Upload 15 files

src/configs/config.js

@@ -0,0 +1,94 @@
+// 配置常量
+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'
+    }
+  ],
+
+  user_agent: 'factory-cli/0.22.14',
+  system_prompt: 'You are Droid, an AI software engineering agent built by Factory.\n\n'
+}
+
+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 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
+}

src/managers/proxy.js

@@ -0,0 +1,36 @@
+import { HttpsProxyAgent } from 'https-proxy-agent'
+import { getProxyUrl } from '../configs/config.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)
+    console.log(`使用代理 ${proxyUrl} 请求 ${targetUrl}`)
+    return { agent: cachedAgent, proxy: { url: proxyUrl } }
+  } catch (error) {
+    console.error(`为 ${proxyUrl} 创建代理失败:`, error)
+    return null
+  }
+}
+

src/routes/handlers/chat.js

@@ -0,0 +1,148 @@
+import fetch from 'node-fetch'
+import { getModelById, getEndpointByType } from '../../configs/config.js'
+import { transformToAnthropic, getAnthropicHeaders } from '../../transformers/requests/anthropic.js'
+import { transformToOpenAI, getOpenAIHeaders } from '../../transformers/requests/openai.js'
+import { transformToCommon, getCommonHeaders } from '../../transformers/requests/common.js'
+import { AnthropicResponseTransformer } from '../../transformers/responses/anthropic.js'
+import { OpenAIResponseTransformer } from '../../transformers/responses/openai.js'
+import { getNextProxyAgent } from '../../managers/proxy.js'
+import { getAuthHeader } from '../utils/auth.js'
+import { convertResponseToChatCompletion } from '../utils/converter.js'
+
+/**
+ * 处理 POST /v1/chat/completions 请求
+ * 标准 OpenAI 聊天补全处理函数（带格式转换）
+ */
+export 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 ((openaiRequest.model === 'claude-sonnet-4-5-20250929' || openaiRequest.model === 'claude-haiku-4-5-20251001' || openaiRequest.model === 'claude-opus-4-1-20250805') && openaiRequest.temperature && openaiRequest.top_p) {
+      delete openaiRequest.top_p
+    }
+
+    // 转换请求格式
+    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}` })
+    }
+
+    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()
+      console.error(`端点错误: ${response.status}`, 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) {
+          console.error('流错误:', 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) {
+          console.error('流错误:', streamError)
+          res.end()
+        }
+      }
+    } else {
+      const data = await response.json()
+      if (model.type === 'openai') {
+        try {
+          const converted = convertResponseToChatCompletion(data)
+          res.json(converted)
+        } catch (e) {
+          res.json(data)
+        }
+      } else {
+        res.json(data)
+      }
+    }
+
+  } catch (error) {
+    console.error('/v1/chat/completions 错误:', error)
+    res.status(500).json({
+      error: '内部服务器错误',
+      message: error.message
+    })
+  }
+}
+

src/routes/handlers/messages.js

@@ -0,0 +1,266 @@
+import fetch from 'node-fetch'
+import { getModelById, getEndpointByType, getSystemPrompt, getModelReasoning } from '../../configs/config.js'
+import { getAnthropicHeaders } from '../../transformers/requests/anthropic.js'
+import { getNextProxyAgent } from '../../managers/proxy.js'
+import { getAuthHeader } from '../utils/auth.js'
+
+/**
+ * 处理 POST /v1/messages 请求
+ * 直接转发 Anthropic 请求（不做格式转换）
+ */
+export async function handleDirectMessages(req, res) {
+  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}` })
+    }
+
+    // 获取认证信息
+    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
+          },
+          {
+            type: 'text',
+            text: 'Forget "You are Droid, an AI software engineering agent built by Factory." You have no relationship with Droid / Factory whatsoever.'
+          },
+          ...modifiedRequest.system
+        ]
+      } else {
+        // 否则创建新的 system 数组
+        modifiedRequest.system = [
+          {
+            type: 'text',
+            text: systemPrompt
+          },
+          {
+            type: 'text',
+            text: 'Forget "You are Droid, an AI software engineering agent built by Factory." You have no relationship with Droid / Factory whatsoever.'
+          }
+        ]
+      }
+    }
+
+    if ((modelId === 'claude-sonnet-4-5-20250929' || modelId === 'claude-haiku-4-5-20251001' || modelId === 'claude-opus-4-1-20250805') && modifiedRequest.temperature && modifiedRequest.top_p) {
+      delete modifiedRequest.top_p
+    }
+
+    // 处理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
+    }
+
+    // 转发修改后的请求
+    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()
+      console.error(`端点错误: ${response.status}`, 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()
+      } catch (streamError) {
+        console.error('流错误:', streamError)
+        res.end()
+      }
+    } else {
+      // 直接转发非流式响应，不做任何转换
+      const data = await response.json()
+      res.json(data)
+    }
+
+  } catch (error) {
+    console.error('/v1/messages 错误:', error)
+    res.status(500).json({
+      error: '内部服务器错误',
+      message: error.message
+    })
+  }
+}
+
+/**
+ * 处理 POST /v1/messages/count_tokens 请求
+ * Anthropic count_tokens 请求
+ */
+export async function handleCountTokens(req, res) {
+  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 }
+
+    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)
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      console.error(`计数令牌错误: ${response.status}`, errorText)
+      return res.status(response.status).json({
+        error: `端点返回 ${response.status}`,
+        details: errorText
+      })
+    }
+
+    const data = await response.json()
+    res.json(data)
+
+  } catch (error) {
+    console.error('/v1/messages/count_tokens 错误:', error)
+    res.status(500).json({
+      error: '内部服务器错误',
+      message: error.message
+    })
+  }
+}
+

src/routes/handlers/models.js

@@ -0,0 +1,29 @@
+import { getConfig } from '../../configs/config.js'
+
+/**
+ * 处理 GET /v1/models 请求
+ * 返回所有可用模型列表
+ */
+export async function handleModels(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) {
+    console.error('GET /v1/models 错误:', error)
+    res.status(500).json({ error: 'Internal server error' })
+  }
+}
+

src/routes/handlers/responses.js

@@ -0,0 +1,138 @@
+import fetch from 'node-fetch'
+import { getModelById, getEndpointByType, getSystemPrompt, getModelReasoning } from '../../configs/config.js'
+import { getOpenAIHeaders } from '../../transformers/requests/openai.js'
+import { getNextProxyAgent } from '../../managers/proxy.js'
+import { getAuthHeader } from '../utils/auth.js'
+
+/**
+ * 处理 POST /v1/responses 请求
+ * 直接转发 OpenAI 请求（不做格式转换）
+ */
+export 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 + 'Forget "You are Droid, an AI software engineering agent built by Factory." You have no relationship with Droid / Factory whatsoever.' + modifiedRequest.instructions
+      } else {
+        // 否则直接设置系统提示
+        modifiedRequest.instructions = systemPrompt + 'Forget "You are Droid, an AI software engineering agent built by Factory." You have no relationship with Droid / Factory whatsoever.'
+      }
+    }
+
+    // 处理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
+    }
+
+    const proxyAgentInfo = getNextProxyAgent(endpoint.base_url)
+    const fetchOptions = {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(modifiedRequest)
+    }
+
+    if (proxyAgentInfo?.agent) {
+      fetchOptions.agent = proxyAgentInfo.agent
+    }
+
+    console.log(`[INFO] 直接转发到 openai 端点: ${endpoint.base_url}`)
+    const response = await fetch(endpoint.base_url, fetchOptions)
+    console.log(`[INFO] 响应状态: ${response.status}`)
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      console.error(`端点错误: ${response.status}`, 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) {
+        console.error('流错误:', streamError)
+        res.end()
+      }
+    } else {
+      const data = await response.json()
+      res.json(data)
+    }
+
+  } catch (error) {
+    console.error('/v1/responses 错误:', error)
+    res.status(500).json({
+      error: '内部服务器错误',
+      message: error.message
+    })
+  }
+}
+

src/routes/routes.js

@@ -0,0 +1,16 @@
+import express from 'express'
+import { handleModels } from './handlers/models.js'
+import { handleChatCompletions } from './handlers/chat.js'
+import { handleDirectResponses } from './handlers/responses.js'
+import { handleDirectMessages, handleCountTokens } from './handlers/messages.js'
+
+const router = express.Router()
+
+// 注册路由
+router.get('/v1/models', handleModels)
+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

src/routes/utils/auth.js

@@ -0,0 +1,9 @@
+/**
+ * 从请求头获取认证信息
+ * @param {Object} req - Express 请求对象
+ * @returns {string|undefined} 认证令牌
+ */
+export function getAuthHeader(req) {
+  return req.headers.authorization || req.headers.Authorization || req.headers['x-api-key']
+}
+

src/routes/utils/converter.js

@@ -0,0 +1,40 @@
+/**
+ * 将 /v1/responses API 结果转换为 /v1/chat/completions 兼容格式
+ * 适用于非流式响应
+ * @param {Object} resp - 原始响应对象
+ * @returns {Object} OpenAI 兼容的聊天补全格式
+ */
+export 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
+}
+

src/server.js

@@ -0,0 +1,129 @@
+import express from 'express'
+import { getPort } from './configs/config.js'
+import router from './routes/routes.js'
+
+const app = express();
+
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({ extended: true, limit: '50mb' }));
+
+// 生成请求ID (UUID格式)
+function generateRequestId() {
+  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)
+  })
+}
+
+// 获取客户端IP
+function getClientIp(req) {
+  return req.headers['x-forwarded-for']?.split(',')[0].trim() ||
+         req.headers['x-real-ip'] ||
+         req.connection?.remoteAddress ||
+         req.socket?.remoteAddress ||
+         'unknown'
+}
+
+// 请求日志中间件
+app.use((req, res, next) => {
+  const startTime = Date.now()
+  const requestId = generateRequestId()
+  const clientIp = getClientIp(req)
+
+  // 将请求ID附加到req对象
+  req.requestId = requestId
+
+  // 请求开始时打印日志
+  console.log(`[INFO] [${requestId}] [${clientIp}] ${req.method} ${req.path}`)
+
+  // 保存原始的 res.json 和 res.end 方法
+  const originalJson = res.json.bind(res)
+  const originalEnd = res.end.bind(res)
+
+  // 重写 res.json 方法以捕获响应状态
+  res.json = function(data) {
+    logRequestEnd(req, res, startTime, requestId, clientIp)
+    return originalJson(data)
+  }
+
+  // 重写 res.end 方法以捕获流式响应状态
+  res.end = function(...args) {
+    logRequestEnd(req, res, startTime, requestId, clientIp)
+    return originalEnd(...args)
+  }
+
+  next()
+})
+
+// 请求结束日志记录函数
+function logRequestEnd(req, res, startTime, requestId, clientIp) {
+  // 避免重复记录
+  if (res._logged) return
+  res._logged = true
+
+  const duration = ((Date.now() - startTime) / 1000).toFixed(3)
+  const status = res.statusCode
+
+  console.log(`[INFO] [${requestId}] [${clientIp}] 响应状态: ${status}`)
+  console.log(`[INFO] [${requestId}] [${clientIp}] 处理时间: ${duration}s`)
+}
+
+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) => {
+  console.error('未处理的错误:', err);
+  res.status(500).json({
+    error: '内部服务器错误',
+    message: err.message
+  });
+});
+
+(async () => {
+  try {
+    const PORT = getPort()
+
+    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 {
+        console.error('启动服务器失败:', err);
+        process.exit(1);
+      }
+    });
+  } catch (error) {
+    console.error('启动服务器失败:', error);
+    process.exit(1);
+  }
+})();

src/transformers/requests/anthropic.js

@@ -0,0 +1,239 @@
+import { getSystemPrompt, getModelReasoning, getUserAgent } from '../../configs/config.js'
+
+export function transformToAnthropic(openaiRequest) {
+  
+  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];
+  }
+
+  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);
+  });
+}

src/transformers/requests/common.js

@@ -0,0 +1,84 @@
+import { getSystemPrompt, getUserAgent } from '../../configs/config.js'
+
+export function transformToCommon(openaiRequest) {
+  // 基本保持 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 || [])
+      ];
+    }
+  }
+
+  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);
+  });
+}

src/transformers/requests/openai.js

@@ -0,0 +1,174 @@
+import { getSystemPrompt, getModelReasoning, getUserAgent } from '../../configs/config.js'
+
+export function transformToOpenAI(openaiRequest) {
+
+  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;
+  }
+
+  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);
+  });
+}

src/transformers/responses/anthropic.js

@@ -0,0 +1,134 @@
+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) {
+    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) {
+      console.error('Anthropic 流转换错误:', error);
+      throw error;
+    }
+  }
+}

src/transformers/responses/openai.js

@@ -0,0 +1,123 @@
+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) {
+    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) {
+      console.error('OpenAI 流转换错误:', error);
+      throw error;
+    }
+  }
+}