Upload 12 files

Dockerfile

@@ -1,16 +1,21 @@
-FROM alpine:latest
-
-# 安装必要的运行时依赖（如果需要）
-RUN apk add --no-cache ca-certificates
-
-WORKDIR /app
-
-# 复制可执行文件并设置权限
-COPY main ./main
-RUN chmod +x main
-
-# 创建非 root 用户（安全最佳实践）
-RUN adduser -D -s /bin/sh main
-USER main
-
-CMD ["./main"]
+FROM node:lts-alpine
+
+# 全局安装PM2
+RUN npm install -g pm2
+
+WORKDIR /app
+
+# 复制package文件
+COPY package*.json ./
+
+# 安装依赖
+RUN npm install
+
+# 复制应用代码
+COPY . .
+
+# 设置权限
+RUN chmod 777 /app
+
+EXPOSE 3000
+CMD ["npm", "start"]

config.js

@@ -0,0 +1,104 @@
+// 配置常量
+const CONFIG = {
+  port:process.env.PORT || 3000,
+
+  endpoint: [
+    {
+      name: 'openai',
+      base_url: 'https://app.factory.ai/api/llm/o/v1/responses'
+    },
+    {
+      name: 'anthropic',
+      base_url: 'https://app.factory.ai/api/llm/a/v1/messages'
+    },
+    {
+      name: 'common',
+      base_url: 'https://app.factory.ai/api/llm/o/v1/chat/completions'
+    }
+  ],
+
+  models: [
+    {
+      id: 'claude-opus-4-1-20250805',
+      type: 'anthropic',
+      reasoning: 'auto'
+    },
+    {
+      id: 'claude-haiku-4-5-20251001',
+      type: 'anthropic',
+      reasoning: 'auto'
+    },
+    {
+      id: 'claude-sonnet-4-5-20250929',
+      type: 'anthropic',
+      reasoning: 'auto'
+    },
+    {
+      id: 'gpt-5-2025-08-07',
+      type: 'openai',
+      reasoning: 'auto'
+    },
+    {
+      id: 'gpt-5-codex',
+      type: 'openai',
+      reasoning: 'off'
+    },
+    {
+      id: 'glm-4.6',
+      type: 'common'
+    }
+  ],
+
+  dev_mode: process.env.DEV_MODE=='true' || false,
+  user_agent: 'factory-cli/0.22.14',
+  system_prompt: 'You are Droid, an AI software engineering agent built by Factory.\n\n'
+}
+
+export function loadConfig() {
+  // 配置已经在代码中定义，无需加载
+  return CONFIG
+}
+
+export function getConfig() {
+  return CONFIG
+}
+
+export function getModelById(modelId) {
+  return CONFIG.models.find(m => m.id === modelId)
+}
+
+export function getEndpointByType(type) {
+  return CONFIG.endpoint.find(e => e.name === type)
+}
+
+export function isDevMode() {
+  return CONFIG.dev_mode === true
+}
+
+export function getPort() {
+  return parseInt(process.env.PORT) || CONFIG.port
+}
+
+export function getSystemPrompt() {
+  return CONFIG.system_prompt || ''
+}
+
+export function getModelReasoning(modelId) {
+  const model = getModelById(modelId)
+  if (!model || !model.reasoning) {
+    return null
+  }
+  const reasoningLevel = model.reasoning.toLowerCase()
+  if (['low', 'medium', 'high', 'auto'].includes(reasoningLevel)) {
+    return reasoningLevel
+  }
+  return null
+}
+
+export function getUserAgent() {
+  return CONFIG.user_agent
+}
+
+export function getProxyUrl() {
+  return process.env.PROXY_URL || null
+}

logger.js

@@ -0,0 +1,40 @@
+import { isDevMode } from './config.js'
+
+export function logInfo(message, data = null) {
+  console.log(`[INFO] ${message}`)
+  if (data && isDevMode()) {
+    console.log(JSON.stringify(data, null, 2))
+  }
+}
+
+export function logDebug(message, data = null) {
+  if (isDevMode()) {
+    console.log(`[DEBUG] ${message}`)
+    if (data) {
+      console.log(JSON.stringify(data, null, 2))
+    }
+  }
+}
+
+export function logError(message, error = null) {
+  console.error(`[ERROR] ${message}`)
+  if (error && isDevMode()) {
+    console.error(error)
+  }
+}
+
+export function logRequest(method, url, headers = null, body = null) {
+  if (isDevMode()) {
+    console.log(`[REQUEST] ${method} ${url}`)
+    if (headers) console.log('[HEADERS]', JSON.stringify(headers, null, 2))
+    if (body) console.log('[BODY]', JSON.stringify(body, null, 2))
+  }
+}
+
+export function logResponse(status, headers = null, body = null) {
+  if (isDevMode()) {
+    console.log(`[RESPONSE] ${status}`)
+    if (headers) console.log('[HEADERS]', JSON.stringify(headers, null, 2))
+    if (body) console.log('[BODY]', JSON.stringify(body, null, 2))
+  }
+}

package.json

@@ -0,0 +1,19 @@
+{
+  "name": "droid2api",
+  "version": "1.3.5",
+  "description": "OpenAI Compatible API Proxy",
+  "main": "server.js",
+  "type": "module",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node server.js"
+  },
+  "keywords": ["openai", "api", "proxy"],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.18.2",
+    "https-proxy-agent": "^7.0.2",
+    "node-fetch": "^3.3.2"
+  }
+}

proxy-manager.js

@@ -0,0 +1,37 @@
+import { HttpsProxyAgent } from 'https-proxy-agent'
+import { getProxyUrl } from './config.js'
+import { logInfo, logError } from './logger.js'
+
+let cachedAgent = null
+let cachedProxyUrl = null
+
+export function getNextProxyAgent(targetUrl) {
+  const proxyUrl = getProxyUrl()
+
+  // 如果没有配置代理，返回 null（直连）
+  if (!proxyUrl) {
+    return null
+  }
+
+  // 如果代理 URL 改变，清除缓存
+  if (proxyUrl !== cachedProxyUrl) {
+    cachedAgent = null
+    cachedProxyUrl = proxyUrl
+  }
+
+  // 如果已有缓存的代理，直接返回
+  if (cachedAgent) {
+    return { agent: cachedAgent, proxy: { url: proxyUrl } }
+  }
+
+  // 创建新的代理
+  try {
+    cachedAgent = new HttpsProxyAgent(proxyUrl)
+    logInfo(`使用代理 ${proxyUrl} 请求 ${targetUrl}`)
+    return { agent: cachedAgent, proxy: { url: proxyUrl } }
+  } catch (error) {
+    logError(`为 ${proxyUrl} 创建代理失败`, error)
+    return null
+  }
+}
+

routes.js

@@ -0,0 +1,608 @@
+import express from 'express'
+import fetch from 'node-fetch'
+import { getConfig, getModelById, getEndpointByType, getSystemPrompt, getModelReasoning } from './config.js'
+import { logError, logRequest, logResponse } from './logger.js'
+import { transformToAnthropic, getAnthropicHeaders } from './transformers/request-anthropic.js'
+import { transformToOpenAI, getOpenAIHeaders } from './transformers/request-openai.js'
+import { transformToCommon, getCommonHeaders } from './transformers/request-common.js'
+import { AnthropicResponseTransformer } from './transformers/response-anthropic.js'
+import { OpenAIResponseTransformer } from './transformers/response-openai.js'
+import { getNextProxyAgent } from './proxy-manager.js'
+
+/**
+ * 从请求头获取认证信息
+ */
+function getAuthHeader(req) {
+  return req.headers.authorization || req.headers.Authorization || req.headers['x-api-key']
+}
+
+const router = express.Router();
+
+/**
+ * 将 /v1/responses API 结果转换为 /v1/chat/completions 兼容格式
+ * 适用于非流式响应
+ */
+function convertResponseToChatCompletion(resp) {
+    if (!resp || typeof resp !== 'object') {
+        throw new Error('Invalid response object');
+    }
+
+    const outputMsg = (resp.output || []).find(o => o.type === 'message');
+    const textBlocks = outputMsg?.content?.filter(c => c.type === 'output_text') || [];
+    const content = textBlocks.map(c => c.text).join('');
+
+    const chatCompletion = {
+        id: resp.id ? resp.id.replace(/^resp_/, 'chatcmpl-') : `chatcmpl-${Date.now()}`,
+        object: 'chat.completion',
+        created: resp.created_at || Math.floor(Date.now() / 1000),
+        model: resp.model || 'unknown-model',
+        choices: [
+            {
+                index: 0,
+                message: {
+                    role: outputMsg?.role || 'assistant',
+                    content: content || ''
+                },
+                finish_reason: resp.status === 'completed' ? 'stop' : 'unknown'
+            }
+        ],
+        usage: {
+            prompt_tokens: resp.usage?.input_tokens ?? 0,
+            completion_tokens: resp.usage?.output_tokens ?? 0,
+            total_tokens: resp.usage?.total_tokens ?? 0
+        }
+    };
+
+    return chatCompletion;
+}
+
+router.get('/v1/models', (req, res) => {
+    try {
+        const config = getConfig()
+        const models = config.models.map(model => ({
+            id: model.id,
+            object: 'model',
+            created: Date.now(),
+            owned_by: model.type,
+            permission: [],
+            root: model.id,
+            parent: null
+        }))
+
+        res.json({
+            object: 'list',
+            data: models
+        })
+    } catch (error) {
+        logError('GET /v1/models', error)
+        res.status(500).json({ error: 'Internal server error' })
+    }
+})
+
+// 标准 OpenAI 聊天补全处理函数（带格式转换）
+async function handleChatCompletions(req, res) {
+    try {
+        const openaiRequest = req.body
+        const modelId = openaiRequest.model
+
+        if (!modelId) {
+            return res.status(400).json({ error: '需要提供 model 参数' })
+        }
+
+        const model = getModelById(modelId)
+        if (!model) {
+            return res.status(404).json({ error: `未找到模型 ${modelId}` })
+        }
+
+        const endpoint = getEndpointByType(model.type)
+        if (!endpoint) {
+            return res.status(500).json({ error: `未找到端点类型 ${model.type}` })
+        }
+
+        // 获取认证信息
+        const authHeader = getAuthHeader(req)
+        if (!authHeader) {
+            return res.status(401).json({
+                error: '未提供认证信息',
+                message: '请在请求头中提供 Authorization 或 x-api-key'
+            })
+        }
+
+        let transformedRequest
+        let headers
+        const clientHeaders = req.headers
+
+        // 转换请求格式
+        if (model.type === 'anthropic') {
+            transformedRequest = transformToAnthropic(openaiRequest)
+            const isStreaming = openaiRequest.stream === true
+            headers = getAnthropicHeaders(authHeader, clientHeaders, isStreaming, modelId)
+        } else if (model.type === 'openai') {
+            transformedRequest = transformToOpenAI(openaiRequest)
+            headers = getOpenAIHeaders(authHeader, clientHeaders)
+        } else if (model.type === 'common') {
+            transformedRequest = transformToCommon(openaiRequest)
+            headers = getCommonHeaders(authHeader, clientHeaders)
+        } else {
+            return res.status(500).json({ error: `未知的端点类型: ${model.type}` })
+        }
+
+        logRequest('POST', endpoint.base_url, headers, transformedRequest)
+
+        const proxyAgentInfo = getNextProxyAgent(endpoint.base_url)
+        const fetchOptions = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(transformedRequest)
+        }
+
+        if (proxyAgentInfo?.agent) {
+            fetchOptions.agent = proxyAgentInfo.agent
+        }
+
+        const response = await fetch(endpoint.base_url, fetchOptions)
+
+        if (!response.ok) {
+            const errorText = await response.text()
+            logError(`端点错误: ${response.status}`, new Error(errorText))
+            return res.status(response.status).json({
+                error: `端点返回 ${response.status}`,
+                details: errorText
+            })
+        }
+
+        const isStreaming = transformedRequest.stream === true
+
+        if (isStreaming) {
+            res.setHeader('Content-Type', 'text/event-stream')
+            res.setHeader('Cache-Control', 'no-cache')
+            res.setHeader('Connection', 'keep-alive')
+
+            // common 类型直接转发，不使用 transformer
+            if (model.type === 'common') {
+                try {
+                    for await (const chunk of response.body) {
+                        res.write(chunk)
+                    }
+                    res.end()
+                } catch (streamError) {
+                    logError('流错误', streamError)
+                    res.end()
+                }
+            } else {
+                // anthropic 和 openai 类型使用 transformer
+                let transformer
+                if (model.type === 'anthropic') {
+                    transformer = new AnthropicResponseTransformer(modelId, `chatcmpl-${Date.now()}`)
+                } else if (model.type === 'openai') {
+                    transformer = new OpenAIResponseTransformer(modelId, `chatcmpl-${Date.now()}`)
+                }
+
+                try {
+                    for await (const chunk of transformer.transformStream(response.body)) {
+                        res.write(chunk)
+                    }
+                    res.end()
+                } catch (streamError) {
+                    logError('流错误', streamError)
+                    res.end()
+                }
+            }
+        } else {
+            const data = await response.json()
+            if (model.type === 'openai') {
+                try {
+                    const converted = convertResponseToChatCompletion(data)
+                    logResponse(200, null, converted)
+                    res.json(converted)
+                } catch (e) {
+                    logResponse(200, null, data)
+                    res.json(data)
+                }
+            } else {
+                logResponse(200, null, data)
+                res.json(data)
+            }
+        }
+
+    } catch (error) {
+        logError('/v1/chat/completions', error)
+        res.status(500).json({
+            error: '内部服务器错误',
+            message: error.message
+        })
+    }
+}
+
+// 直接转发 OpenAI 请求（不做格式转换）
+async function handleDirectResponses(req, res) {
+    try {
+        const openaiRequest = req.body
+        const modelId = openaiRequest.model
+
+        if (!modelId) {
+            return res.status(400).json({ error: '需要提供 model 参数' })
+        }
+
+        const model = getModelById(modelId)
+        if (!model) {
+            return res.status(404).json({ error: `未找到模型 ${modelId}` })
+        }
+
+        // 只允许 openai 类型端点
+        if (model.type !== 'openai') {
+            return res.status(400).json({
+                error: '无效的端点类型',
+                message: `/v1/responses 接口只支持 openai 类型端点，当前模型 ${modelId} 是 ${model.type} 类型`
+            })
+        }
+
+        const endpoint = getEndpointByType(model.type)
+        if (!endpoint) {
+            return res.status(500).json({ error: `未找到端点类型 ${model.type}` })
+        }
+
+        // 获取认证信息
+        const authHeader = getAuthHeader(req);
+        if (!authHeader) {
+            return res.status(401).json({
+                error: '未提供认证信息',
+                message: '请在请求头中提供 Authorization 或 x-api-key'
+            });
+        }
+
+        // 如果是 x-api-key，转换为 Bearer 格式
+        const finalAuthHeader = authHeader.startsWith('Bearer ')
+            ? authHeader
+            : `Bearer ${authHeader}`;
+
+        const clientHeaders = req.headers;
+
+        // 获取 headers
+        const headers = getOpenAIHeaders(finalAuthHeader, clientHeaders);
+
+        // 注入系统提示到 instructions 字段
+        const systemPrompt = getSystemPrompt();
+        const modifiedRequest = { ...openaiRequest };
+        if (systemPrompt) {
+            // 如果已有 instructions，则在前面添加系统提示
+            if (modifiedRequest.instructions) {
+                modifiedRequest.instructions = systemPrompt + modifiedRequest.instructions;
+            } else {
+                // 否则直接设置系统提示
+                modifiedRequest.instructions = systemPrompt;
+            }
+        }
+
+        // 处理reasoning字段
+        const reasoningLevel = getModelReasoning(modelId);
+        if (reasoningLevel === 'auto') {
+            // Auto模式：保持原始请求的reasoning字段不变
+            // 如果原始请求有reasoning字段就保留，没有就不添加
+        } else if (reasoningLevel && ['low', 'medium', 'high'].includes(reasoningLevel)) {
+            modifiedRequest.reasoning = {
+                effort: reasoningLevel,
+                summary: 'auto'
+            };
+        } else {
+            // 如果配置是off或无效，移除reasoning字段
+            delete modifiedRequest.reasoning;
+        }
+
+        logRequest('POST', endpoint.base_url, headers, modifiedRequest)
+
+        const proxyAgentInfo = getNextProxyAgent(endpoint.base_url)
+        const fetchOptions = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(modifiedRequest)
+        }
+
+        if (proxyAgentInfo?.agent) {
+            fetchOptions.agent = proxyAgentInfo.agent
+        }
+
+        const response = await fetch(endpoint.base_url, fetchOptions)
+
+        if (!response.ok) {
+            const errorText = await response.text()
+            logError(`端点错误: ${response.status}`, new Error(errorText))
+            return res.status(response.status).json({
+                error: `端点返回 ${response.status}`,
+                details: errorText
+            })
+        }
+
+        const isStreaming = openaiRequest.stream === true
+
+        if (isStreaming) {
+            res.setHeader('Content-Type', 'text/event-stream')
+            res.setHeader('Cache-Control', 'no-cache')
+            res.setHeader('Connection', 'keep-alive')
+
+            try {
+                for await (const chunk of response.body) {
+                    res.write(chunk)
+                }
+                res.end()
+            } catch (streamError) {
+                logError('流错误', streamError)
+                res.end()
+            }
+        } else {
+            const data = await response.json()
+            logResponse(200, null, data)
+            res.json(data)
+        }
+
+    } catch (error) {
+        logError('/v1/responses', error)
+        res.status(500).json({
+            error: '内部服务器错误',
+            message: error.message
+        })
+    }
+}
+
+// 直接转发 Anthropic 请求（不做格式转换）
+async function handleDirectMessages(req, res) {
+    logInfo('POST /v1/messages');
+
+    try {
+        const anthropicRequest = req.body;
+        const modelId = anthropicRequest.model;
+
+        if (!modelId) {
+            return res.status(400).json({ error: '需要提供 model 参数' });
+        }
+
+        const model = getModelById(modelId);
+        if (!model) {
+            return res.status(404).json({ error: `未找到模型 ${modelId}` });
+        }
+
+        // 只允许 anthropic 类型端点
+        if (model.type !== 'anthropic') {
+            return res.status(400).json({
+                error: '无效的端点类型',
+                message: `/v1/messages 接口只支持 anthropic 类型端点，当前模型 ${modelId} 是 ${model.type} 类型`
+            });
+        }
+
+        const endpoint = getEndpointByType(model.type);
+        if (!endpoint) {
+            return res.status(500).json({ error: `未找到端点类型 ${model.type}` });
+        }
+
+        logInfo(`直接转发到 ${model.type} 端点: ${endpoint.base_url}`);
+
+        // 获取认证信息
+        const authHeader = getAuthHeader(req);
+        if (!authHeader) {
+            return res.status(401).json({
+                error: '未提供认证信息',
+                message: '请在请求头中提供 Authorization 或 x-api-key'
+            });
+        }
+
+        // 如果是 x-api-key，转换为 Bearer 格式
+        const finalAuthHeader = authHeader.startsWith('Bearer ')
+            ? authHeader
+            : `Bearer ${authHeader}`;
+
+        const clientHeaders = req.headers;
+
+        // 获取 headers
+        const isStreaming = anthropicRequest.stream === true;
+        const headers = getAnthropicHeaders(finalAuthHeader, clientHeaders, isStreaming, modelId);
+
+        // 注入系统提示到 system 字段
+        const systemPrompt = getSystemPrompt();
+        const modifiedRequest = { ...anthropicRequest };
+
+        // 清理cc中的 "You are Claude Code, Anthropic's official CLI for Claude."
+        if (modifiedRequest.system && Array.isArray(modifiedRequest.system)) {
+            for (const msg of modifiedRequest.system) {
+                if (msg.type === 'text') {
+                    msg.text = msg.text.replace("You are Claude Code, Anthropic's official CLI for Claude.", 'you are bot.');
+                }
+            }
+        }
+
+        if (systemPrompt) {
+            if (modifiedRequest.system && Array.isArray(modifiedRequest.system)) {
+                // 如果已有 system 数组，则在最前面插入系统提示
+                modifiedRequest.system = [
+                    { type: 'text', text: systemPrompt },
+                    ...modifiedRequest.system
+                ];
+            } else {
+                // 否则创建新的 system 数组
+                modifiedRequest.system = [
+                    { type: 'text', text: systemPrompt }
+                ];
+            }
+        }
+
+        // 处理thinking字段
+        const reasoningLevel = getModelReasoning(modelId);
+        if (reasoningLevel === 'auto') {
+            // Auto模式：保持原始请求的thinking字段不变
+            // 如果原始请求有thinking字段就保留，没有就不添加
+        } else if (reasoningLevel && ['low', 'medium', 'high'].includes(reasoningLevel)) {
+            const budgetTokens = {
+                'low': 4096,
+                'medium': 12288,
+                'high': 24576
+            };
+
+            modifiedRequest.thinking = {
+                type: 'enabled',
+                budget_tokens: budgetTokens[reasoningLevel]
+            };
+        } else {
+            // 如果配置是off或无效，移除thinking字段
+            delete modifiedRequest.thinking;
+        }
+
+        logRequest('POST', endpoint.base_url, headers, modifiedRequest);
+        // console.log(modifiedRequest);
+
+        // 转发修改后的请求
+        const proxyAgentInfo = getNextProxyAgent(endpoint.base_url);
+        const fetchOptions = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(modifiedRequest)
+        };
+
+        if (proxyAgentInfo?.agent) {
+            fetchOptions.agent = proxyAgentInfo.agent;
+        }
+
+        const response = await fetch(endpoint.base_url, fetchOptions);
+
+        logInfo(`响应状态: ${response.status}`);
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            logError(`端点错误: ${response.status}`, new Error(errorText));
+            return res.status(response.status).json({
+                error: `端点返回 ${response.status}`,
+                details: errorText
+            });
+        }
+
+        if (isStreaming) {
+            // 直接转发流式响应，不做任何转换
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+
+            try {
+                // 直接将原始响应流转发给客户端
+                for await (const chunk of response.body) {
+                    res.write(chunk);
+                }
+                res.end();
+                logInfo('流转发成功');
+            } catch (streamError) {
+                logError('流错误', streamError);
+                res.end();
+            }
+        } else {
+            // 直接转发非流式响应，不做任何转换
+            const data = await response.json();
+            logResponse(200, null, data);
+            res.json(data);
+        }
+
+    } catch (error) {
+        logError('/v1/messages 错误', error);
+        res.status(500).json({
+            error: '内部服务器错误',
+            message: error.message
+        });
+    }
+}
+
+// 处理 Anthropic count_tokens 请求
+async function handleCountTokens(req, res) {
+    logInfo('POST /v1/messages/count_tokens');
+
+    try {
+        const anthropicRequest = req.body;
+        const modelId = anthropicRequest.model;
+
+        if (!modelId) {
+            return res.status(400).json({ error: '需要提供 model 参数' });
+        }
+
+        const model = getModelById(modelId);
+        if (!model) {
+            return res.status(404).json({ error: `未找到模型 ${modelId}` });
+        }
+
+        // 只允许 anthropic 类型端点
+        if (model.type !== 'anthropic') {
+            return res.status(400).json({
+                error: '无效的端点类型',
+                message: `/v1/messages/count_tokens 接口只支持 anthropic 类型端点，当前模型 ${modelId} 是 ${model.type} 类型`
+            });
+        }
+
+        const endpoint = getEndpointByType('anthropic');
+        if (!endpoint) {
+            return res.status(500).json({ error: '未找到端点类型 anthropic' });
+        }
+
+        // 获取认证信息
+        const authHeader = getAuthHeader(req);
+        if (!authHeader) {
+            return res.status(401).json({
+                error: '未提供认证信息',
+                message: '请在请求头中提供 Authorization 或 x-api-key'
+            });
+        }
+
+        // 如果是 x-api-key，转换为 Bearer 格式
+        const finalAuthHeader = authHeader.startsWith('Bearer ')
+            ? authHeader
+            : `Bearer ${authHeader}`;
+
+        const clientHeaders = req.headers;
+        const headers = getAnthropicHeaders(finalAuthHeader, clientHeaders, false, modelId);
+
+        // 构建 count_tokens 端点 URL
+        const countTokensUrl = endpoint.base_url.replace('/v1/messages', '/v1/messages/count_tokens');
+
+        // 使用原始请求体
+        const modifiedRequest = { ...anthropicRequest };
+
+        logInfo(`转发到 count_tokens 端点: ${countTokensUrl}`);
+        logRequest('POST', countTokensUrl, headers, modifiedRequest);
+
+        const proxyAgentInfo = getNextProxyAgent(countTokensUrl);
+        const fetchOptions = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(modifiedRequest)
+        };
+
+        if (proxyAgentInfo?.agent) {
+            fetchOptions.agent = proxyAgentInfo.agent;
+        }
+
+        const response = await fetch(countTokensUrl, fetchOptions);
+
+        logInfo(`响应状态: ${response.status}`);
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            logError(`计数令牌错误: ${response.status}`, new Error(errorText));
+            return res.status(response.status).json({
+                error: `端点返回 ${response.status}`,
+                details: errorText
+            });
+        }
+
+        const data = await response.json();
+        logResponse(200, null, data);
+        res.json(data);
+
+    } catch (error) {
+        logError('/v1/messages/count_tokens 错误', error);
+        res.status(500).json({
+            error: '内部服务器错误',
+            message: error.message
+        });
+    }
+}
+
+// 注册路由
+router.post('/v1/chat/completions', handleChatCompletions);
+router.post('/v1/responses', handleDirectResponses);
+router.post('/v1/messages', handleDirectMessages);
+router.post('/v1/messages/count_tokens', handleCountTokens);
+
+export default router;

server.js

@@ -0,0 +1,69 @@
+import express from 'express'
+import { loadConfig, isDevMode, getPort } from './config.js'
+import { logError } from './logger.js'
+import router from './routes.js'
+
+const app = express();
+
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({ extended: true, limit: '50mb' }));
+
+app.use((req, res, next) => {
+  res.header('Access-Control-Allow-Origin', '*');
+  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+  res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key, anthropic-version');
+  
+  if (req.method === 'OPTIONS') {
+    return res.sendStatus(200);
+  }
+  next();
+});
+
+app.use(router);
+
+app.get('/', (req, res) => {
+  res.redirect('https://www.bilibili.com/video/BV1SMH5zfEwe/?spm_id_from=333.1007.tianma.1-1-1.click&vd_source=1f3b8eb28230105c578a443fa6481550')
+})
+
+
+// 错误处理中间件
+app.use((err, req, res, next) => {
+  logError('未处理的错误', err);
+  res.status(500).json({
+    error: '内部服务器错误',
+    message: isDevMode() ? err.message : undefined
+  });
+});
+
+(async () => {
+  try {
+    loadConfig()
+    const PORT = getPort()
+
+    const server = app.listen(PORT)
+    .on('listening', () => {
+      console.log(`服务器运行在 http://localhost:${PORT}`)
+    })
+    .on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        console.error(`\n${'='.repeat(80)}`);
+        console.error(`错误: 端口 ${PORT} 已被占用!`);
+        console.error('');
+        console.error('请选择以下选项之一:');
+        console.error(`  1. 停止使用端口 ${PORT} 的进程:`);
+        console.error(`     lsof -ti:${PORT} | xargs kill`);
+        console.error('');
+        console.error('  2. 使用环境变量更改端口:');
+        console.error('     export PORT=8080');
+        console.error(`${'='.repeat(80)}\n`);
+        process.exit(1);
+      } else {
+        logError('启动服务器失败', err);
+        process.exit(1);
+      }
+    });
+  } catch (error) {
+    logError('启动服务器失败', error);
+    process.exit(1);
+  }
+})();

transformers/request-anthropic.js

@@ -0,0 +1,242 @@
+import { logDebug } from '../logger.js';
+import { getSystemPrompt, getModelReasoning, getUserAgent } from '../config.js';
+
+export function transformToAnthropic(openaiRequest) {
+  logDebug('将 OpenAI 请求转换为 Anthropic 格式');
+  
+  const anthropicRequest = {
+    model: openaiRequest.model,
+    messages: []
+  };
+
+  // 仅在客户端明确提供时添加 stream 参数
+  if (openaiRequest.stream !== undefined) {
+    anthropicRequest.stream = openaiRequest.stream;
+  }
+
+  // 处理 max_tokens
+  if (openaiRequest.max_tokens) {
+    anthropicRequest.max_tokens = openaiRequest.max_tokens;
+  } else if (openaiRequest.max_completion_tokens) {
+    anthropicRequest.max_tokens = openaiRequest.max_completion_tokens;
+  } else {
+    anthropicRequest.max_tokens = 4096;
+  }
+
+  // 提取系统消息并转换其他消息
+  let systemContent = [];
+
+  if (openaiRequest.messages && Array.isArray(openaiRequest.messages)) {
+    for (const msg of openaiRequest.messages) {
+      // 单独处理系统消息
+      if (msg.role === 'system') {
+        if (typeof msg.content === 'string') {
+          systemContent.push({
+            type: 'text',
+            text: msg.content?.replace("You are Claude Code, Anthropic's official CLI for Claude.", 'you are bot.')
+          });
+        } else if (Array.isArray(msg.content)) {
+          for (const part of msg.content) {
+            if (part.type === 'text') {
+              systemContent.push({
+                type: 'text',
+                text: part.text?.replace("You are Claude Code, Anthropic's official CLI for Claude.", 'you are bot.')
+              });
+            } else {
+              systemContent.push(part);
+            }
+          }
+        }
+        continue; // 跳过将系统消息添加到消息数组
+      }
+
+      const anthropicMsg = {
+        role: msg.role,
+        content: []
+      };
+
+      if (typeof msg.content === 'string') {
+        anthropicMsg.content.push({
+          type: 'text',
+          text: msg.content
+        });
+      } else if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (part.type === 'text') {
+            anthropicMsg.content.push({
+              type: 'text',
+              text: part.text
+            });
+          } else if (part.type === 'image_url') {
+            anthropicMsg.content.push({
+              type: 'image',
+              source: part.image_url
+            });
+          } else {
+            anthropicMsg.content.push(part);
+          }
+        }
+      }
+
+      anthropicRequest.messages.push(anthropicMsg);
+    }
+  }
+
+  // 添加系统参数，并在前面加上系统提示
+  const systemPrompt = getSystemPrompt();
+  if (systemPrompt || systemContent.length > 0) {
+    anthropicRequest.system = [];
+    // 如果存在系统提示，则将其作为第一个元素添加
+    if (systemPrompt) {
+      anthropicRequest.system.push({
+        type: 'text',
+        text: systemPrompt
+      });
+    }
+    // 添加用户提供的系统内容
+    anthropicRequest.system.push(...systemContent);
+  }
+
+  // 如果存在工具，则进行转换
+  if (openaiRequest.tools && Array.isArray(openaiRequest.tools)) {
+    anthropicRequest.tools = openaiRequest.tools.map(tool => {
+      if (tool.type === 'function') {
+        return {
+          name: tool.function.name,
+          description: tool.function.description,
+          input_schema: tool.function.parameters || {}
+        };
+      }
+      return tool;
+    });
+  }
+
+  // 根据模型配置处理 thinking 字段
+  const reasoningLevel = getModelReasoning(openaiRequest.model);
+  if (reasoningLevel === 'auto') {
+    // 自动模式：完全保留原始请求的 thinking 字段
+    if (openaiRequest.thinking !== undefined) {
+      anthropicRequest.thinking = openaiRequest.thinking;
+    }
+    // 如果原始请求没有 thinking 字段，则不添加
+  } else if (reasoningLevel && ['low', 'medium', 'high'].includes(reasoningLevel)) {
+    // 特定级别：使用模型配置覆盖
+    const budgetTokens = {
+      'low': 4096,
+      'medium': 12288,
+      'high': 24576
+    };
+
+    anthropicRequest.thinking = {
+      type: 'enabled',
+      budget_tokens: budgetTokens[reasoningLevel]
+    };
+  } else {
+    // 关闭或无效：显式删除 thinking 字段
+    // 这确保删除原始请求中的任何 thinking 字段
+    delete anthropicRequest.thinking;
+  }
+
+  // 传递其他兼容参数
+  if (openaiRequest.temperature !== undefined) {
+    anthropicRequest.temperature = openaiRequest.temperature;
+  }
+  if (openaiRequest.top_p !== undefined) {
+    anthropicRequest.top_p = openaiRequest.top_p;
+  }
+  if (openaiRequest.stop !== undefined) {
+    anthropicRequest.stop_sequences = Array.isArray(openaiRequest.stop)
+      ? openaiRequest.stop
+      : [openaiRequest.stop];
+  }
+
+  logDebug('已转换的 Anthropic 请求', anthropicRequest);
+  return anthropicRequest;
+}
+
+export function getAnthropicHeaders(authHeader, clientHeaders = {}, isStreaming = true, modelId = null) {
+  // 如果未提供则生成唯一 ID
+  const sessionId = clientHeaders['x-session-id'] || generateUUID();
+  const messageId = clientHeaders['x-assistant-message-id'] || generateUUID();
+
+  const headers = {
+    'accept': 'application/json',
+    'content-type': 'application/json',
+    'anthropic-version': clientHeaders['anthropic-version'] || '2023-06-01',
+    'authorization': authHeader || '',
+    'x-api-key': 'placeholder',
+    'x-api-provider': 'anthropic',
+    'x-factory-client': 'cli',
+    'x-session-id': sessionId,
+    'x-assistant-message-id': messageId,
+    'user-agent': getUserAgent(),
+    'x-stainless-timeout': '600',
+    'connection': 'keep-alive'
+  }
+
+  // 根据推理配置处理 anthropic-beta 头
+  const reasoningLevel = modelId ? getModelReasoning(modelId) : null;
+  let betaValues = [];
+
+  // 从客户端头添加现有的 beta 值
+  if (clientHeaders['anthropic-beta']) {
+    const existingBeta = clientHeaders['anthropic-beta'];
+    betaValues = existingBeta.split(',').map(v => v.trim());
+  }
+
+  // 根据推理配置处理 thinking beta
+  const thinkingBeta = 'interleaved-thinking-2025-05-14';
+  if (reasoningLevel === 'auto') {
+    // 自动模式：不修改 anthropic-beta 头，保留原始值
+    // betaValues 保持客户端头的不变
+  } else if (reasoningLevel && ['low', 'medium', 'high'].includes(reasoningLevel)) {
+    // 如果尚未存在，则添加 thinking beta
+    if (!betaValues.includes(thinkingBeta)) {
+      betaValues.push(thinkingBeta);
+    }
+  } else {
+    // 如果推理关闭或无效，则删除 thinking beta
+    betaValues = betaValues.filter(v => v !== thinkingBeta);
+  }
+
+  // 如果有任何值，则设置 anthropic-beta 头
+  if (betaValues.length > 0) {
+    headers['anthropic-beta'] = betaValues.join(', ');
+  }
+
+  // 使用默认值传递 Stainless SDK 头
+  const stainlessDefaults = {
+    'x-stainless-arch': 'x64',
+    'x-stainless-lang': 'js',
+    'x-stainless-os': 'MacOS',
+    'x-stainless-runtime': 'node',
+    'x-stainless-retry-count': '0',
+    'x-stainless-package-version': '0.57.0',
+    'x-stainless-runtime-version': 'v24.3.0'
+  };
+
+  // 根据流式传输设置 helper-method
+  if (isStreaming) {
+    headers['x-stainless-helper-method'] = 'stream';
+  }
+
+  // 从客户端复制 Stainless 头或使用默认值
+  Object.keys(stainlessDefaults).forEach(header => {
+    headers[header] = clientHeaders[header] || stainlessDefaults[header];
+  });
+
+  // 如果客户端提供，则覆盖默认超时
+  if (clientHeaders['x-stainless-timeout']) {
+    headers['x-stainless-timeout'] = clientHeaders['x-stainless-timeout'];
+  }
+
+  return headers;
+}
+
+function generateUUID() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c == 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}

transformers/request-common.js

@@ -0,0 +1,88 @@
+import { logDebug } from '../logger.js';
+import { getSystemPrompt, getUserAgent } from '../config.js';
+
+export function transformToCommon(openaiRequest) {
+  logDebug('将 OpenAI 请求转换为通用格式');
+
+  // 基本保持 OpenAI 格式，只在 messages 前面插入 system 消息
+  const commonRequest = {
+    ...openaiRequest
+  };
+
+  const systemPrompt = getSystemPrompt();
+
+  if (systemPrompt) {
+    // 检查是否已有 system 消息
+    const hasSystemMessage = commonRequest.messages?.some(m => m.role === 'system');
+
+    if (hasSystemMessage) {
+      // 如果已有 system 消息，在第一个 system 消息前插入我们的 system prompt
+      commonRequest.messages = commonRequest.messages.map((msg, index) => {
+        if (msg.role === 'system' && index === commonRequest.messages.findIndex(m => m.role === 'system')) {
+          // 找到第一个 system 消息，前置我们的 prompt
+          return {
+            role: 'system',
+            content: systemPrompt + (typeof msg.content === 'string' ? msg.content?.replace("You are Claude Code, Anthropic's official CLI for Claude.", 'you are bot.') : '')
+          };
+        }
+        return msg;
+      });
+    } else {
+      // 如果没有 system 消息，在 messages 数组最前面插入
+      commonRequest.messages = [
+        {
+          role: 'system',
+          content: systemPrompt
+        },
+        ...(commonRequest.messages || [])
+      ];
+    }
+  }
+
+  logDebug('已转换的通用请求', commonRequest);
+  return commonRequest;
+}
+
+export function getCommonHeaders(authHeader, clientHeaders = {}) {
+  // 如果未提供则生成唯一 ID
+  const sessionId = clientHeaders['x-session-id'] || generateUUID();
+  const messageId = clientHeaders['x-assistant-message-id'] || generateUUID();
+  
+  const headers = {
+    'accept': 'application/json',
+    'content-type': 'application/json',
+    'authorization': authHeader || '',
+    'x-api-provider': 'baseten',
+    'x-factory-client': 'cli',
+    'x-session-id': sessionId,
+    'x-assistant-message-id': messageId,
+    'user-agent': getUserAgent(),
+    'connection': 'keep-alive'
+  };
+
+  // 使用默认值传递 Stainless SDK 头
+  const stainlessDefaults = {
+    'x-stainless-arch': 'x64',
+    'x-stainless-lang': 'js',
+    'x-stainless-os': 'MacOS',
+    'x-stainless-runtime': 'node',
+    'x-stainless-retry-count': '0',
+    'x-stainless-package-version': '5.23.2',
+    'x-stainless-runtime-version': 'v24.3.0'
+  };
+
+  // 从客户端复制 Stainless 头或使用默认值
+  Object.keys(stainlessDefaults).forEach(header => {
+    headers[header] = clientHeaders[header] || stainlessDefaults[header];
+  });
+
+  return headers;
+}
+
+function generateUUID() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c == 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}

transformers/request-openai.js

@@ -0,0 +1,177 @@
+import { logDebug } from '../logger.js';
+import { getSystemPrompt, getModelReasoning, getUserAgent } from '../config.js';
+
+export function transformToOpenAI(openaiRequest) {
+  logDebug('将 OpenAI 请求转换为目标 OpenAI 格式');
+
+  const targetRequest = {
+    model: openaiRequest.model,
+    input: [],
+    store: false
+  };
+
+  // 仅在客户端明确提供时添加 stream 参数
+  if (openaiRequest.stream !== undefined) {
+    targetRequest.stream = openaiRequest.stream;
+  }
+
+  // 将 max_tokens 转换为 max_output_tokens
+  if (openaiRequest.max_tokens) {
+    targetRequest.max_output_tokens = openaiRequest.max_tokens;
+  } else if (openaiRequest.max_completion_tokens) {
+    targetRequest.max_output_tokens = openaiRequest.max_completion_tokens;
+  }
+
+  // Transform messages to input
+  if (openaiRequest.messages && Array.isArray(openaiRequest.messages)) {
+    for (const msg of openaiRequest.messages) {
+      const inputMsg = {
+        role: msg.role,
+        content: []
+      };
+
+      // Determine content type based on role
+      // user role uses 'input_text', assistant role uses 'output_text'
+      const textType = msg.role === 'assistant' ? 'output_text' : 'input_text';
+      const imageType = msg.role === 'assistant' ? 'output_image' : 'input_image';
+
+      if (typeof msg.content === 'string') {
+        inputMsg.content.push({
+          type: textType,
+          text: msg.content?.replace("You are Claude Code, Anthropic's official CLI for Claude.", 'you are bot.')
+        });
+      } else if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (part.type === 'text') {
+            inputMsg.content.push({
+              type: textType,
+              text: part.text?.replace("You are Claude Code, Anthropic's official CLI for Claude.", 'you are bot.')
+            });
+          } else if (part.type === 'image_url') {
+            inputMsg.content.push({
+              type: imageType,
+              image_url: part.image_url
+            });
+          } else {
+            // Pass through other types as-is
+            inputMsg.content.push(part);
+          }
+        }
+      }
+
+      targetRequest.input.push(inputMsg);
+    }
+  }
+
+  // Transform tools if present
+  if (openaiRequest.tools && Array.isArray(openaiRequest.tools)) {
+    targetRequest.tools = openaiRequest.tools.map(tool => ({
+      ...tool,
+      strict: false
+    }));
+  }
+
+  // Extract system message as instructions and prepend system prompt
+  const systemPrompt = getSystemPrompt();
+  const systemMessage = openaiRequest.messages?.find(m => m.role === 'system');
+  
+  if (systemMessage) {
+    let userInstructions = '';
+    if (typeof systemMessage.content === 'string') {
+      userInstructions = systemMessage.content;
+    } else if (Array.isArray(systemMessage.content)) {
+      userInstructions = systemMessage.content
+        .filter(p => p.type === 'text')
+        .map(p => p.text)
+        .join('\n');
+    }
+    targetRequest.instructions = systemPrompt + userInstructions;
+    targetRequest.input = targetRequest.input.filter(m => m.role !== 'system');
+  } else if (systemPrompt) {
+    // If no user-provided system message, just add the system prompt
+    targetRequest.instructions = systemPrompt;
+  }
+
+  // 根据模型配置处理 reasoning 字段
+  const reasoningLevel = getModelReasoning(openaiRequest.model);
+  if (reasoningLevel === 'auto') {
+    // 自动模式：完全保留原始请求的 reasoning 字段
+    if (openaiRequest.reasoning !== undefined) {
+      targetRequest.reasoning = openaiRequest.reasoning;
+    }
+    // 如果原始请求没有 reasoning 字段，则不添加
+  } else if (reasoningLevel && ['low', 'medium', 'high'].includes(reasoningLevel)) {
+    // 特定级别：使用模型配置覆盖
+    targetRequest.reasoning = {
+      effort: reasoningLevel,
+      summary: 'auto'
+    };
+  } else {
+    // 关闭或无效：显式删除 reasoning 字段
+    // 这确保删除原始请求中的任何 reasoning 字段
+    delete targetRequest.reasoning;
+  }
+
+  // Pass through other parameters
+  if (openaiRequest.temperature !== undefined) {
+    targetRequest.temperature = openaiRequest.temperature;
+  }
+  if (openaiRequest.top_p !== undefined) {
+    targetRequest.top_p = openaiRequest.top_p;
+  }
+  if (openaiRequest.presence_penalty !== undefined) {
+    targetRequest.presence_penalty = openaiRequest.presence_penalty;
+  }
+  if (openaiRequest.frequency_penalty !== undefined) {
+    targetRequest.frequency_penalty = openaiRequest.frequency_penalty;
+  }
+  if (openaiRequest.parallel_tool_calls !== undefined) {
+    targetRequest.parallel_tool_calls = openaiRequest.parallel_tool_calls;
+  }
+
+  logDebug('已转换的目标 OpenAI 请求', targetRequest);
+  return targetRequest;
+}
+
+export function getOpenAIHeaders(authHeader, clientHeaders = {}) {
+  // 如果未提供则生成唯一 ID
+  const sessionId = clientHeaders['x-session-id'] || generateUUID();
+  const messageId = clientHeaders['x-assistant-message-id'] || generateUUID();
+  
+  const headers = {
+    'content-type': 'application/json',
+    'authorization': authHeader || '',
+    'x-api-provider': 'azure_openai',
+    'x-factory-client': 'cli',
+    'x-session-id': sessionId,
+    'x-assistant-message-id': messageId,
+    'user-agent': getUserAgent(),
+    'connection': 'keep-alive'
+  };
+
+  // Pass through Stainless SDK headers with defaults
+  const stainlessDefaults = {
+    'x-stainless-arch': 'x64',
+    'x-stainless-lang': 'js',
+    'x-stainless-os': 'MacOS',
+    'x-stainless-runtime': 'node',
+    'x-stainless-retry-count': '0',
+    'x-stainless-package-version': '5.23.2',
+    'x-stainless-runtime-version': 'v24.3.0'
+  };
+
+  // Copy Stainless headers from client or use defaults
+  Object.keys(stainlessDefaults).forEach(header => {
+    headers[header] = clientHeaders[header] || stainlessDefaults[header];
+  });
+
+  return headers;
+}
+
+function generateUUID() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c == 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}

transformers/response-anthropic.js

@@ -0,0 +1,138 @@
+import { logDebug } from '../logger.js';
+
+export class AnthropicResponseTransformer {
+  constructor(model, requestId) {
+    this.model = model;
+    this.requestId = requestId || `chatcmpl-${Date.now()}`;
+    this.created = Math.floor(Date.now() / 1000);
+    this.messageId = null;
+    this.currentIndex = 0;
+  }
+
+  parseSSELine(line) {
+    if (line.startsWith('event:')) {
+      return { type: 'event', value: line.slice(6).trim() };
+    }
+    if (line.startsWith('data:')) {
+      const dataStr = line.slice(5).trim();
+      try {
+        return { type: 'data', value: JSON.parse(dataStr) };
+      } catch (e) {
+        return { type: 'data', value: dataStr };
+      }
+    }
+    return null;
+  }
+
+  transformEvent(eventType, eventData) {
+    logDebug(`Anthropic 事件: ${eventType}`);
+
+    if (eventType === 'message_start') {
+      this.messageId = eventData.message?.id || this.requestId;
+      return this.createOpenAIChunk('', 'assistant', false);
+    }
+
+    if (eventType === 'content_block_start') {
+      return null;
+    }
+
+    if (eventType === 'content_block_delta') {
+      const text = eventData.delta?.text || '';
+      return this.createOpenAIChunk(text, null, false);
+    }
+
+    if (eventType === 'content_block_stop') {
+      return null;
+    }
+
+    if (eventType === 'message_delta') {
+      const stopReason = eventData.delta?.stop_reason;
+      if (stopReason) {
+        return this.createOpenAIChunk('', null, true, this.mapStopReason(stopReason));
+      }
+      return null;
+    }
+
+    if (eventType === 'message_stop') {
+      return this.createDoneSignal();
+    }
+
+    if (eventType === 'ping') {
+      return null;
+    }
+
+    return null;
+  }
+
+  createOpenAIChunk(content, role = null, finish = false, finishReason = null) {
+    const chunk = {
+      id: this.requestId,
+      object: 'chat.completion.chunk',
+      created: this.created,
+      model: this.model,
+      choices: [
+        {
+          index: 0,
+          delta: {},
+          finish_reason: finish ? finishReason : null
+        }
+      ]
+    };
+
+    if (role) {
+      chunk.choices[0].delta.role = role;
+    }
+    if (content) {
+      chunk.choices[0].delta.content = content;
+    }
+
+    return `data: ${JSON.stringify(chunk)}\n\n`;
+  }
+
+  createDoneSignal() {
+    return 'data: [DONE]\n\n';
+  }
+
+  mapStopReason(anthropicReason) {
+    const mapping = {
+      'end_turn': 'stop',
+      'max_tokens': 'length',
+      'stop_sequence': 'stop',
+      'tool_use': 'tool_calls'
+    };
+    return mapping[anthropicReason] || 'stop';
+  }
+
+  async *transformStream(sourceStream) {
+    let buffer = '';
+    let currentEvent = null;
+
+    try {
+      for await (const chunk of sourceStream) {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+
+          const parsed = this.parseSSELine(line);
+          if (!parsed) continue;
+
+          if (parsed.type === 'event') {
+            currentEvent = parsed.value;
+          } else if (parsed.type === 'data' && currentEvent) {
+            const transformed = this.transformEvent(currentEvent, parsed.value);
+            if (transformed) {
+              yield transformed;
+            }
+            currentEvent = null;
+          }
+        }
+      }
+    } catch (error) {
+      logDebug('Anthropic 流转换错误', error);
+      throw error;
+    }
+  }
+}

transformers/response-openai.js

@@ -0,0 +1,127 @@
+import { logDebug } from '../logger.js';
+
+export class OpenAIResponseTransformer {
+  constructor(model, requestId) {
+    this.model = model;
+    this.requestId = requestId || `chatcmpl-${Date.now()}`;
+    this.created = Math.floor(Date.now() / 1000);
+  }
+
+  parseSSELine(line) {
+    if (line.startsWith('event:')) {
+      return { type: 'event', value: line.slice(6).trim() };
+    }
+    if (line.startsWith('data:')) {
+      const dataStr = line.slice(5).trim();
+      try {
+        return { type: 'data', value: JSON.parse(dataStr) };
+      } catch (e) {
+        return { type: 'data', value: dataStr };
+      }
+    }
+    return null;
+  }
+
+  transformEvent(eventType, eventData) {
+    logDebug(`目标 OpenAI 事件: ${eventType}`);
+
+    if (eventType === 'response.created') {
+      return this.createOpenAIChunk('', 'assistant', false);
+    }
+
+    if (eventType === 'response.in_progress') {
+      return null;
+    }
+
+    if (eventType === 'response.output_text.delta') {
+      const text = eventData.delta || eventData.text || '';
+      return this.createOpenAIChunk(text, null, false);
+    }
+
+    if (eventType === 'response.output_text.done') {
+      return null;
+    }
+
+    if (eventType === 'response.done') {
+      const status = eventData.response?.status;
+      let finishReason = 'stop';
+      
+      if (status === 'completed') {
+        finishReason = 'stop';
+      } else if (status === 'incomplete') {
+        finishReason = 'length';
+      }
+
+      const finalChunk = this.createOpenAIChunk('', null, true, finishReason);
+      const done = this.createDoneSignal();
+      return finalChunk + done;
+    }
+
+    return null;
+  }
+
+  createOpenAIChunk(content, role = null, finish = false, finishReason = null) {
+    const chunk = {
+      id: this.requestId,
+      object: 'chat.completion.chunk',
+      created: this.created,
+      model: this.model,
+      choices: [
+        {
+          index: 0,
+          delta: {},
+          finish_reason: finish ? finishReason : null
+        }
+      ]
+    };
+
+    if (role) {
+      chunk.choices[0].delta.role = role;
+    }
+    if (content) {
+      chunk.choices[0].delta.content = content;
+    }
+
+    return `data: ${JSON.stringify(chunk)}\n\n`;
+  }
+
+  createDoneSignal() {
+    return 'data: [DONE]\n\n';
+  }
+
+  async *transformStream(sourceStream) {
+    let buffer = '';
+    let currentEvent = null;
+
+    try {
+      for await (const chunk of sourceStream) {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+
+          const parsed = this.parseSSELine(line);
+          if (!parsed) continue;
+
+          if (parsed.type === 'event') {
+            currentEvent = parsed.value;
+          } else if (parsed.type === 'data' && currentEvent) {
+            const transformed = this.transformEvent(currentEvent, parsed.value);
+            if (transformed) {
+              yield transformed;
+            }
+          }
+        }
+      }
+
+      if (currentEvent === 'response.done' || currentEvent === 'response.completed') {
+        yield this.createDoneSignal();
+      }
+    } catch (error) {
+      logDebug('OpenAI 流转换错误', error);
+      throw error;
+    }
+  }
+}