@simonyea/holysheep-cli 1.6.10 → 1.6.11

package/README.md

@@ -218,6 +218,7 @@ A: OpenClaw 需要 Node.js 20+，运行 `node --version` 确认版本后重试
 
 ## Changelog
 
+- **v1.6.11** — OpenClaw 新增本地 HolySheep Bridge，统一暴露单一 `holysheep` provider 以支持自由切换 GPT / Claude / MiniMax；同时保留用户所选默认模型，不再强制 GPT-5.4 作为 primary
 - **v1.6.10** — 将可运行的 OpenClaw runtime（含 npx 回退）视为已安装，避免 Windows/Node 环境下重复提示安装；同时修复 Droid CLI 的 GPT `/v1` 接入地址并同步写入 `~/.factory/config.json`
 - **v1.6.9** — 保留 OpenClaw 的 MiniMax 配置，并为 MiniMax 使用独立 provider id，避免与 Claude provider 冲突；在 OpenClaw 2026.3.13 下改为提示精确 `/model` 切换命令，而不是停止配置 MiniMax
 - **v1.6.8** — 修复 Codex 重复写入 `config.toml` 导致的 duplicate key，并修复 OpenClaw 在 Windows 下的安装检测；针对 OpenClaw 2026.3.13 的模型路由回归，临时跳过 MiniMax 避免 `model not allowed`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonyea/holysheep-cli",
-  "version": "1.6.10",
+  "version": "1.6.11",
   "description": "Claude Code/Cursor/Cline API relay for China — ¥1=$1, WeChat/Alipay payment, no credit card, no VPN. One command setup for all AI coding tools.",
   "keywords": [
     "openai-china",

package/src/index.js

@@ -154,6 +154,19 @@ program
     })
   })
 
+// ── openclaw-bridge ──────────────────────────────────────────────────────────
+program
+  .command('openclaw-bridge')
+  .description('启动 HolySheep 的 OpenClaw 本地桥接服务')
+  .option('--port <port>', '指定桥接服务端口')
+  .action((opts) => {
+    const { startBridge } = require('./tools/openclaw-bridge')
+    startBridge({
+      port: opts.port ? Number(opts.port) : null,
+      host: '127.0.0.1',
+    })
+  })
+
 // 默认：无命令时显示帮助 + 提示 setup
 program
   .action(() => {

package/src/tools/openclaw-bridge.js

@@ -0,0 +1,545 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('fs')
+const http = require('http')
+const path = require('path')
+const os = require('os')
+const fetch = global.fetch || require('node-fetch')
+
+const OPENCLAW_DIR = path.join(os.homedir(), '.openclaw')
+const BRIDGE_CONFIG_FILE = path.join(OPENCLAW_DIR, 'holysheep-bridge.json')
+
+function readBridgeConfig(configPath = BRIDGE_CONFIG_FILE) {
+  return JSON.parse(fs.readFileSync(configPath, 'utf8'))
+}
+
+function parseArgs(argv) {
+  const args = { port: null, host: '127.0.0.1', config: BRIDGE_CONFIG_FILE }
+  for (let i = 0; i < argv.length; i++) {
+    const value = argv[i]
+    if (value === '--port') args.port = Number(argv[++i])
+    else if (value === '--host') args.host = argv[++i]
+    else if (value === '--config') args.config = argv[++i]
+  }
+  return args
+}
+
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let raw = ''
+    req.on('data', (chunk) => {
+      raw += chunk
+      if (raw.length > 5 * 1024 * 1024) {
+        reject(new Error('Request body too large'))
+        req.destroy()
+      }
+    })
+    req.on('end', () => {
+      if (!raw) return resolve({})
+      try {
+        resolve(JSON.parse(raw))
+      } catch (error) {
+        reject(error)
+      }
+    })
+    req.on('error', reject)
+  })
+}
+
+function sendJson(res, statusCode, payload) {
+  res.writeHead(statusCode, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  res.end(JSON.stringify(payload))
+}
+
+function sendOpenAIStream(res, payload) {
+  const choice = payload.choices?.[0] || {}
+  const message = choice.message || {}
+  const created = payload.created || Math.floor(Date.now() / 1000)
+
+  res.writeHead(200, {
+    'content-type': 'text/event-stream; charset=utf-8',
+    'cache-control': 'no-cache, no-transform',
+    connection: 'keep-alive',
+  })
+
+  const firstChunk = {
+    id: payload.id,
+    object: 'chat.completion.chunk',
+    created,
+    model: payload.model,
+    choices: [{
+      index: 0,
+      delta: {
+        role: 'assistant',
+        ...(message.content ? { content: message.content } : {}),
+        ...(message.tool_calls ? { tool_calls: message.tool_calls } : {}),
+      },
+      finish_reason: null,
+    }],
+  }
+
+  const finalChunk = {
+    id: payload.id,
+    object: 'chat.completion.chunk',
+    created,
+    model: payload.model,
+    choices: [{ index: 0, delta: {}, finish_reason: choice.finish_reason || 'stop' }],
+    usage: payload.usage,
+  }
+
+  res.write(`data: ${JSON.stringify(firstChunk)}\n\n`)
+  res.write(`data: ${JSON.stringify(finalChunk)}\n\n`)
+  res.end('data: [DONE]\n\n')
+}
+
+function normalizeText(value) {
+  if (typeof value === 'string') return value
+  if (Array.isArray(value)) return value.map(normalizeText).filter(Boolean).join('\n')
+  if (value && typeof value === 'object') {
+    if (typeof value.text === 'string') return value.text
+    if (typeof value.content === 'string') return value.content
+  }
+  return value == null ? '' : String(value)
+}
+
+function parseDataUrl(url) {
+  const match = String(url || '').match(/^data:([^;]+);base64,(.+)$/)
+  if (!match) return null
+  return { mediaType: match[1], data: match[2] }
+}
+
+function openAIContentToAnthropicBlocks(content) {
+  if (typeof content === 'string') return [{ type: 'text', text: content }]
+  if (!Array.isArray(content)) return []
+
+  const blocks = []
+  for (const part of content) {
+    if (!part) continue
+    if (part.type === 'text' && typeof part.text === 'string') {
+      blocks.push({ type: 'text', text: part.text })
+      continue
+    }
+    if (part.type === 'image_url' && part.image_url?.url) {
+      const dataUrl = parseDataUrl(part.image_url.url)
+      if (dataUrl) {
+        blocks.push({
+          type: 'image',
+          source: { type: 'base64', media_type: dataUrl.mediaType, data: dataUrl.data },
+        })
+      }
+    }
+  }
+  return blocks
+}
+
+function pushAnthropicMessage(messages, role, blocks) {
+  if (!blocks.length) return
+  const previous = messages[messages.length - 1]
+  if (previous && previous.role === role) {
+    previous.content = previous.content.concat(blocks)
+    return
+  }
+  messages.push({ role, content: blocks })
+}
+
+function convertOpenAIToAnthropicMessages(messages) {
+  const anthropicMessages = []
+  const systemParts = []
+
+  for (const message of messages || []) {
+    if (!message) continue
+
+    if (message.role === 'system') {
+      const blocks = openAIContentToAnthropicBlocks(message.content)
+      if (blocks.length === 0) {
+        const text = normalizeText(message.content)
+        if (text) systemParts.push(text)
+      } else {
+        for (const block of blocks) {
+          if (block.type === 'text') systemParts.push(block.text)
+        }
+      }
+      continue
+    }
+
+    if (message.role === 'tool') {
+      pushAnthropicMessage(anthropicMessages, 'user', [{
+        type: 'tool_result',
+        tool_use_id: message.tool_call_id,
+        content: normalizeText(message.content),
+      }])
+      continue
+    }
+
+    if (message.role === 'assistant') {
+      const blocks = []
+      const textBlocks = openAIContentToAnthropicBlocks(message.content)
+      if (textBlocks.length) blocks.push(...textBlocks)
+      else if (typeof message.content === 'string' && message.content) blocks.push({ type: 'text', text: message.content })
+
+      for (const toolCall of message.tool_calls || []) {
+        let input = {}
+        try {
+          input = JSON.parse(toolCall.function?.arguments || '{}')
+        } catch {}
+        blocks.push({
+          type: 'tool_use',
+          id: toolCall.id,
+          name: toolCall.function?.name || 'tool',
+          input,
+        })
+      }
+
+      pushAnthropicMessage(anthropicMessages, 'assistant', blocks)
+      continue
+    }
+
+    const blocks = openAIContentToAnthropicBlocks(message.content)
+    if (blocks.length) pushAnthropicMessage(anthropicMessages, 'user', blocks)
+    else {
+      const text = normalizeText(message.content)
+      if (text) pushAnthropicMessage(anthropicMessages, 'user', [{ type: 'text', text }])
+    }
+  }
+
+  return {
+    system: systemParts.join('\n\n').trim() || undefined,
+    messages: anthropicMessages,
+  }
+}
+
+function convertOpenAIToolsToAnthropic(tools) {
+  return (tools || [])
+    .filter((tool) => tool?.type === 'function' && tool.function?.name)
+    .map((tool) => ({
+      name: tool.function.name,
+      description: tool.function.description || '',
+      input_schema: tool.function.parameters || { type: 'object', properties: {} },
+    }))
+}
+
+function convertToolChoice(toolChoice) {
+  if (!toolChoice || toolChoice === 'auto') return { type: 'auto' }
+  if (toolChoice === 'none') return { type: 'auto', disable_parallel_tool_use: true }
+  if (toolChoice === 'required') return { type: 'any' }
+  if (toolChoice.type === 'function' && toolChoice.function?.name) {
+    return { type: 'tool', name: toolChoice.function.name }
+  }
+  return { type: 'auto' }
+}
+
+function buildAnthropicPayload(requestBody) {
+  const converted = convertOpenAIToAnthropicMessages(requestBody.messages)
+  const payload = {
+    model: requestBody.model,
+    max_tokens: requestBody.max_tokens || requestBody.max_completion_tokens || requestBody.max_output_tokens || 4096,
+    messages: converted.messages,
+    stream: false,
+  }
+
+  if (converted.system) payload.system = converted.system
+  if (requestBody.temperature != null) payload.temperature = requestBody.temperature
+  if (requestBody.top_p != null) payload.top_p = requestBody.top_p
+  if (Array.isArray(requestBody.stop) && requestBody.stop.length) payload.stop_sequences = requestBody.stop
+  if (typeof requestBody.stop === 'string') payload.stop_sequences = [requestBody.stop]
+
+  const tools = convertOpenAIToolsToAnthropic(requestBody.tools)
+  if (tools.length) payload.tools = tools
+  if (requestBody.tool_choice) payload.tool_choice = convertToolChoice(requestBody.tool_choice)
+
+  return payload
+}
+
+function mapFinishReason(stopReason) {
+  if (stopReason === 'tool_use') return 'tool_calls'
+  if (stopReason === 'max_tokens') return 'length'
+  return 'stop'
+}
+
+function buildToolCalls(content) {
+  const calls = []
+  for (const block of content || []) {
+    if (block?.type !== 'tool_use') continue
+    calls.push({
+      id: block.id,
+      type: 'function',
+      function: {
+        name: block.name,
+        arguments: JSON.stringify(block.input || {}),
+      },
+    })
+  }
+  return calls
+}
+
+function anthropicToOpenAIResponse(responseBody, requestedModel) {
+  const text = (responseBody.content || [])
+    .filter((block) => block?.type === 'text')
+    .map((block) => block.text)
+    .join('')
+  const toolCalls = buildToolCalls(responseBody.content)
+
+  return {
+    id: responseBody.id || `chatcmpl_${Date.now()}`,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model: requestedModel,
+    choices: [{
+      index: 0,
+      message: {
+        role: 'assistant',
+        content: text || null,
+        ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
+      },
+      finish_reason: mapFinishReason(responseBody.stop_reason),
+    }],
+    usage: responseBody.usage
+      ? {
+          prompt_tokens: responseBody.usage.input_tokens || 0,
+          completion_tokens: responseBody.usage.output_tokens || 0,
+          total_tokens: (responseBody.usage.input_tokens || 0) + (responseBody.usage.output_tokens || 0),
+        }
+      : undefined,
+  }
+}
+
+function pickRoute(model) {
+  if (String(model).startsWith('gpt-')) return 'openai'
+  if (String(model).startsWith('claude-')) return 'anthropic'
+  if (String(model).startsWith('MiniMax-')) return 'minimax'
+  return 'openai'
+}
+
+function parseOpenAIStreamText(text) {
+  try {
+    const parsed = JSON.parse(String(text || ''))
+    if (parsed && typeof parsed === 'object') return parsed
+  } catch {}
+
+  const blocks = String(text || '').split(/\r?\n\r?\n+/).filter(Boolean)
+  let responseCompleted = null
+  let finalChunk = null
+  let content = ''
+  let sawOutputTextDelta = false
+
+  for (const block of blocks) {
+    const eventMatch = block.match(/^event:\s*(.+)$/m)
+    const dataMatch = block.match(/^data:\s*(.+)$/m)
+    if (!dataMatch) continue
+
+    const eventName = eventMatch ? eventMatch[1].trim() : ''
+    const payload = dataMatch[1].trim()
+    if (!payload || payload === '[DONE]') continue
+
+    let chunk
+    try {
+      chunk = JSON.parse(payload)
+    } catch {
+      continue
+    }
+
+    if (eventName === 'response.output_text.delta' && typeof chunk.delta === 'string') {
+      sawOutputTextDelta = true
+      content += chunk.delta
+      continue
+    }
+
+    if (eventName === 'response.content_part.done' && chunk.part?.type === 'output_text' && typeof chunk.part.text === 'string') {
+      if (!sawOutputTextDelta) content += chunk.part.text
+      continue
+    }
+
+    if (eventName === 'response.completed' && chunk.response) {
+      responseCompleted = chunk.response
+      if (!content) {
+        const outputText = (chunk.response.output || [])
+          .flatMap((item) => item?.content || [])
+          .filter((item) => item?.type === 'output_text' && typeof item.text === 'string')
+          .map((item) => item.text)
+          .join('')
+        if (outputText) content = outputText
+      }
+      continue
+    }
+
+    finalChunk = chunk
+    const choice = chunk.choices?.[0] || {}
+    const delta = choice.delta || {}
+    if (delta.content) content += delta.content
+    else if (choice.message?.content) content += choice.message.content
+  }
+
+  if (responseCompleted) {
+    return {
+      id: responseCompleted.id || `chatcmpl_${Date.now()}`,
+      object: 'chat.completion',
+      created: responseCompleted.created_at || Math.floor(Date.now() / 1000),
+      model: responseCompleted.model,
+      choices: [{
+        index: 0,
+        message: { role: 'assistant', content: content || null },
+        finish_reason: responseCompleted.status === 'completed' ? 'stop' : 'length',
+      }],
+      usage: responseCompleted.usage,
+    }
+  }
+
+  if (!finalChunk) return null
+
+  return {
+    id: finalChunk.id || `chatcmpl_${Date.now()}`,
+    object: 'chat.completion',
+    created: finalChunk.created || Math.floor(Date.now() / 1000),
+    model: finalChunk.model,
+    choices: [{
+      index: 0,
+      message: { role: 'assistant', content: content || null },
+      finish_reason: finalChunk.choices?.[0]?.finish_reason || 'stop',
+    }],
+    usage: finalChunk.usage,
+  }
+}
+
+async function relayOpenAIRequest(requestBody, config, res) {
+  const upstreamBody = {
+    ...requestBody,
+    stream: requestBody.stream === true,
+  }
+  const upstream = await fetch(`${config.baseUrlOpenAI.replace(/\/+$/, '')}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      authorization: `Bearer ${config.apiKey}`,
+      'user-agent': 'holysheep-openclaw-bridge/1.0',
+    },
+    body: JSON.stringify(upstreamBody),
+  })
+
+  const text = await upstream.text()
+  if (!requestBody.stream) {
+    const parsed = parseOpenAIStreamText(text)
+    if (parsed) return sendJson(res, upstream.status, parsed)
+  }
+
+  res.writeHead(upstream.status, {
+    'content-type': upstream.headers.get('content-type') || 'application/json; charset=utf-8',
+    'cache-control': upstream.headers.get('cache-control') || 'no-store',
+  })
+  res.end(text)
+}
+
+async function relayAnthropicRequest(requestBody, config, route, res) {
+  const payload = buildAnthropicPayload(requestBody)
+  const baseUrl = route === 'minimax'
+    ? `${config.baseUrlAnthropic.replace(/\/+$/, '')}/minimax/v1/messages`
+    : `${config.baseUrlAnthropic.replace(/\/+$/, '')}/v1/messages`
+
+  const upstream = await fetch(baseUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'x-api-key': config.apiKey,
+      'anthropic-version': '2023-06-01',
+      'user-agent': 'holysheep-openclaw-bridge/1.0',
+    },
+    body: JSON.stringify(payload),
+  })
+
+  const text = await upstream.text()
+  let body
+  try {
+    body = JSON.parse(text)
+  } catch {
+    body = { error: { message: text || 'Invalid upstream response' } }
+  }
+
+  if (!upstream.ok) {
+    return sendJson(res, upstream.status, body)
+  }
+
+  const openaiBody = anthropicToOpenAIResponse(body, requestBody.model)
+  if (requestBody.stream) return sendOpenAIStream(res, openaiBody)
+  return sendJson(res, 200, openaiBody)
+}
+
+function buildModelsResponse(config) {
+  return {
+    object: 'list',
+    data: (config.models || []).map((model) => ({
+      id: model,
+      object: 'model',
+      owned_by: 'holysheep',
+    })),
+  }
+}
+
+function createBridgeServer(configPath = BRIDGE_CONFIG_FILE) {
+  return http.createServer(async (req, res) => {
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204, {
+        'access-control-allow-origin': '*',
+        'access-control-allow-methods': 'GET,POST,OPTIONS',
+        'access-control-allow-headers': 'content-type,authorization,x-api-key,anthropic-version',
+      })
+      return res.end()
+    }
+
+    try {
+      const config = readBridgeConfig(configPath)
+      const url = new URL(req.url, `http://${req.headers.host || '127.0.0.1'}`)
+
+      if (req.method === 'GET' && url.pathname === '/health') {
+        return sendJson(res, 200, { ok: true, port: config.port, models: config.models || [] })
+      }
+
+      if (req.method === 'GET' && url.pathname === '/v1/models') {
+        return sendJson(res, 200, buildModelsResponse(config))
+      }
+
+      if (req.method === 'POST' && url.pathname === '/v1/chat/completions') {
+        const requestBody = await readJsonBody(req)
+        const route = pickRoute(requestBody.model)
+        if (route === 'openai') return relayOpenAIRequest(requestBody, config, res)
+        return relayAnthropicRequest(requestBody, config, route, res)
+      }
+
+      return sendJson(res, 404, { error: { message: 'Not found' } })
+    } catch (error) {
+      return sendJson(res, 500, { error: { message: error.message || 'Bridge error' } })
+    }
+  })
+}
+
+function startBridge(args = parseArgs(process.argv.slice(2))) {
+  const config = readBridgeConfig(args.config)
+  const port = args.port || config.port
+  const host = args.host || '127.0.0.1'
+  const server = createBridgeServer(args.config)
+
+  server.listen(port, host, () => {
+    process.stdout.write(`HolySheep OpenClaw bridge listening on http://${host}:${port}\n`)
+  })
+
+  return server
+}
+
+if (require.main === module) {
+  startBridge()
+}
+
+module.exports = {
+  BRIDGE_CONFIG_FILE,
+  buildAnthropicPayload,
+  anthropicToOpenAIResponse,
+  buildModelsResponse,
+  createBridgeServer,
+  parseArgs,
+  parseOpenAIStreamText,
+  pickRoute,
+  readBridgeConfig,
+  startBridge,
+}

package/src/tools/openclaw.js

@@ -9,16 +9,18 @@ const path = require('path')
 const os = require('os')
 const { spawnSync, spawn, execSync } = require('child_process')
 const { commandExists } = require('../utils/which')
+const { BRIDGE_CONFIG_FILE } = require('./openclaw-bridge')
 
 const OPENCLAW_DIR = path.join(os.homedir(), '.openclaw')
 const CONFIG_FILE = path.join(OPENCLAW_DIR, 'openclaw.json')
 const isWin = process.platform === 'win32'
+const DEFAULT_BRIDGE_PORT = 18788
 const DEFAULT_GATEWAY_PORT = 18789
-const MAX_PORT_SCAN = 20
+const MAX_PORT_SCAN = 40
 const OPENCLAW_DEFAULT_MODEL = 'gpt-5.4'
 const OPENCLAW_DEFAULT_CLAUDE_MODEL = 'claude-sonnet-4-6'
 const OPENCLAW_DEFAULT_MINIMAX_MODEL = 'MiniMax-M2.7-highspeed'
-const OPENCLAW_ROUTING_REGRESSION_VERSION = /^2026\.3\.13(?:\D|$)/
+const OPENCLAW_PROVIDER_NAME = 'holysheep'
 
 function getOpenClawBinaryCandidates() {
   return isWin ? ['openclaw.cmd', 'openclaw'] : ['openclaw']
@@ -144,16 +146,67 @@ function detectRuntime() {
   return { available: false, via: null, command: null, version: null }
 }
 
-function isRoutingRegressionVersion(version) {
-  return OPENCLAW_ROUTING_REGRESSION_VERSION.test(String(version || '').trim())
+function readBridgeConfig() {
+  try {
+    if (fs.existsSync(BRIDGE_CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(BRIDGE_CONFIG_FILE, 'utf8'))
+    }
+  } catch {}
+  return {}
+}
+
+function writeBridgeConfig(data) {
+  fs.mkdirSync(OPENCLAW_DIR, { recursive: true })
+  fs.writeFileSync(BRIDGE_CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8')
+}
+
+function getConfiguredBridgePort(config = readBridgeConfig()) {
+  const port = Number(config?.port)
+  return Number.isInteger(port) && port > 0 ? port : DEFAULT_BRIDGE_PORT
+}
+
+function getBridgeBaseUrl(port = getConfiguredBridgePort()) {
+  return `http://127.0.0.1:${port}/v1`
 }
 
-function getRoutingRegressionWarning(runtimeVersion, minimaxModelRef) {
-  if (!isRoutingRegressionVersion(runtimeVersion) || !minimaxModelRef) {
-    return ''
+function waitForBridge(port) {
+  for (let i = 0; i < 10; i++) {
+    const t0 = Date.now()
+    while (Date.now() - t0 < 500) {}
+
+    try {
+      execSync(
+        isWin
+          ? `powershell -NonInteractive -Command "try{(Invoke-WebRequest -Uri http://127.0.0.1:${port}/health -TimeoutSec 1 -UseBasicParsing).StatusCode}catch{exit 1}"`
+          : `curl -sf http://127.0.0.1:${port}/health -o /dev/null --max-time 1`,
+        { stdio: 'ignore', timeout: 3000 }
+      )
+      return true
+    } catch {}
   }
 
-  return `当前 OpenClaw 2026.3.13 存在 provider 路由回归，但 HolySheep 仍会保留 MiniMax 配置。若网页模型切换失败，请直接输入 /model ${minimaxModelRef}，或升级 OpenClaw 后再试。`
+  return false
+}
+
+function startBridge(port) {
+  if (waitForBridge(port)) return true
+
+  const scriptPath = path.join(__dirname, '..', 'index.js')
+  const child = spawn(process.execPath, [scriptPath, 'openclaw-bridge', '--port', String(port)], {
+    detached: true,
+    stdio: 'ignore',
+  })
+  child.unref()
+  return waitForBridge(port)
+}
+
+function getBridgeCommand(port = getConfiguredBridgePort()) {
+  return `hs openclaw-bridge --port ${port}`
+}
+
+function pickPrimaryModel(primaryModel, selectedModels) {
+  const models = Array.isArray(selectedModels) ? selectedModels : []
+  return primaryModel || models[0] || OPENCLAW_DEFAULT_MODEL
 }
 
 function readConfig() {
@@ -245,11 +298,6 @@ function getDashboardCommand() {
   return `${runtime} dashboard --no-open`
 }
 
-function buildProviderName(baseUrl, prefix) {
-  const hostname = new URL(baseUrl).hostname.replace(/\./g, '-')
-  return `${prefix}-${hostname}`
-}
-
 function buildModelEntry(id) {
   return {
     id,
@@ -261,79 +309,51 @@ function buildModelEntry(id) {
   }
 }
 
-function buildManagedPlan(apiKey, baseUrlAnthropic, baseUrlOpenAI, selectedModels) {
+function normalizeRequestedModels(selectedModels) {
   const requestedModels = Array.isArray(selectedModels) && selectedModels.length > 0
-    ? selectedModels
+    ? [...selectedModels]
     : [OPENCLAW_DEFAULT_MODEL, OPENCLAW_DEFAULT_CLAUDE_MODEL, OPENCLAW_DEFAULT_MINIMAX_MODEL]
 
-  const openaiModels = requestedModels.filter((model) => model.startsWith('gpt-'))
-  if (!openaiModels.includes(OPENCLAW_DEFAULT_MODEL)) {
-    openaiModels.unshift(OPENCLAW_DEFAULT_MODEL)
-  }
-
-  const claudeModels = requestedModels.filter((model) => model.startsWith('claude-'))
-  if (claudeModels.length === 0) {
-    claudeModels.push(OPENCLAW_DEFAULT_CLAUDE_MODEL)
-  }
-
-   const minimaxModels = requestedModels.filter((model) => model.startsWith('MiniMax-'))
-   if (requestedModels.includes(OPENCLAW_DEFAULT_MINIMAX_MODEL) && !minimaxModels.includes(OPENCLAW_DEFAULT_MINIMAX_MODEL)) {
-     minimaxModels.unshift(OPENCLAW_DEFAULT_MINIMAX_MODEL)
-   }
-
-  const openaiProviderName = buildProviderName(baseUrlOpenAI, 'custom-openai')
-  const anthropicProviderName = buildProviderName(baseUrlAnthropic, 'custom-anthropic')
-  const minimaxProviderName = buildProviderName(`${baseUrlAnthropic.replace(/\/+$/, '')}/minimax`, 'custom-minimax')
-
-  const providers = {
-    [openaiProviderName]: {
-      baseUrl: baseUrlOpenAI,
-      apiKey,
-      api: 'openai-completions',
-      models: openaiModels.map(buildModelEntry),
-    },
-    [anthropicProviderName]: {
-      baseUrl: baseUrlAnthropic,
-      apiKey,
-      api: 'anthropic-messages',
-      models: claudeModels.map(buildModelEntry),
-    },
-  }
-
-  if (minimaxModels.length > 0) {
-    providers[minimaxProviderName] = {
-      baseUrl: `${baseUrlAnthropic.replace(/\/+$/, '')}/minimax`,
-      apiKey,
-      api: 'anthropic-messages',
-      models: minimaxModels.map(buildModelEntry),
-    }
-  }
+  if (!requestedModels.includes(OPENCLAW_DEFAULT_MODEL)) requestedModels.unshift(OPENCLAW_DEFAULT_MODEL)
+  return Array.from(new Set(requestedModels))
+}
 
-  const managedModelRefs = [
-    ...openaiModels.map((id) => `${openaiProviderName}/${id}`),
-    ...claudeModels.map((id) => `${anthropicProviderName}/${id}`),
-    ...minimaxModels.map((id) => `${minimaxProviderName}/${id}`),
-  ]
+function buildManagedPlan(baseUrlBridge, primaryModel, selectedModels) {
+  const requestedModels = normalizeRequestedModels(selectedModels)
+  const managedModelRefs = requestedModels.map((model) => `${OPENCLAW_PROVIDER_NAME}/${model}`)
+  const fallbackPrimaryModel = pickPrimaryModel(primaryModel, requestedModels)
+  const primaryRef = managedModelRefs.includes(`${OPENCLAW_PROVIDER_NAME}/${fallbackPrimaryModel}`)
+    ? `${OPENCLAW_PROVIDER_NAME}/${fallbackPrimaryModel}`
+    : managedModelRefs[0] || `${OPENCLAW_PROVIDER_NAME}/${OPENCLAW_DEFAULT_MODEL}`
 
   return {
-    providers,
+    providers: {
+      [OPENCLAW_PROVIDER_NAME]: {
+        baseUrl: baseUrlBridge,
+        api: 'openai-completions',
+        models: requestedModels.map(buildModelEntry),
+      },
+    },
     managedModelRefs,
-    primaryRef: `${openaiProviderName}/${OPENCLAW_DEFAULT_MODEL}`,
-    minimaxRef: minimaxModels[0] ? `${minimaxProviderName}/${minimaxModels[0]}` : '',
+    models: requestedModels,
+    primaryRef,
   }
 }
 
 function isHolySheepProvider(provider) {
-  return typeof provider?.baseUrl === 'string' && provider.baseUrl.includes('api.holysheep.ai')
+  return typeof provider?.baseUrl === 'string' && (
+    provider.baseUrl.includes('api.holysheep.ai') ||
+    provider.baseUrl.includes('127.0.0.1')
+  )
 }
 
-function writeManagedConfig(baseConfig, apiKey, baseUrlAnthropic, baseUrlOpenAI, selectedModels, gatewayPort) {
+function writeManagedConfig(baseConfig, bridgeBaseUrl, primaryModel, selectedModels, gatewayPort) {
   fs.mkdirSync(OPENCLAW_DIR, { recursive: true })
 
-  const plan = buildManagedPlan(apiKey, baseUrlAnthropic, baseUrlOpenAI, selectedModels)
+  const plan = buildManagedPlan(bridgeBaseUrl, primaryModel, selectedModels)
   const existingProviders = baseConfig?.models?.providers || {}
   const managedProviderIds = Object.entries(existingProviders)
-    .filter(([, provider]) => isHolySheepProvider(provider))
+    .filter(([providerId, provider]) => providerId === OPENCLAW_PROVIDER_NAME || isHolySheepProvider(provider))
     .map(([providerId]) => providerId)
 
   const preservedProviders = Object.fromEntries(
@@ -462,11 +482,13 @@ module.exports = {
   },
 
   isConfigured() {
-    const cfg = JSON.stringify(readConfig())
-    return cfg.includes('holysheep.ai')
+    const cfg = readConfig()
+    const hasProvider = cfg?.models?.providers?.[OPENCLAW_PROVIDER_NAME]?.baseUrl?.includes('127.0.0.1')
+    const bridge = readBridgeConfig()
+    return Boolean(hasProvider && bridge?.apiKey)
   },
 
-  configure(apiKey, baseUrlAnthropic, baseUrlOpenAI, _primaryModel, selectedModels) {
+  configure(apiKey, baseUrlAnthropic, baseUrlOpenAI, primaryModel, selectedModels) {
     const chalk = require('chalk')
     console.log(chalk.gray('\n  ⚙️  正在配置 OpenClaw...'))
 
@@ -476,6 +498,27 @@ module.exports = {
     }
     this._lastRuntimeCommand = runtime.command
 
+    const resolvedPrimaryModel = pickPrimaryModel(primaryModel, selectedModels)
+    const bridgePort = findAvailableGatewayPort(DEFAULT_BRIDGE_PORT)
+    if (!bridgePort) {
+      throw new Error(`找不到可用桥接端口（已检查 ${DEFAULT_BRIDGE_PORT}-${DEFAULT_BRIDGE_PORT + MAX_PORT_SCAN - 1}）`)
+    }
+    this._lastBridgePort = bridgePort
+
+    writeBridgeConfig({
+      port: bridgePort,
+      apiKey,
+      baseUrlAnthropic,
+      baseUrlOpenAI,
+      models: normalizeRequestedModels(selectedModels),
+    })
+
+    console.log(chalk.gray('  → 正在启动 HolySheep Bridge...'))
+    if (!startBridge(bridgePort)) {
+      throw new Error('HolySheep OpenClaw Bridge 启动失败')
+    }
+    const bridgeBaseUrl = getBridgeBaseUrl(bridgePort)
+
     runOpenClaw(['gateway', 'stop'], { preferNpx: runtime.via === 'npx' })
 
     const gatewayPort = findAvailableGatewayPort(DEFAULT_GATEWAY_PORT)
@@ -504,9 +547,9 @@ module.exports = {
       '--non-interactive',
       '--accept-risk',
       '--auth-choice', 'custom-api-key',
-      '--custom-base-url', baseUrlOpenAI,
+      '--custom-base-url', bridgeBaseUrl,
       '--custom-api-key', apiKey,
-      '--custom-model-id', OPENCLAW_DEFAULT_MODEL,
+      '--custom-model-id', resolvedPrimaryModel,
       '--custom-compatibility', 'openai',
       '--gateway-port', String(gatewayPort),
       '--install-daemon',
@@ -518,18 +561,12 @@ module.exports = {
 
     const plan = writeManagedConfig(
       result.status === 0 ? readConfig() : {},
-      apiKey,
-      baseUrlAnthropic,
-      baseUrlOpenAI,
+      bridgeBaseUrl,
+      resolvedPrimaryModel,
       selectedModels,
       gatewayPort,
     )
 
-    const routingRegressionWarning = getRoutingRegressionWarning(runtime.version, plan.minimaxRef)
-    if (routingRegressionWarning) {
-      console.log(chalk.yellow(`  ⚠️  ${routingRegressionWarning}`))
-    }
-
     _disableGatewayAuth(runtime.via === 'npx')
     const serviceReady = _installGatewayService(gatewayPort, runtime.via === 'npx')
 
@@ -545,7 +582,8 @@ module.exports = {
     const dashUrl = getDashboardUrl(gatewayPort, runtime.via === 'npx')
     console.log(chalk.cyan('\n  → 浏览器打开（推荐使用此地址）:'))
     console.log(chalk.bold.cyan(`     ${dashUrl}`))
-    console.log(chalk.gray(`     默认模型: ${OPENCLAW_DEFAULT_MODEL}`))
+    console.log(chalk.gray(`     Bridge 地址: ${bridgeBaseUrl}`))
+    console.log(chalk.gray(`     默认模型: ${plan.primaryRef || OPENCLAW_DEFAULT_MODEL}`))
     console.log(chalk.gray('     如在 Windows 上打开裸 http://127.0.0.1:PORT/ 仍报 Unauthorized，请使用上面的 dashboard 地址'))
 
     return {
@@ -559,24 +597,28 @@ module.exports = {
 
   reset() {
     try { fs.unlinkSync(CONFIG_FILE) } catch {}
+    try { fs.unlinkSync(BRIDGE_CONFIG_FILE) } catch {}
   },
 
   getConfigPath() { return CONFIG_FILE },
+  getBridgePort() { return getConfiguredBridgePort() },
   getGatewayPort() { return getConfiguredGatewayPort() },
   getPrimaryModel() { return getConfiguredPrimaryModel() },
   getPortListeners(port = getConfiguredGatewayPort()) { return listPortListeners(port) },
   get hint() {
-    return `Gateway 已启动，默认模型为 ${getConfiguredPrimaryModel() || OPENCLAW_DEFAULT_MODEL}`
+    return `Bridge + Gateway 已配置，默认模型为 ${getConfiguredPrimaryModel() || OPENCLAW_DEFAULT_MODEL}`
   },
   get launchSteps() {
+    const bridgePort = getConfiguredBridgePort()
     const port = getConfiguredGatewayPort()
     return [
-      { cmd: getLaunchCommand(port), note: '先启动 OpenClaw Gateway' },
+      { cmd: getBridgeCommand(bridgePort), note: '先启动 HolySheep OpenClaw Bridge' },
+      { cmd: getLaunchCommand(port), note: '再启动 OpenClaw Gateway' },
       { cmd: getDashboardCommand(), note: '再生成/打开可直接连接的 Dashboard 地址（推荐）' },
     ]
   },
   get launchNote() {
-    return `🌐 推荐运行 ${getDashboardCommand()}；Windows 上不要只打开裸 http://127.0.0.1:${getConfiguredGatewayPort()}/`
+    return `🌐 请先启动 Bridge，再启动 Gateway；最后运行 ${getDashboardCommand()}`
   },
   installCmd: 'npm install -g openclaw@latest',
   docsUrl: 'https://docs.openclaw.ai',