jianf/ModelRouter
1
0
Fork 0
mirror of https://gitcode.com/JianFeeeee/ModelRouter.git synced 2026-11-12 04:07:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore!: 移除厂商私有协议适配器与渠道业务插件（合规清理）

Browse Source 
G-Star 合规要求下，把"模拟官方客户端、复刻私有协议、自动领取平台额度"这一类
能力整体移出仓库。这些实现依赖各平台未公开的端点、签名算法与官方 client id，
属于绕过客户端校验获取额度，风险高于普通协议适配。

移除（93 个文件）：
- 适配器：opencodezen（伪装 UA 取免费池）、trae、buddy、kimicode
- 插件：channels.lua（12 个平台登录/领额度/签到）、quota.lua（厂商额度探针）
- 随之删除的 78 个渠道/额度专用测试与 3 份渠道文档

同时修掉的既有问题：
- **硬编码第三方 OAuth client_secret**（Google Cloud Code 的 GOCSPX-…，两处）
  随 channels.lua 一起消失。
- `deploy.sh` 的 `sync_plugins` 整段删除：它仍按"内置插件是发行物"的旧前提
  把插件复制/覆盖进 plugin_dir，与"插件属运维资产、网关不安装不覆盖"的契约
  冲突。现在部署脚本只同步适配器与二进制/配置。
- 适配器清单去掉已移除项；e2e 配置改用显式 `auto:` 链（`models.priority` 早已
  移除，该测试此前已失效）。

保留（公开协议）：openai / anthropic / gemini / deepseek / github / groq /
mistral / ollama / qwen38 / sensenova = 10 个适配器；插件示例 billing / usage。

验证：go build -tags luajit ./... OK；internal/lua 21.4s、provider、core 51s、
gateway 122.8s、e2e 9.0s 全绿。
This commit is contained in:
JianFeeeee
2026-10-27 09:23:24 +08:00
parent 449e59dd52
commit 8f2c5572e7
123 changed files with 76 additions and 32056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

292
internal/lua/adapters/buddy.lua
View File

@ -1,292 +0,0 @@
local adapter = {}
adapter.name = "buddy"
adapter.version = "1.0.0"
adapter.endpoint = "/chat/completions"
adapter.headers = {}
-- Claude-behind-OpenAI upstreams (tabitoken, 扇贝, …) convert /chat/completions
-- to the Anthropic Messages API internally, so they inherit Anthropic's
-- tool id rule: ^[a-zA-Z0-9_-]{1,64}$, enforced by rejecting the WHOLE request
-- with "Invalid tool use format" / "tool_use.id: String should match pattern".
-- Plain OpenAI has no such rule, so an OpenAI-compatible model can mint an id
-- like "bash:0" (observed from moonshotai/kimi-k3). In a fan-out router that id
-- is replayed to every other source, so one such id kills every Claude slot at
-- once and an AUTO request falls through all tiers.
--
-- safe_tool_id is pure and deterministic, so a tool_calls entry and its
-- matching tool_call_id are rewritten identically within one request. A
-- rewritten id keeps an 8-hex digest of the ORIGINAL id, without which two
-- distinct ids could collapse into one ("a:b" and "a_b") and become an
-- unpaired/duplicate tool call. Already-legal ids are returned untouched, so
-- well-behaved traffic is byte-identical to before.
-- (anthropic.lua carries the same helper; Lua adapters have no shared prelude.)
local TOOL_ID_MAX = 64
local function safe_tool_id(id)
if type(id) ~= "string" or id == "" then return id end
local clean = string.gsub(id, "[^A-Za-z0-9_-]", "_")
if clean == id and #clean <= TOOL_ID_MAX then
return clean
end
local digest = string.sub(sha256_hex(id), 1, 8)
local keep = TOOL_ID_MAX - #digest - 1
if #clean > keep then clean = string.sub(clean, 1, keep) end
return clean .. "_" .. digest
end
-- 需要补 reasoning_effort 的模型 → 补哪个档位。
--
-- 唯一出处：参考 product.ts:237 声明 glm-5.1 的 reasoningEfforts 只有 ['medium']。
-- 但实测**任何非空档位都被接受**，故这里取 medium（与参考声明一致）。
local NEED_EFFORT = {
["glm-5.1"] = "medium",
}
-- OpenAI /chat/completions format (pass-through, strip provider-specific fields)
function adapter.transform_request(raw_body)
local ok, req = pcall(json.decode, raw_body)
if not ok then return raw_body end
-- The gateway's private control fields are GONE from the body (v2): the
-- neutral `thinking` field carries that intent and each adapter maps it in
-- its own protocol terms. These upstreams have no thinking switch at all,
-- so the field is simply dropped here — which is what the nil-ing below
-- used to do, except the field being dropped is no longer the kernel's
-- private one.
req.thinking = nil
req.extra_body = nil
-- ★★ buddy（腾讯 CodeBuddy）上游**只支持流式**：body.stream=false 会被
-- 400 拒绝（实测 2026-10-19）：
-- 11101: Non-stream chat request is currently not supported
-- 与 Accept: text/event-stream 头无关（头早已在发），判据是 body。
-- 故强制 stream=true，非流式请求由内核的"客户端要非流式、上游回流式"
-- 路径消化（transform_response 需能聚合 SSE，见下）。
req.stream = true
-- ★★ buddy 的 glm-5.1 **要求请求体里有非空的 reasoning_effort**，
-- 否则上游回 400：
-- {"code":11150,"msg":"the reasoning effort value is not supported
-- by the current model"}
-- 实测（2026-10-16，逐字对照实验）：
-- glm-5.1 裸（无该字段） → 400 11150 ✗
-- glm-5.1 + reasoning_effort:medium → 200 ✓
-- glm-5.1 空串 → 400 11150 ✗
-- 任何**非空**档位均可（low/medium/high/xhigh/max/minimal 逐个 200）
-- 而其余 15 个 buddy 模型裸跑全 200（多带该字段也无害）—— 即这是
-- glm-5.1 **独有**的要求。
-- ⚠️ 只对**已实测需要**的模型补（而不是一律补）：一律补会把"某个模型的
-- 特殊要求"扩成"全平台行为"，将来上游若对某些模型收紧就会一次性弄坏
-- 所有模型。
if NEED_EFFORT[req.model or ""] and
not (type(req.reasoning_effort) == "string" and req.reasoning_effort ~= "") and
req.reasoning_effort == nil then
req.reasoning_effort = NEED_EFFORT[req.model]
end
if req.messages then
for _, msg in ipairs(req.messages) do
msg.reasoning_content = nil
if msg.tool_call_id ~= nil then
msg.tool_call_id = safe_tool_id(msg.tool_call_id)
end
if type(msg.tool_calls) == "table" then
for _, tc in ipairs(msg.tool_calls) do
if type(tc) == "table" and tc.id ~= nil then
tc.id = safe_tool_id(tc.id)
end
end
end
end
end
return json.encode(req)
end
-- aggregate_sse(raw)：把上游 SSE（data: 行流）聚合成一个非流式 OpenAI 响应。
-- 强制 stream=true 后，内核的非流式路径会在这里收到完整 SSE 原文——必须聚合，
-- 否则 json.decode 失败原样透传，Go 侧 unmarshal 报 invalid character 'd'。
-- 聚合 content / reasoning_content / tool_calls（按 index 拼接分片）/
-- finish_reason / usage；无可解析帧时返回 nil（调用方回退原样）。
local function aggregate_sse(raw)
local content, reasoning = {}, {}
local finish, usage, id, model, created = nil, nil, nil, nil, nil
local tools_by_index = {}
local seen = false
for line in (raw .. "\n"):gmatch("([^\n]*)\n") do
local s = line:gsub("^%s+", ""):gsub("%s+$", "")
if s:sub(1, 5) == "data:" then
local payload = s:sub(6):gsub("^%s+", "")
if payload ~= "" and payload ~= "[DONE]" then
local ok, d = pcall(json.decode, payload)
if ok and type(d) == "table" then
seen = true
id = id or d.id
model = model or d.model
created = created or d.created
if type(d.usage) == "table" then usage = d.usage end
local ch = d.choices and d.choices[1]
if type(ch) == "table" then
if type(ch.finish_reason) == "string" and ch.finish_reason ~= "" then
finish = ch.finish_reason
end
local dl = ch.delta
if type(dl) == "table" then
if type(dl.content) == "string" then content[#content + 1] = dl.content end
if type(dl.reasoning_content) == "string" then
reasoning[#reasoning + 1] = dl.reasoning_content
end
if type(dl.tool_calls) == "table" then
for _, tc in ipairs(dl.tool_calls) do
if type(tc) == "table" and tc.index ~= nil then
local slot = tools_by_index[tc.index]
if slot == nil then
slot = { id = tc.id, type = tc.type or "function",
["function"] = { name = "", arguments = "" } }
tools_by_index[tc.index] = slot
end
if tc.id then slot.id = tc.id end
local fn = tc["function"]
if type(fn) == "table" then
if fn.name then slot["function"].name = slot["function"].name .. fn.name end
if fn.arguments then slot["function"].arguments = slot["function"].arguments .. fn.arguments end
end
end
end
end
end
end
end
end
end
end
if not seen then return nil end
local msg = { role = "assistant", content = table.concat(content) }
local rc = table.concat(reasoning)
if rc ~= "" then msg.reasoning_content = rc end
local ordered = {}
for i = 0, 63 do
if tools_by_index[i] then ordered[#ordered + 1] = tools_by_index[i] end
end
if #ordered > 0 then msg.tool_calls = ordered end
local out = {
id = id or "", object = "chat.completion", created = created or 0,
model = model or "",
choices = { { index = 0, message = msg,
finish_reason = (finish and finish ~= "") and finish or "stop" } },
}
if usage then out.usage = usage end
local ok2, enc = pcall(json.encode, out)
if not ok2 then return nil end
return enc
end
function adapter.transform_response(raw_body)
-- 上游只会回流式（transform_request 强制 stream=true）。客户端要非流式时
-- 内核把完整 SSE 原文交到这里，先聚合再走统一转换。
if type(raw_body) == "string"
and (raw_body:match("^%s*data:") or raw_body:match("[\r\n]data:")) then
local aggregated = aggregate_sse(raw_body)
if aggregated ~= nil then raw_body = aggregated end
end
-- 非流式 OpenAI 响应 → 统一信封。此前在 openai/groq/kimicode/mistral/github
-- 五个适配器里**逐字节相同**（各 2206B，diff 为空），已抽到共享前导。
return __prelude.openai_response(raw_body)
end
function adapter.transform_stream_chunk(raw_chunk)
local ok, chunk = pcall(json.decode, raw_chunk)
if not ok then return "" end
-- OpenAI-style streams may attach usage to a chunk with empty choices
-- (the final usage chunk). Keys must match Go's TokenUsage json tags
-- (prompt/completion/total); the gateway re-emits standard *_tokens.
local uses = nil
if type(chunk.usage) == "table" then
uses = {
prompt = chunk.usage.prompt_tokens or chunk.usage.prompt or 0,
completion = chunk.usage.completion_tokens or chunk.usage.completion or 0,
total = chunk.usage.total_tokens or chunk.usage.total or 0,
}
if type(chunk.usage.prompt_tokens_details) == "table" and chunk.usage.prompt_tokens_details.cached_tokens ~= nil then
uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_tokens_details.cached_tokens }
elseif (chunk.usage.prompt_cache_hit_tokens or 0) > 0 then
uses.prompt_cache_hit_tokens = chunk.usage.prompt_cache_hit_tokens
uses.prompt_cache_miss_tokens = chunk.usage.prompt_cache_miss_tokens or 0
uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_cache_hit_tokens }
end
end
if not chunk.choices or #chunk.choices == 0 then
if uses ~= nil then
-- usage-only chunk is not a content/finish signal; the gateway
-- emits its own terminal stop chunk and merges this usage.
return json.encode({ usage = uses, done = false })
end
return ""
end
local delta = chunk.choices[1].delta or {}
local fr = chunk.choices[1].finish_reason
local finish = (type(fr) == "string" and fr ~= "") and fr or nil
local unified = {
content = delta.content or "",
done = (finish ~= nil)
}
if finish then
unified.finish_reason = finish
end
if uses ~= nil then
unified.usage = uses
end
if delta.reasoning_content then
unified.reasoning_content = delta.reasoning_content
end
if type(delta.tool_calls) == "table" and #delta.tool_calls > 0 then
-- Do not serialize an empty Lua table as JSON `{}`. That shape is
-- neither an OpenAI tool-call array nor an omitted field, and several
-- agent clients reject it on the final chunk.
for _, tc in ipairs(delta.tool_calls) do
if type(tc) == "table" and tc.id ~= nil then
tc.id = safe_tool_id(tc.id)
end
end
unified.tool_calls = delta.tool_calls
end
return json.encode(unified)
end
-- 错误收敛：标准 OpenAI 信封 {error:{message,...}}
function adapter.transform_error(status, body)
-- OpenAI 风格错误体抽消息。此前在 deepseek/github/groq/kimicode/
-- openai/sensenova 六个适配器里逐字节相同（各 293B），已抽到共享前导。
return __prelude.openai_error(status, body)
end
-- ★ build_headers：buddy 要求客户端身份头 + 流式的 Accept。
--
-- 实测（2026-10-16）：不发 `Accept: text/event-stream` 时上游接受请求（200）
-- 但只回一帧空内容（completion_tokens=0），既不报错也不产出正文 —— 表现是
-- "模型不回答"，极易误判成模型坏了或额度不足。
-- 参考 buddy-adapter.ts 的 send() 固定发该头。
--
-- 身份头照参考 credentialRequestHeaders + CODEBUDDY 产品配置：
-- X-Domain 用产品域（不用凭据里的 domain 快照，那是登录时的区域，
-- 跨产品迁移后会指错区）；X-Product 是**部署类型**（SaaS）；X-Product-Code
-- 是产品码（codebuddy）。
function adapter.build_headers(meta)
local h = {
["Accept"] = "text/event-stream",
["Content-Type"] = "application/json",
["X-Domain"] = "copilot.tencent.com",
["X-Product"] = "SaaS",
["X-Product-Code"] = "codebuddy",
["User-Agent"] = "CodeBuddyIDE/1.106.1",
}
-- Authorization 由内核在 buildHeaders 之后补（值为源的 api_key）——
-- 这里显式给出同一份，保证与其它 buddy 请求形态一致。
if type(meta) == "table" and type(meta.api_key) == "string" and meta.api_key ~= "" then
h["Authorization"] = "Bearer " .. meta.api_key
end
return h
end
return adapter

79
internal/lua/adapters/kimicode.lua
View File

@ -1,79 +0,0 @@
local adapter = {}
adapter.name = "kimicode"
adapter.version = "1.0.0"
adapter.endpoint = "/v1/chat/completions"
adapter.headers = {}
-- KimiCode / Kimi K2 属于 OpenAI 兼容协议；但部分云端 API 会校验调用方
-- "app"（只放行特定 agent），要求每次请求带上按 secret 计算的应用签名。
-- 这里演示 build_headers 钩子：基于 timestamp + 请求体哈希生成签名头。
--
-- 配置要求（source.meta）:
-- meta:
-- app_id: <申请到的 app id>
-- app_key: <你的 key（由网关的 base_url 复用 api_key 亦可）>
-- app_secret: <签名密钥>
-- app_agent: code-agent # 若云端要求声明 agent 身份
function adapter.transform_request(raw_body)
local ok, req = pcall(json.decode, raw_body)
if not ok then return raw_body end
req.model = req.model or "kimi-k2"
-- The gateway's private control fields are GONE from the body (v2): the
-- neutral `thinking` field carries that intent and each adapter maps it in
-- its own protocol terms. These upstreams have no thinking switch at all,
-- so the field is simply dropped here — which is what the nil-ing below
-- used to do, except the field being dropped is no longer the kernel's
-- private one.
req.thinking = nil
req.extra_body = nil
return json.encode(req)
end
-- 可选的动态签名钩子。meta 由 Go 注入：
-- meta.url / meta.method / meta.body / meta.api_key / meta.timestamp / meta.source.meta
function adapter.build_headers(meta)
local h = {
["Content-Type"] = "application/json",
["X-App-Id"] = tostring((meta.source.meta or {}).app_id or ""),
["X-Timestamp"] = tostring(meta.timestamp),
}
local agent = (meta.source.meta or {}).app_agent
if agent and agent ~= "" then
h["X-Agent"] = agent
end
-- 校验 app：通常要求 Authorization 用 app secret 派生签名
local secret = (meta.source.meta or {}).app_secret
local api_key = meta.source.meta and meta.source.meta.api_key or meta.api_key
if secret and secret ~= "" then
local body_hash = sha256_hex(meta.body)
local sign_string = tostring(meta.timestamp) .. meta.method .. meta.url .. body_hash
local sign = hmac_sha256_hex(secret, sign_string)
h["Authorization"] = "Bearer " .. api_key
h["X-App-Sign"] = sign
else
h["Authorization"] = "Bearer " .. api_key
end
return h
end
function adapter.transform_response(raw_body)
-- 非流式 OpenAI 响应 → 统一信封。此前在 openai/groq/kimicode/mistral/github
-- 五个适配器里**逐字节相同**（各 2206B，diff 为空），已抽到共享前导。
return __prelude.openai_response(raw_body)
end
function adapter.transform_stream_chunk(raw_chunk)
-- 标准 OpenAI SSE → 统一信封。该实现此前在 groq/kimicode/mistral/github
-- 四个适配器里**逐字节重复**（各 2211B），已抽到共享前导。
return __prelude.openai_stream_chunk(raw_chunk)
end
-- 错误收敛：kimi 网关为 OpenAI 风格 {error:{message,...}}
function adapter.transform_error(status, body)
-- OpenAI 风格错误体抽消息。此前在 deepseek/github/groq/kimicode/
-- openai/sensenova 六个适配器里逐字节相同（各 293B），已抽到共享前导。
return __prelude.openai_error(status, body)
end
return adapter

586
internal/lua/adapters/opencodezen.lua
View File

@ -1,586 +0,0 @@
local adapter = {}
adapter.name = "opencodezen"
adapter.version = "1.1.0"
adapter.endpoint = "/chat/completions"
-- ★ hidden：不进用户可见适配器列表（v1.1.0）。本适配器是 OpenCode 免费层的
-- **门禁专用形态**（强制 stream、注入 read 桩工具、会话号服从倒计时公式），
-- 直接暴露会被误当成通用 OpenAI 适配器选去接别的上游，结果不可预测。
-- 被 localzen 源引用时内核仍会把它列出来（源编辑器回显），其余场合隐藏。
adapter.hidden = true
-- OpenCode Zen（按量付费端点，https://opencode.ai/zen/v1）
--
-- 与 OpenCode Go（opencodego.lua，https://opencode.ai/zen/go/v1）是两个不同的
-- 服务，行为要求并不相同，因此各有专用适配器：
--
-- * 本适配器（Zen）服务免费池 / 按量付费池。免费模型必须带 opencode 客户端
-- 指纹（UA + x-opencode-*），否则上游拒绝："free tier can only be used in
-- OpenCode"。
-- ★ reasoning_content：**保留**（与 Go 侧一致）。此前这里写「剥掉」是基于
-- 「免费池以非 thinking 模型为主、回传会报错」的假设，**生产实测已证伪** ——
-- 剥掉恰恰会引发
-- The `reasoning_content` in the thinking mode must be passed back to the API
-- （详见 transform_request 内的长注释：失败只在「上一轮真的产出了 reasoning」
-- 时才出现，故表现为同一会话里成功/失败交替，极难归因）。
-- 参考的共享序列化器（openai-compat.ts）也是「有就回传」。
-- * Go 订阅读者请看 opencodego.lua：那边**必须**回传 reasoning_content，
-- 否则 thinking 模式直接 400。
--
-- 缺 x-opencode-client/session/request/project 身份头会被判为匿名客户端，
-- 部分模型在带 tools 时上游直接失败（流式返回单 chunk
-- "finish_reason":"network_error" 空 content，非流式 503
-- "Endpoint is unavailable"，表现为"空回复"）。
-- ============================================================================
-- ★ opencode Zen 免费层门禁（2026-10-15 实测解出，逐条对齐官方 CLI）
--
-- 上游对免费池有**三个**必须同时满足的条件，缺任一则 403 FreeTierError
-- （"free tier can only be used from within OpenCode"），与 UA / TLS 指纹 / 凭据来源
-- 均无关：
--
-- 1. 端点必须是 /inference/v1/chat/completions（不是 /zen/v1）
-- —— 由源的 base_url 决定，不在本适配器内。
-- 2. 必须同时发 x-opencode-session **与** x-opencode-session-id（值相同）。
-- 两个 id 的 12 位 hex 段由**确定公式**给出（见下），不是随机数；
-- 时间容差实测 ≥ 60 秒，故 os.time() 的秒精度足够。
-- 3. 请求的 tools 里必须有一个名为 read 的工具，且其 parameters.properties
-- **非空**。这是唯一的 tools 要求：实测抽掉官方 11 个工具中的任意一个均为
-- 200，**只有抽掉 read 变 403**；且 properties 里放任意属性名即可，
-- 描述文字 / $schema / required 都不需要（properties 为空对象则 403）。
-- ⇒ 无 tools 的纯对话请求会被拒，故 transform_request 需兜底注入桩工具。
-- 4. **stream 必须为 true**：实测同为合法请求，stream=false 恒 403、stream=true 恒 200
-- （包括 max_tokens 20/60/200/1000/32000 均 200）。
-- ⇒ 非流式请求会被拒，故 transform_request 强制 stream=true。
--
-- 明确**不影响**通过的（均实测）：system 内容（含无 system）、消息条数
-- （2/3/4/6 条均 200）、凭据（Bearer public 与普通 API key 均可）、
-- x-opencode-project / x-opencode-client / UA 里的 opencode/ 前缀。
--
-- ⚠️ 参考实现 dsh-our-free-model 的门禁桩（bash + read，但无真实 properties）
-- 恰好卡在第 3 条上 —— 即它「伪装需跟进上游更新」的真实原因。
adapter.headers = {
["User-Agent"] = "opencode/1.19.4 ai-sdk/provider-utils/4.0.23 runtime/bun/1.4.4",
}
-- rand_id：按官方的 48-bit 公式生成 12 位 hex 段 + 14 位 base62 随机段。
--
-- 公式逆自官方 CLI 本地库（~/.local/share/opencode/opencode.db 的 session 表，
-- 用 11/12 条真实 id 逐条比对完全一致）：
--
-- MASK = 2^48 - 1
-- K = 0x1afffffffffffe （注意不是 27<<48，两者差 2）
-- session 段 = (K - now_ms * 4096) & MASK ← **倒计时式**：Δseg/Δms ≡ -4096
-- request 段 = (now_ms * 16) & MASK
--
-- 为什么是「倒计时」而不是时间戳：0x1afffffffffffe 减去 ms*2^12，所以 seg 随
-- 时间**递减**。用 f"{ms:012x}" 之类的正向写法必然不对（我为此错过一轮）。
--
-- ⚠️ 精度：now_ms*4096 ≈ 7.3e15 < 2^53 ≈ 9.0e15，在 double 安全整数范围内，
-- 故 LuaJIT 的默认数字类型（double）直接算即可，无需大整数库。
local B62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
local MASK48 = 281474976710655 -- 2^48 - 1
local ID_K = 0x1afffffffffffe
local function rand_tail(n)
local out = {}
for i = 1, n do
local v = 0
if math and math.random then
v = math.random(1, 62)
else
-- 无 math 时用时间做退化熵源：只要唯一，不要求密码学强度。
v = (os.time() * 7 + i * 13) % 62 + 1
end
out[i] = B62:sub(v, v)
end
return table.concat(out)
end
-- now_ms：毫秒。沙箱只有 os.time()（秒）与 os.clock()（CPU 时间，无用），
-- 而上游时间容差实测 ≥ 60 秒，故秒精度足够；毫秒位补 0。
-- meta.timestamp 由内核给出（同为秒），优先用它以便同一请求内自洽。
local function now_ms(meta)
local t = tonumber(meta and meta.timestamp) or (os.time and os.time()) or 0
return t * 1000
end
local function rand_id(prefix, ms, kind, affinity)
local seg
if kind == "session" then
seg = (ID_K - ms * 4096) % (MASK48 + 1)
else
seg = (ms * 16) % (MASK48 + 1)
end
-- %012x：12 位十六进制，不足补零
-- affinity（可空）：会话亲和键。非空时其 8 位 hex 摘要混入 tail ——
-- 同一分钟桶内不同会话得到不同会号；hex 段不受影响（门禁只校验它）。
local tail
if type(affinity) == "string" and affinity ~= "" then
tail = string.sub(sha256_hex(affinity), 1, 8) .. rand_tail(6)
else
tail = rand_tail(14)
end
return prefix .. string.format("%012x", seg) .. tail
end
-- session_bucket_ms 决定上游会话号的**稳定周期**（按整分钟对齐）。
--
-- 为什么需要稳定：上游前缀缓存是会话级的（实测：同一段 6032 token 提示词，
-- 固定会号第 2 次命中 5888；每请求换会号则恒为 0 命中）。而免费层门禁要求
-- x-opencode-session 的 12 位 hex 段服从「倒计时」公式（见 rand_id 注释），
-- 所以不能真的「随便挑一个固定值」，只能选一个**时间桶**。
--
-- 取整分钟（而非秒）：同一分钟内的所有请求共享一个会话号 ⇒ 既保留缓存命中，
-- 又不超出上游的时间容差。实测容差 ≥ 1 小时（-3600s 仍 200），
-- 所以一分钟桶有很大余量，即便上游收紧到几分钟也仍然安全。
-- ★ 会话亲和（v1.1.0，移植自 _local_archive 版本）：整分钟桶让**所有请求**
-- 共享会号，多会话并发时互相污染缓存键。改进：桶内再按**会话身份**分桶——
-- 1) meta.client_session（pi 等真会话客户端自带，会话恒定）
-- 2) 退路：历史里第一条 user 消息做会话指纹（通用 OpenAI 客户端不发任何
-- 会话标识，实测抓包确认；第一条 user 消息在整个会话里恒定）
-- 3) 再退：无 user 消息时退回纯时间桶（与 v1.0 行为一致）
-- 实现：把会话身份 hash 进 14 位 base62 随机段（hex 段仍服从门禁公式）。
local function conversation_fingerprint(body)
if type(body) ~= "string" or body == "" then return "" end
local ok, req = pcall(json.decode, body)
if not ok or type(req) ~= "table" then return "" end
for _, m in ipairs(req.messages or {}) do
if type(m) == "table" and m.role == "user" then
local c = m.content
if type(c) == "string" then
if c ~= "" then return c end
elseif type(c) == "table" then
for _, part in ipairs(c) do
if type(part) == "table" and part.type == "text" and part.text then
return part.text
end
end
end
return ""
end
end
return ""
end
local function session_affinity_key(meta)
local cs = meta and meta.client_session
if type(cs) == "string" and cs ~= "" then return cs end
return conversation_fingerprint(meta and meta.body)
end
local function session_bucket_ms(meta)
local ms = now_ms(meta)
return ms - (ms % 60000)
end
function adapter.build_headers(meta)
local ms = now_ms(meta)
local bucket = session_bucket_ms(meta)
-- ★ 本函数的头集合以**官方 CLI 抓包**为准（opencode 1.19.4，2026-10-24
-- 通过本地抓包代理取得明文请求）。官方实际发这五个 x-opencode-* 头：
--
-- x-opencode-client: cli
-- x-opencode-project: global
-- x-opencode-request: msg_<12hex><14base62>
-- x-opencode-session: ses_<12hex><14base62>
-- x-opencode-session-id: ses_<12hex><14base62> ← 与 session 同值
--
-- ⚠⚠ 这里有一个**版本相关的陷阱**，用实测记录，因为它反反复复：
-- 同一台机器、同一个 `Bearer public` 凭据、同一个模型：
--
-- CLI 1.18.29（只发 4 个头，无 session-id） → "Free usage limit reached"
-- CLI 1.19.4 （发 5 个头，含 session-id） → 200，任务真实完成
--
-- 我一度根据 1.18.29 的抓包删掉了 `x-opencode-session-id`，并把注释
-- 改写成「官方根本不发这个头」。**那是错的** —— 旧版客户端当时的报错
-- 本来就是额度不足，不是头缺失；而新版上游确实要这个头。删掉它会让
-- 1.19.x 的指纹不匹配，重新落回 429。
--
-- 结论：头集合必须与 **UA 里声称的版本**一致。声称 1.19.4 就必须发 5 个头。
-- 将来升级 UA 时，必须**重新抓包**该版本的发头集合，不能沿用旧结论。
--
-- 会话亲和键（可空）混入 tail：同一分钟桶内不同会话得到不同会号，
-- 同一会话跨分钟仍共享指纹 ⇒ 前缀缓存按会话命中而非按分钟命中。
local sid = rand_id("ses_", bucket, "session", session_affinity_key(meta))
return {
["User-Agent"] = adapter.headers["User-Agent"],
["x-opencode-client"] = "cli",
-- project 固定：同网关实例共享一个工作区身份（官方也发同样值）
["x-opencode-project"] = "global",
["x-opencode-session"] = sid,
-- ★ 1.19.4 实测**必须**并发这一份（与 session 同值）。见上面的版本陷阱。
["x-opencode-session-id"] = sid,
-- request id 每请求唯一（不参与缓存键），用当前时间而非桶，避免同桶内重复
["x-opencode-request"] = rand_id("msg_", ms, "request"),
}
end
-- ============================================================================
-- ★ 免费层 tools 兜底：上游要求 tools 里必须有一个名为 read、且
-- parameters.properties 非空的工具（实测唯一要求；抽掉它即 403）。
-- 纯对话请求（客户端没传 tools）会被拒，故这里注入一个桩工具。
--
-- 只补缺，不改用户已有的 tools：用户自带 read 时原样透传（官方 CLI 就是这么发的），
-- 用户带的其它工具保留不动。
local FREE_GATE_TOOL = "read"
local function ensure_free_gate_tool(req)
local tools = req.tools
if type(tools) ~= "table" then tools = {} req.tools = tools end
for _, t in ipairs(tools) do
if type(t) == "table" then
local fn = t["function"]
-- 注意：function 是 Lua 关键字，必须用 req["function"] 形式取下标。
if type(fn) == "table" and fn.name == FREE_GATE_TOOL then
local p = fn.parameters
-- 已有 read 但 properties 为空 ⇒ 补上；否则原样保留用户定义。
if type(p) == "table" and type(p.properties) == "table"
and next(p.properties) ~= nil then
return
end
fn.parameters = { type = "object",
properties = { filePath = { type = "string", description = "Path to read" } } }
return
end
end
end
tools[#tools + 1] = {
type = "function",
["function"] = {
name = FREE_GATE_TOOL,
description = "Read a file from the local filesystem.",
parameters = { type = "object",
properties = { filePath = { type = "string", description = "Path to read" } },
required = { "filePath" } },
},
}
end
-- OpenAI /chat/completions format (pass-through, strip provider-specific fields)
-- zen 上游 schema 只接受 text content part（无视觉/音频能力）：多模态 part
-- （image_url / input_audio / file 等）一律剥离。剥离后 content 变空的消息
-- 若不再携带 tool_calls / tool_call_id 才整条丢弃（避免上游
-- "unknown variant `image_url`, expected `text`"）；带工具调用的必须保留，
-- 否则会把紧随其后的 tool 结果变成孤儿，模型会反复重发同一个调用。
-- zen 上游角色白名单只有 system / user / assistant / tool / latest_reminder：
-- OpenAI 的 developer（及 function 等）不在其中，直接透传会触发上游
-- "unknown variant `developer`, expected one of ..." 错误；统一归一化为 system。
local ROLE_WHITELIST = {
system = true,
user = true,
assistant = true,
tool = true,
latest_reminder = true,
}
function adapter.transform_request(raw_body)
local ok, req = pcall(json.decode, raw_body)
if not ok then return raw_body end
-- ★ 免费层 gate：tools 里必须有 read（且 parameters.properties 非空）。
-- 放在最前面：它决定本请求会不会被 403，与后面的字段清理无关。
-- 对所有模型都注入：免费池与付费池共用同一层形状检查，多一个桩工具无害
-- （官方 CLI 本来也带全套工具），但缺了它会让免费模型整体失效。
ensure_free_gate_tool(req)
-- ★ 免费层只接受流式：实测 stream=false 恒 403（同样 body 改 true 即 200）。
-- 转成流式由上游以 SSE 回应，内核本就会聚合/透传流式响应，故对客户端透明。
req.stream = true
req.disable_thinking = nil
req.extra_body = nil
-- stream_options is only valid alongside stream:true; sending it on a
-- non-streaming request is rejected by strict upstreams.
if req.stream then
if type(req.stream_options) ~= "table" then req.stream_options = {} end
req.stream_options.include_usage = true
end
if req.messages then
local kept = {}
for _, msg in ipairs(req.messages) do
if type(msg.role) == "string" and not ROLE_WHITELIST[msg.role] then
msg.role = "system"
end
-- ★ 必须**保留** reasoning_content（不再剥离）。
--
-- 历史：这里原先写 `msg.reasoning_content = nil`，理由是「Zen 免费池
-- 不接受回传」。**生产实测证伪**（2026-10-16）：
-- provider localzen: api error 400: Upstream request failed:
-- [invalid_request_error] The `reasoning_content` in the thinking
-- mode must be passed back to the API.
-- 失败形态很隐蔽：**同一模型同一会话里成功与失败交替出现** ——
-- 因为只有当上一轮**真的产出了 reasoning**（thinking 模型、
-- reasoning_effort 开启、长上下文）时，回放该历史才会被拒；
-- 剥掉之后，客户端看到的 502 与「上一轮想过」这件事毫无关联。
-- 审计文件里能看到成串 502 紧跟在一个 prompt_tokens=139330 的
-- 成功请求之后 —— 那正是「想了、但下一轮我们没把它还回去」。
--
-- 参考实现（`openai-compat.ts` 的 serializeMessages，opencode 适配器
-- 直接复用）在 assistant 回合携带 reasoning 时**就带上**该字段：
-- `...reasoning.length > 0 ? { reasoning_content: reasoning } : {}`
-- 即「有就回传」，没有额外条件 —— 与本适配器此前的假设方向相反。
--
-- ⚠️ 不改成「仅当 thinking 开启才回传」：我们**无法**从请求里可靠
-- 判定上游是否处于 thinking 模式（真正知道的是上游）。而「有就回传」
-- 是零风险方向 —— 上游不需要时忽略即可（实测传与不传同为 200），
-- 需要时缺了就是硬 400。
if type(msg.reasoning_content) == "string" and msg.reasoning_content == "" then
msg.reasoning_content = nil
end
local drop = false
if type(msg.content) == "table" then
local parts = {}
for _, part in ipairs(msg.content) do
if type(part) == "table" and part.type ~= nil and part.type ~= "text" then
-- multimodal part not supported by zen
else
table.insert(parts, part)
end
end
if #parts == 0 then
-- Content collapsed to nothing after stripping unsupported
-- parts. A message that still carries a tool call must
-- NEVER be dropped: the very next message is its tool
-- result, and dropping the call orphans that result. The
-- model then sees a result for a call it never made and
-- re-issues the same tool call on every turn (observed as
-- an infinite "repeated tool call" loop).
if (type(msg.tool_calls) == "table" and #msg.tool_calls > 0)
or msg.tool_call_id ~= nil then
msg.content = ""
else
drop = true
end
else
msg.content = parts
end
end
if not drop then
table.insert(kept, msg)
end
end
req.messages = kept
end
return json.encode(req)
end
-- ★ aggregate_sse：把 SSE 流（openai chat.completion.chunk 形状）聚合成一个非流式
-- 响应对象，供 transform_response 在「客户端要非流式、上游却回流式」时使用。
-- 返回 JSON 字符串；无法聚合（无任何 chunk）时返回 nil。
--
-- 只处理 content / reasoning_content / finish_reason / usage 四类增量：
-- 它们覆盖了内核需要从响应里取的全部字段（正文、结束原因、token 计数）。
local function aggregate_sse(raw)
local content, reasoning, finish = {}, {}, ""
local usage, id, model, created = nil, nil, nil, nil
local seen = false
for line in (raw .. "\n"):gmatch("([^\n]*)\n") do
local s = line:gsub("^%s+", ""):gsub("%s+$", "")
if s:sub(1, 5) == "data:" then
local payload = s:sub(6):gsub("^%s+", "")
if payload ~= "" and payload ~= "[DONE]" then
local ok, d = pcall(json.decode, payload)
if ok and type(d) == "table" then
seen = true
id = id or d.id
model = model or d.model
created = created or d.created
if type(d.usage) == "table" then usage = d.usage end
local ch = d.choices and d.choices[1]
if type(ch) == "table" then
if ch.finish_reason and ch.finish_reason ~= "" then
finish = ch.finish_reason
end
local dl = ch.delta
if type(dl) == "table" then
if type(dl.content) == "string" then content[#content + 1] = dl.content end
if type(dl.reasoning_content) == "string" then
reasoning[#reasoning + 1] = dl.reasoning_content
end
end
end
end
end
end
end
if not seen then return nil end
local msg = { role = "assistant", content = table.concat(content) }
local rc = table.concat(reasoning)
if rc ~= "" then msg.reasoning_content = rc end
local out = {
id = id or "", object = "chat.completion", created = created or 0, model = model or "",
choices = { { index = 0, message = msg, finish_reason = finish ~= "" and finish or "stop" } },
}
if usage then out.usage = usage end
local ok2, enc = pcall(json.encode, out)
if not ok2 then return nil end
return enc
end
function adapter.transform_response(raw_body)
-- ★ 免费层只接受 stream=true（见文件头门禁第 4 条），所以本适配器把每个请求
-- 都改成了流式 —— 但内核是按**客户端意图**选路径的：客户端发非流式时，
-- 内核走 Provider.Chat 并调本函数（期望 JSON），而上游回的是 SSE。
-- 若在这里直接 json.decode 就会得到 "invalid character 'd'" 错误。
--
-- 因此本函数必须先识别 SSE 并自行聚合，再走原来的 JSON 路径。
-- 这样保持内核对上游协议无感（内核不知道也不该知道上游选了流式）。
if type(raw_body) == "string" and (raw_body:sub(1, 6) == "data: " or raw_body:find("\ndata: ", 1, true)) then
local aggregated = aggregate_sse(raw_body)
if aggregated ~= nil then
local ok2, resp2 = pcall(json.decode, aggregated)
if ok2 and type(resp2) == "table" then raw_body = aggregated end
end
end
local ok, resp = pcall(json.decode, raw_body)
if not ok or resp == nil then return raw_body end
local unified = {
content = "",
finish_reason = "",
token_usage = { prompt = 0, completion = 0, total = 0 }
}
if type(resp.usage) == "table" then
unified.token_usage.prompt = resp.usage.prompt_tokens or 0
unified.token_usage.completion = resp.usage.completion_tokens or 0
unified.token_usage.total = resp.usage.total_tokens or 0
local hit = 0
if type(resp.usage.prompt_tokens_details) == "table" and resp.usage.prompt_tokens_details.cached_tokens ~= nil then
hit = resp.usage.prompt_tokens_details.cached_tokens
unified.token_usage.prompt_tokens_details = { cached_tokens = hit }
end
if (resp.usage.prompt_cache_hit_tokens or 0) > 0 then
unified.token_usage.prompt_cache_hit_tokens = resp.usage.prompt_cache_hit_tokens
unified.token_usage.prompt_cache_miss_tokens = resp.usage.prompt_cache_miss_tokens or 0
if hit == 0 then
unified.token_usage.prompt_tokens_details = { cached_tokens = resp.usage.prompt_cache_hit_tokens }
end
end
-- 上游报告输出里有多少是思考 token。不给客户端的话，无法判断
-- completion_tokens 里多少是「可见回答」、多少是「思考」（都按输出计费）。
local ctd = resp.usage.completion_tokens_details
if type(ctd) == "table" and ctd.reasoning_tokens ~= nil then
unified.token_usage.completion_tokens_details = { reasoning_tokens = ctd.reasoning_tokens }
end
end
-- 本次调用的费用，上游放在**顶层**且是**字符串**（如 "0"、"0.0012"）。
-- Go 订阅是包月制，恒为 "0"；只有 Zen 按量付费模型才有信息量。
-- 原样透传：网关不解析、不换算、不汇总 —— 它只是上游事实的搬运者。
if resp.cost ~= nil then
unified.cost = tostring(resp.cost)
end
if type(resp.choices) == "table" and #resp.choices > 0 then
local ch = resp.choices[1]
if type(ch.message) == "table" then
unified.content = ch.message.content or ""
local reasoning = ch.message.reasoning_content or ch.message.reasoning
if reasoning then
unified.reasoning_content = reasoning
end
if type(ch.message.tool_calls) == "table" then
local tcs = {}
for _, tc in ipairs(ch.message.tool_calls) do
local args_ok, args = pcall(json.decode, tc["function"].arguments)
if not args_ok then args = {} end
table.insert(tcs, {
id = tc.id,
type = tc.type or "function",
name = tc["function"].name,
arguments = args
})
end
unified.tool_calls = tcs
end
end
unified.finish_reason = ch.finish_reason or ""
end
return json.encode(unified)
end
function adapter.transform_stream_chunk(raw_chunk)
local ok, chunk = pcall(json.decode, raw_chunk)
if not ok then return "" end
-- OpenAI-style streams may attach usage to a chunk with empty choices
-- (the final usage chunk). Preserve it; the gateway emits it as the
-- terminal usage chunk. Note: keys must match Go's TokenUsage json tags
-- (prompt/completion/total); the gateway re-emits standard *_tokens.
local uses = nil
if type(chunk.usage) == "table" then
uses = {
prompt = chunk.usage.prompt_tokens or chunk.usage.prompt or 0,
completion = chunk.usage.completion_tokens or chunk.usage.completion or 0,
total = chunk.usage.total_tokens or chunk.usage.total or 0,
}
-- 独立字段与 prompt_tokens_details **并存**透传，不要写成 elseif：
-- 上游命中缓存时两者都发，非流式路径也是两个都带。写成 elseif 会让
-- 流式丢掉 prompt_cache_hit_tokens/miss，与同一源的**非流式**产出不一致
-- （dsh 优先读 details，但只认独立字段的老客户端会看不到缓存）。
if type(chunk.usage.prompt_tokens_details) == "table" and chunk.usage.prompt_tokens_details.cached_tokens ~= nil then
uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_tokens_details.cached_tokens }
end
if (chunk.usage.prompt_cache_hit_tokens or 0) > 0 then
uses.prompt_cache_hit_tokens = chunk.usage.prompt_cache_hit_tokens
uses.prompt_cache_miss_tokens = chunk.usage.prompt_cache_miss_tokens or 0
if uses.prompt_tokens_details == nil then
uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_cache_hit_tokens }
end
end
local ctd = chunk.usage.completion_tokens_details
if type(ctd) == "table" and ctd.reasoning_tokens ~= nil then
uses.completion_tokens_details = { reasoning_tokens = ctd.reasoning_tokens }
end
end
if not chunk.choices or #chunk.choices == 0 then
-- 空 choices 的帧既不是内容也不是结束信号。上游发两种：
-- {"choices":[],"usage":{...}} —— 终帧用量
-- {"choices":[],"cost":"0"} —— 单独的费用帧
-- 两者可能落在同一帧上，必须都转出去；早退只带 usage 会把费用丢干净。
local out = { done = false }
if uses ~= nil then out.usage = uses end
if chunk.cost ~= nil then out.cost = tostring(chunk.cost) end
if uses == nil and chunk.cost == nil then return "" end
return json.encode(out)
end
local delta = chunk.choices[1].delta or {}
local fr = chunk.choices[1].finish_reason
local finish = (type(fr) == "string" and fr ~= "") and fr or nil
local unified = {
content = delta.content or "",
done = (finish ~= nil)
}
if finish then
unified.finish_reason = finish
end
if uses ~= nil then
unified.usage = uses
end
-- zen 用 reasoning 字段承载推理文本（OpenAI 惯例是 reasoning_content）
local reasoning = delta.reasoning_content or delta.reasoning
if reasoning then
unified.reasoning_content = reasoning
end
if delta.tool_calls then
-- pass raw streaming fragments through; OpenAI clients accumulate index+id+name+arguments
unified.tool_calls = delta.tool_calls
end
return json.encode(unified)
end
-- 错误收敛（可选钩子）：zen 错误信封固定为 {error={type,message}}；
-- 免费池限流 FreeUsageLimitError 单独标注。返回 nil 走通用兜底。
function adapter.transform_error(status, body)
local ok, resp = pcall(json.decode, body)
if not ok or type(resp) ~= "table" then return nil end
local e = resp.error
if type(e) ~= "table" then return nil end
if e.type == "FreeUsageLimitError" then
return "zen free pool quota exhausted"
end
return e.message
end
return adapter

292
internal/lua/adapters/trae.lua
View File

@ -1,292 +0,0 @@
-- trae 源适配器（trae-local-api 的 OpenAI 兼容代理）
-- trae-local-api 运行在 http://127.0.0.1:19900，接 Trae CN 账号的云资源。
-- 协议：OpenAI /v1/chat/completions
-- 特性：
-- - 排队：上游 busy 时排队，可能长时间无响应
-- - 非流式请求偶发返回 SSE 数据（upstream bug）
-- - 支持 thinking，由上游模型自动决定是否开启
local adapter = {}
adapter.name = "trae"
adapter.version = "1.0.0"
adapter.endpoint = "/v1/chat/completions"
adapter.headers = {}
function adapter.transform_request(raw_body)
local ok, req = pcall(json.decode, raw_body)
if not ok then return raw_body end
-- The gateway's private control fields are GONE from the body (v2): the
-- neutral `thinking` field carries that intent and each adapter maps it in
-- its own protocol terms. These upstreams have no thinking switch at all,
-- so the field is simply dropped here — which is what the nil-ing below
-- used to do, except the field being dropped is no longer the kernel's
-- private one.
req.thinking = nil
req.extra_body = nil
if req.messages then
for _, msg in ipairs(req.messages) do
msg.reasoning_content = nil
end
end
return json.encode(req)
end
-- parse_text_tool_calls extracts tool calls that an upstream emitted as PLAIN
-- TEXT instead of using the OpenAI tool_calls field.
--
-- trae-local-api's OpenAI endpoint (/v1/chat/completions) does not read the
-- request's `tools` array at all, so the relayed model is never told the tool
-- schema; it falls back to printing
-- <tool_call>
-- {"name": "get_weather", "arguments": {"location": "北京"}}
-- </tool_call>
-- into message.content, leaves message.tool_calls null, and reports
-- finish_reason="stop". A client following the OpenAI contract therefore never
-- sees a tool call: the agent loop terminates unexpectedly mid-conversation
-- (and a hand-written replay produces an empty function name next turn).
--
-- Both tag spellings are accepted: the same codebase's Anthropic endpoint
-- instructs models to emit <toolcall>, and models mix the two. Key names vary
-- too (arguments / params / input), so all are tried.
--
-- Returns (tool_calls_array_or_nil, content_with_blocks_removed).
local function parse_text_tool_calls(content)
if type(content) ~= "string" or content == "" then return nil, content end
local tcs = {}
local idx = 0
local function collect(pattern)
for payload in content:gmatch(pattern) do
local ok, obj = pcall(json.decode, payload)
if ok and type(obj) == "table" then
-- some models wrap it as {"function":{"name":..,"arguments":..}}
local fn = obj["function"]
local name = obj.name or (type(fn) == "table" and fn.name) or nil
if name then
local args = obj.arguments or obj.params or obj.input
if args == nil and type(fn) == "table" then
args = fn.arguments or fn.params
end
if type(args) == "string" then
local aok, decoded = pcall(json.decode, args)
args = aok and decoded or {}
elseif type(args) ~= "table" then
args = {}
end
idx = idx + 1
table.insert(tcs, {
id = obj.id or ("call_text_" .. idx),
type = "function",
name = name,
arguments = args
})
end
end
end
end
-- `<tag ...>` allows attributes; %s* handles the "</tool_call >" spacing
-- that trae-local-api's own prompt example uses.
collect("<tool_call[^>]*>%s*(.-)%s*</tool_call%s*>")
collect("<toolcall[^>]*>%s*(.-)%s*</toolcall%s*>")
-- Legacy / mimicked form: models that saw past assistant turns folded as
-- [Called tool: name({...})]
-- tend to emit the same shape instead of a real block. Recover it so
-- the agent loop keeps working; otherwise the client receives plain text
-- where a structured tool call should be. Capture the name and the JSON
-- object literal independently (the JSON is the only {...} run here).
if #tcs == 0 and content:find("%[Called tool") then
for name, argsraw in content:gmatch("%[Called tool%s*:%s*([%w_%-%.]+)%s*%((%b{})%s*%)%s*%]") do
local aok, decoded = pcall(json.decode, argsraw)
idx = idx + 1
table.insert(tcs, {
id = "call_legacy_" .. idx,
type = "function",
name = name,
arguments = aok and decoded or {}
})
end
end
if #tcs == 0 then return nil, content end
-- drop the blocks from user-visible content; keep any surrounding prose
local stripped = content:gsub("<tool_call[^>]*>%s*.-%s*</tool_call%s*>", "")
stripped = stripped:gsub("<toolcall[^>]*>%s*.-%s*</toolcall%s*>", "")
stripped = stripped:gsub("%[Called tool%s*:%s*[%w_%-%.]+%s*%(%b{}%s*%)%s*%]", "")
stripped = stripped:gsub("^%s+", ""):gsub("%s+$", "")
return tcs, stripped
end
function adapter.transform_response(raw_body)
-- trae-local-api 偶发在非流式请求中返回 SSE 格式数据，
-- 表现为多个 data: {...} 行或混合了 reasoning_chunk 等。
-- 剥掉 data: 前缀，取最后一个完整的 JSON 块（通常是
-- 最终的 stop chunk 或 usage chunk）。
local use_json = raw_body
if raw_body:match("^data:") or raw_body:match("\ndata:") then
-- 取最后一个 data: 行的 JSON
local last = nil
for line in raw_body:gmatch("data: ([^\n\r]+)") do
local trimmed = line:match("^%s*(.-)%s*$")
if trimmed and trimmed ~= "[DONE]" then
local ok2, obj = pcall(json.decode, trimmed)
if ok2 and type(obj) == "table" then
last = obj
end
end
end
if last then
use_json = json.encode(last)
end
-- 如果解析失败，回退到原始 body
end
local ok, resp = pcall(json.decode, use_json)
if not ok or resp == nil then return raw_body end
local unified = {
content = "",
finish_reason = "",
token_usage = { prompt = 0, completion = 0, total = 0 }
}
if type(resp.usage) == "table" then
unified.token_usage.prompt = resp.usage.prompt_tokens or 0
unified.token_usage.completion = resp.usage.completion_tokens or 0
unified.token_usage.total = resp.usage.total_tokens or 0
end
if type(resp.choices) == "table" and #resp.choices > 0 then
local ch = resp.choices[1]
if type(ch.message) == "table" then
unified.content = ch.message.content or ""
if ch.message.reasoning_content then
unified.reasoning_content = ch.message.reasoning_content
end
if type(ch.message.tool_calls) == "table" and #ch.message.tool_calls > 0 then
local tcs = {}
for _, tc in ipairs(ch.message.tool_calls) do
local fn = tc["function"] or {}
local args = fn.arguments
if type(args) == "string" then
local args_ok, decoded = pcall(json.decode, args)
args = args_ok and decoded or {}
elseif type(args) ~= "table" then
args = {}
end
table.insert(tcs, {
id = tc.id,
type = tc.type or "function",
name = fn.name,
arguments = args
})
end
unified.tool_calls = tcs
end
end
unified.finish_reason = ch.finish_reason or ""
-- Fallback: trae-local-api's OpenAI endpoint drops the request's
-- `tools` array entirely, so the relayed model is never told the tool
-- schema and instead PRINTS a <tool_call>{...}</tool_call> block into
-- content, leaving message.tool_calls null and finish_reason="stop".
-- A client following the OpenAI contract then sees a normal completion
-- and its agent loop terminates mid-conversation. Recover the
-- structured call so the loop can continue.
if unified.tool_calls == nil then
local recovered, cleaned = parse_text_tool_calls(unified.content)
if recovered then
unified.tool_calls = recovered
unified.content = cleaned
unified.finish_reason = "tool_calls"
end
end
end
return json.encode(unified)
end
function adapter.transform_stream_chunk(raw_chunk)
local ok, chunk = pcall(json.decode, raw_chunk)
if not ok then return "" end
local uses = nil
if type(chunk.usage) == "table" then
uses = {
prompt = chunk.usage.prompt_tokens or chunk.usage.prompt or 0,
completion = chunk.usage.completion_tokens or chunk.usage.completion or 0,
total = chunk.usage.total_tokens or chunk.usage.total or 0,
}
if type(chunk.usage.prompt_tokens_details) == "table" and chunk.usage.prompt_tokens_details.cached_tokens ~= nil then
uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_tokens_details.cached_tokens }
elseif (chunk.usage.prompt_cache_hit_tokens or 0) > 0 then
uses.prompt_cache_hit_tokens = chunk.usage.prompt_cache_hit_tokens
uses.prompt_cache_miss_tokens = chunk.usage.prompt_cache_miss_tokens or 0
uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_cache_hit_tokens }
end
end
if not chunk.choices or #chunk.choices == 0 then
if uses ~= nil then
return json.encode({ usage = uses, done = false })
end
return ""
end
local delta = chunk.choices[1].delta or {}
local fr = chunk.choices[1].finish_reason
local finish = (type(fr) == "string" and fr ~= "") and fr or nil
local unified = {
content = delta.content or "",
done = (finish ~= nil)
}
if finish then
unified.finish_reason = finish
end
if uses ~= nil then
unified.usage = uses
end
if delta.reasoning_content then
unified.reasoning_content = delta.reasoning_content
end
if type(delta.tool_calls) == "table" and #delta.tool_calls > 0 then
unified.tool_calls = delta.tool_calls
end
return json.encode(unified)
end
function adapter.transform_error(status, body)
local ok, resp = pcall(json.decode, body)
if not ok or type(resp) ~= "table" then
-- Non-JSON body: extract title from HTML or first line
local title = string.match(body or "", "<title>(.-)</title>")
if title and title ~= "" then return title end
local line = string.match(body or "", "^%s*([^\r\n]+)")
if line and line ~= "" and not string.match(line, "^<") then
return string.sub(line, 1, 200)
end
return nil
end
local e = resp.error
if type(e) == "table" and type(e.message) == "string" then
-- trae quota / rate limit annotations
if e.code then
return tostring(e.code) .. ": " .. e.message
end
return e.message
end
if type(e) == "string" then return e end
if type(resp.message) == "string" and resp.message ~= "" then
if resp.code ~= nil then
return tostring(resp.code) .. ": " .. resp.message
end
return resp.message
end
return nil
end
return adapter