mslxdff 0.1.136 → 0.1.140

package/src/providers/codearts/sign.js

@@ -0,0 +1,96 @@
+// 华为云 SDK-HMAC-SHA256 请求签名（AK/SK + 可选 STS security token）。
+// 对齐 @huaweicloud/huaweicloud-sdk-core AKSKSigner（逆向参考：HITZY2002/codearts2api internal/upstream/signer.go）：
+//   - SignedHeaders = 请求全部头（小写排序，含 host / x-sdk-content-sha256 / maas_type）
+//   - CanonicalURI 每段 percent-encode 且末尾补 "/"
+//   - payload hash 取 X-Sdk-Content-Sha256（= 请求体原样 sha256 hex）
+import crypto from "node:crypto";
+
+export const SIGN_ALGORITHM = "SDK-HMAC-SHA256";
+
+export function sha256Hex(data) {
+  const buf = typeof data === "string" ? Buffer.from(data, "utf8") : (data || Buffer.alloc(0));
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+export function hmacHex(key, msg) {
+  return crypto.createHmac("sha256", String(key || "")).update(String(msg || ""), "utf8").digest("hex");
+}
+
+// Go url.PathEscape(encodePathSegment)：仅 / ; , ? 与非 URI 字符转义。
+// 本项目全部端点路径均为纯字母数字（恒等），此处按 RFC3986 pchar 集保守实现。
+const PCHAR = /[^A-Za-z0-9\-._~!$&'()*+,;=:@]/g;
+function escapeSegment(seg) {
+  return String(seg || "").replace(PCHAR, (c) => encodeURIComponent(c));
+}
+
+// 末尾强制补 "/"（对齐 JS SDK CanonicalURI；漏掉即签名失败）。
+export function canonicalUriPath(pathname) {
+  const out = String(pathname || "/").split("/").map(escapeSegment).join("/");
+  return out.endsWith("/") ? out : out + "/";
+}
+
+// Go url.QueryEscape：空格 → "+"；key/value 各自排序。
+const QESC = (s) => encodeURIComponent(s).replace(/%20/g, "+").replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase());
+function decodeSafe(s) { try { return decodeURIComponent(s); } catch { return s; } }
+
+export function canonicalQuery(rawQuery) {
+  const raw = String(rawQuery || "");
+  if (!raw) return "";
+  const pairs = raw.replace(/^\?/, "").split("&").filter(Boolean).map((p) => {
+    const i = p.indexOf("=");
+    const k = i < 0 ? p : p.slice(0, i);
+    const v = i < 0 ? "" : p.slice(i + 1);
+    return [decodeSafe(k), decodeSafe(v)];
+  });
+  pairs.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0));
+  return pairs.map(([k, v]) => `${QESC(k)}=${QESC(v)}`).join("&");
+}
+
+// 全部请求头（小写 key 排序；值 TrimSpace）→ canonical 行集 + SignedHeaders 串。
+export function canonicalHeaders(headers) {
+  const canon = {};
+  for (const [k, v] of Object.entries(headers || {})) {
+    if (v === undefined || v === null) continue;
+    canon[k.toLowerCase()] = String(v).trim();
+  }
+  const keys = Object.keys(canon).sort();
+  const lines = keys.map((k) => `${k}:${canon[k]}\n`).join("");
+  return { canonical: lines, signed: keys.join(";"), canon };
+}
+
+/**
+ * 给请求补签名头：x-sdk-date / x-security-token / x-sdk-content-sha256 / authorization。
+ * @param {object} p
+ * @param {string} p.method  HTTP 方法
+ * @param {string} p.url     完整 URL（host 取自这里）
+ * @param {object} p.headers 签名前已就位的全部业务头（maas_type 必须已含）
+ * @param {string|Buffer} [p.body] 请求体原样字节
+ * @param {{accessKeyId, secretAccessKey, securityToken?}} p.cred
+ * @returns {{headers: object, stringToSign: string, canonicalRequest: string}} 最终待发送头
+ */
+export function signRequest({ method, url, headers = {}, body = "", cred, now = new Date() }) {
+  const u = new URL(url);
+  const xDate = now.toISOString().slice(0, 19).replace(/[-:]/g, "") + "Z";
+  const payloadHash = sha256Hex(body);
+  const h = { ...headers };
+  if (cred?.securityToken) h["x-security-token"] = cred.securityToken;
+  h["x-sdk-date"] = xDate;
+  h["x-sdk-content-sha256"] = payloadHash;
+  // host 进签名集（Go 显式 Set("Host")）；fetch 会按 URL 自发同值 Host 头，服务端验签一致。
+  h["host"] = u.host;
+  const { canonical, signed } = canonicalHeaders(h);
+  const canonicalRequest = [
+    String(method || "GET").toUpperCase(),
+    canonicalUriPath(u.pathname),
+    canonicalQuery(u.search),
+    canonical,
+    signed,
+    payloadHash,
+  ].join("\n");
+  const stringToSign = [SIGN_ALGORITHM, xDate, sha256Hex(canonicalRequest)].join("\n");
+  const signature = hmacHex(cred?.secretAccessKey, stringToSign);
+  const finalHeaders = { ...h };
+  delete finalHeaders.host; // host 头由 HTTP 客户端自行发出，不在 fetch 头里透传
+  finalHeaders.authorization = `${SIGN_ALGORITHM} Access=${cred?.accessKeyId || ""}, SignedHeaders=${signed}, Signature=${signature}`;
+  return { headers: finalHeaders, stringToSign, canonicalRequest };
+}

package/src/providers/codearts/sse.js

@@ -0,0 +1,204 @@
+// CodeArts SSE 帧解析（纯函数，无 IO）。
+// 线格式（实测，对齐 codearts2api internal/upstream/sse.go）：逐行 `data: <json>`，
+// 无空行分隔、部分行无 event: 前缀；同时兼容标准 event:+data:+空行。
+// 帧：起始 {id,model,type:"answer",chat_id,…}；全文快照 {text:"<累计全文>",output,
+// prompt_tokens,completion_tokens}（text 是快照非增量 → 替换语义）；增量
+// {choices:[{delta:{content,reasoning_content,tool_calls}}]} 或顶层 {delta:{…}}；
+// 结束 {"text":"[DONE]","error_code":"0"}；错误 {"error_code":"…","error_msg":"…"}。
+
+export function createSseState() {
+  return { pendingEvent: "", content: "", reason: "", finish: "", usage: null, error: null, done: false, calls: new Map(), forward: null };
+}
+
+// 降级：finish_reason=tool_calls 但 calls 为空（上游偶发空 tool_calls 帧 + 零文本，
+// 真机 glm-5.3-flash 实测）→ 降 stop，否则 OpenAI 客户端判"无输出结束回合"报错。
+// 注意：有真实 tool_calls 时必须原样透传，否则工具链断裂。
+export function effectiveFinish(st) {
+  if (st?.finish === "tool_calls" && !(st?.calls?.size > 0)) return "stop";
+  return st?.finish || "stop";
+}
+
+export function scanLine(line, state) {
+  const raw = String(line || "").replace(/\r?\n$/, "");
+  if (raw.startsWith("event:")) { state.pendingEvent = raw.slice(6).trim(); return null; }
+  if (raw.startsWith("data:")) {
+    const ev = state.pendingEvent || "";
+    state.pendingEvent = "";
+    return { event: ev, data: raw.slice(5).trim() };
+  }
+  if (!raw.trim()) { state.pendingEvent = ""; return null; }
+  return null;
+}
+
+// OpenAI 兼容 chunk：choices[0].delta 或顶层 delta。
+export function deltaFromChunk(payload) {
+  if (payload?.delta && typeof payload.delta === "object") return { delta: payload.delta, finishReason: "" };
+  const choices = Array.isArray(payload?.choices) ? payload.choices : [];
+  if (!choices.length || typeof choices[0] !== "object") return { delta: null, finishReason: "" };
+  const c0 = choices[0];
+  return {
+    delta: c0.delta && typeof c0.delta === "object" ? c0.delta : null,
+    finishReason: typeof c0.finish_reason === "string" ? c0.finish_reason : "",
+  };
+}
+
+// tool_calls 分片按 index 聚合（id/type/name/arguments 增量拼接）。
+export function applyToolCallDeltas(st, delta) {
+  const rawCalls = delta?.tool_calls;
+  if (!Array.isArray(rawCalls)) return;
+  rawCalls.forEach((raw, position) => {
+    if (!raw || typeof raw !== "object") return;
+    const index = typeof raw.index === "number" ? raw.index : position;
+    let call = st.calls.get(index);
+    if (!call) { call = { index, type: "function", id: "", function: { name: "", arguments: "" } }; st.calls.set(index, call); }
+    if (typeof raw.id === "string" && raw.id) call.id = raw.id;
+    if (typeof raw.type === "string" && raw.type) call.type = raw.type;
+    const fn = raw.function;
+    if (fn && typeof fn === "object") {
+      if (typeof fn.name === "string") call.function.name += fn.name;
+      if (typeof fn.arguments === "string") call.function.arguments += fn.arguments;
+    }
+  });
+}
+
+export function sortedToolCalls(st) {
+  return [...st.calls.keys()].sort((a, b) => a - b).map((i) => {
+    const c = st.calls.get(i);
+    return { index: c.index, type: c.type || "function", id: c.id, function: { name: c.function.name, arguments: c.function.arguments } };
+  });
+}
+
+const firstText = (payload, keys) => {
+  for (const k of keys) if (typeof payload?.[k] === "string") return payload[k];
+  return "";
+};
+
+function markUsage(st, payload) {
+  const p = Number(payload?.prompt_tokens), c = Number(payload?.completion_tokens);
+  if (Number.isFinite(p) || Number.isFinite(c)) {
+    st.usage = {
+      prompt_tokens: Number.isFinite(p) ? p : (st.usage?.prompt_tokens || 0),
+      completion_tokens: Number.isFinite(c) ? c : (st.usage?.completion_tokens || 0),
+    };
+  }
+}
+
+// 结构化问答帧判定（对齐 codearts2api isValidStructuredQA）：question+answer 必须同时为字符串、
+// 长度受控、answer 不似代码；options 若在场须为 2-10 项数组。防止把整段 JSON 当正文。
+const CODE_HINTS = ["import ", "def ", "class ", "func ", "package ", "module ", "struct ", "interface "];
+export function isValidStructuredQA(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const { question, answer, options } = obj;
+  if (typeof question !== "string" || typeof answer !== "string") return false;
+  if (!question.length || question.length > 500) return false;
+  if (!answer.length || answer.length > 100) return false;
+  const low = answer.toLowerCase();
+  if (CODE_HINTS.some((h) => low.includes(h))) return false;
+  if (options !== undefined) {
+    if (!Array.isArray(options) || options.length < 2 || options.length > 10) return false;
+  }
+  return true;
+}
+
+function tryStructuredAnswer(st, payload) {
+  if (st.content || !isValidStructuredQA(payload)) return;
+  st.content = payload.answer;
+}
+
+// 单事件应用到聚合状态（对齐 Go applyEvent 的替换/追加语义）。
+export function applyEvent(st, event, data) {
+  const ev = String(event || "").trim().toLowerCase();
+  const trimmed = String(data || "").trim();
+  if (ev === "" && trimmed === "[DONE]") { if (!st.finish) st.finish = "stop"; st.done = true; return; }
+  let payload = null;
+  if (trimmed && trimmed !== "[DONE]") { try { payload = JSON.parse(trimmed); } catch { payload = null; } }
+
+  const checkError = () => {
+    const code = firstText(payload || {}, ["error_code", "code"]);
+    if (code && code !== "0") {
+      st.error = { code, msg: firstText(payload || {}, ["error_msg", "message", "msg"]) || "request failed" };
+      return true;
+    }
+    return false;
+  };
+  const applyDeltaLike = (textKeys) => {
+    if (checkError()) return true;
+    const { delta, finishReason } = deltaFromChunk(payload);
+    if (finishReason) st.finish = finishReason;
+    // 本帧原生 OpenAI 字段（role/tool_calls/finish）→ 流式层原样转发。
+    // 少转 tool_calls 会让客户端收到 finish_reason=tool_calls 却无工具可执行 → 回合空停（真机复现）。
+    st.forward = {
+      role: delta && typeof delta.role === "string" ? delta.role : "",
+      toolCalls: delta && Array.isArray(delta.tool_calls) && delta.tool_calls.length ? delta.tool_calls : null,
+      finish: finishReason || "",
+    };
+    if (delta) {
+      applyToolCallDeltas(st, delta);
+      if (typeof delta.content === "string" && delta.content) st.content += delta.content;
+      if (typeof delta.reasoning_content === "string" && delta.reasoning_content) st.reason += delta.reasoning_content;
+      return true;
+    }
+    markUsage(st, payload);
+    const t = firstText(payload || {}, textKeys);
+    if (t) {
+      if (trimmed === "[DONE]" || t === "[DONE]" || /^done$/i.test(t)) { st.finish = "stop"; st.done = true; return true; }
+      st.content = t; // 全文快照 → 替换
+      return true;
+    }
+    const out = Array.isArray(payload?.output) ? payload.output : null;
+    if (out && out.length) {
+      const sb = out.filter((x) => x?.type === "output_text" && typeof x.text === "string").map((x) => x.text).join("");
+      if (sb) st.content = sb;
+      return true;
+    }
+    tryStructuredAnswer(st, payload || {});
+    return true;
+  };
+
+  switch (ev) {
+    case "reasoning": case "thinking": case "onreasoning": case "onthinking": {
+      const t = firstText(payload || {}, ["text", "reasoning", "content", "thinking"]);
+      if (t) st.reason += t;
+      return;
+    }
+    case "done": case "end": case "finish": {
+      if (checkError()) return;
+      const f = firstText(payload || {}, ["finish_reason", "finish", "reason"]);
+      st.finish = f || "stop";
+      st.done = true;
+      return;
+    }
+    case "onanswer": case "answer": case "delta": case "message": case "content": case "": case "data": {
+      if (trimmed === "[DONE]") { if (!st.finish) st.finish = "stop"; st.done = true; return; }
+      applyDeltaLike(ev === "" || ev === "data" ? ["text", "content", "delta"] : ["text", "content", "delta", "message"]);
+      return;
+    }
+    default: return; // related_question_answer 等杂帧忽略
+  }
+}
+
+// HTTP 200 内嵌错误 → 状态映射（429/400/502），让网关按状态码走冷却/降级。
+export function embeddedErrorFromData(data) {
+  const trimmed = String(data || "").trim();
+  if (!trimmed || trimmed === "[DONE]") return null;
+  let payload;
+  try { payload = JSON.parse(trimmed); } catch { return null; }
+  const code = typeof payload?.error_code === "string" ? payload.error_code : "";
+  if (!code || code === "0") return null;
+  const message = typeof payload?.error_msg === "string" ? payload.error_msg : "";
+  const combined = `${code} ${message}`.trim();
+  const low = combined.toLowerCase();
+  let status = 502;
+  if (/429|tm\.00001041|tpm|并发会话/.test(low)) status = 429;
+  else if (/002002009|not registered|4004\.200|benefit not found/.test(low)) status = 400;
+  return { status, message: combined.slice(0, 300) };
+}
+
+export class UpstreamEventError extends Error {
+  constructor(message, { status = 502, code = "" } = {}) {
+    super(message);
+    this.name = "UpstreamEventError";
+    this.status = status;
+    this.code = code;
+  }
+}

package/src/providers/codearts/stream.js

@@ -0,0 +1,209 @@
+// 非流式聚合、chat_id 派生。解析纯函数见 ./sse.js。
+import crypto from "node:crypto";
+import { createSseState, scanLine, applyEvent, sortedToolCalls, embeddedErrorFromData, effectiveFinish, isValidStructuredQA, UpstreamEventError } from "./sse.js";
+
+// chat.js 从这里拿错误类（保持单一导入面）。
+export { UpstreamEventError };
+
+// 只读到首个 data: 事件：正常帧原样回放（不破坏流式）；内嵌业务错误转 UpstreamEventError 供上层重试/冷却。
+export async function preflightResponse(resp) {
+  if (!resp?.body) return resp;
+  const reader = resp.body.getReader();
+  const dec = new TextDecoder();
+  const prefix = [];
+  let buf = "";
+  const state = { pendingEvent: "" };
+  const headers = new Headers(resp.headers);
+  headers.delete("content-length");
+  while (true) {
+    const { done, value } = await reader.read();
+    if (value?.length) {
+      const chunk = dec.decode(value, { stream: true });
+      prefix.push(chunk);
+      buf += chunk;
+    }
+    let idx;
+    while ((idx = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, idx);
+      buf = buf.slice(idx + 1);
+      const ev = scanLine(line, state);
+      if (ev) {
+        const err = embeddedErrorFromData(ev.data);
+        if (err) {
+          try { await reader.cancel(); } catch {}
+          throw new UpstreamEventError(err.message, { status: err.status, code: err.message });
+        }
+        return replay(prefix, buf, reader, resp.status, headers);
+      }
+    }
+    if (done) return replay(prefix, buf, null, resp.status, headers);
+  }
+}
+
+function replay(chunks, tail, reader, status, headers) {
+  const enc = new TextEncoder();
+  let primed = false;
+  const stream = new ReadableStream({
+    async pull(controller) {
+      if (!primed) {
+        primed = true;
+        for (const c of chunks) controller.enqueue(enc.encode(c));
+        if (tail) controller.enqueue(enc.encode(tail));
+        if (!reader) { controller.close(); return; }
+      }
+      try {
+        const { done, value } = await reader.read();
+        if (done) controller.close();
+        else controller.enqueue(value);
+      } catch (err) { controller.error(err); }
+    },
+    cancel() { try { reader?.cancel?.(); } catch {} },
+  });
+  return new Response(stream, { status, headers });
+}
+
+// chat_id 必须 32 位 hex（UUID 去连字符），否则上游报「请求参数错误：chat_id」。
+export function newChatId(body, opts) {
+  const raw = String(body?.chat_id || body?.conversation_id || opts?.sessionId || "").trim();
+  const hex = raw.toLowerCase().replace(/[^0-9a-f]/g, "");
+  if (hex.length >= 32) return hex.slice(0, 32);
+  return crypto.createHash("sha256").update(raw || crypto.randomUUID(), "utf8").digest("hex").slice(0, 32);
+}
+
+// 解包：模型把整段 QA JSON（或 ```json/```markdown 包裹）当正文时只取 answer（对齐 codearts2api unwrapQAContent）。
+export function unwrapQAContent(s) {
+  const text = String(s || "");
+  const trimmed = text.trim();
+  if (!trimmed) return text;
+  const direct = parseQaAnswer(trimmed);
+  if (direct !== null) return direct;
+  if (!trimmed.startsWith("```")) return text;
+  const lines = trimmed.split("\n");
+  if (lines.length < 3 || lines[lines.length - 1].trim() !== "```") return text;
+  const inner = lines.slice(1, -1).join("\n");
+  const ans = parseQaAnswer(inner.trim());
+  return ans !== null ? ans : inner;
+}
+
+function parseQaAnswer(s) {
+  try {
+    const obj = JSON.parse(s);
+    return isValidStructuredQA(obj) ? obj.answer : null;
+  } catch { return null; }
+}
+
+const chunkLine = (id, model, delta, finish) => {
+  const choice = { index: 0, delta };
+  if (finish) choice.finish_reason = finish;
+  return `data: ${JSON.stringify({ id, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model, choices: [choice] })}\n\n`;
+};
+
+/** 上游 SSE → OpenAI SSE 流式转换（快照替换/增量混合语义，保证至少一个 finish chunk + [DONE]）。 */
+export function sseToOpenAIResponse(resp, { model, id }) {
+  const dec = new TextDecoder();
+  const enc = new TextEncoder();
+  const reader = resp.body.getReader();
+  let buf = "";
+  const state = createSseState();
+  let finishSent = false;
+  const stream = new ReadableStream({
+    async pull(controller) {
+      const emit = (text) => controller.enqueue(enc.encode(text));
+      const finishChunk = () => { if (!finishSent) { emit(chunkLine(id, model, {}, effectiveFinish(state))); finishSent = true; } };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (value?.length) buf += dec.decode(value, { stream: true });
+          let idx;
+          while ((idx = buf.indexOf("\n")) >= 0) {
+            const line = buf.slice(0, idx);
+            buf = buf.slice(idx + 1);
+            const ev = scanLine(line, state);
+            if (!ev) continue;
+            if (ev.data === "[DONE]") {
+              finishChunk();
+              emit("data: [DONE]\n\n");
+              controller.close();
+              return;
+            }
+            const beforeC = state.content.length, beforeR = state.reason.length;
+            state.forward = null; // 每帧重置：仅本帧 delta 路径产生 forward，防重复转发
+            applyEvent(state, ev.event, ev.data);
+            if (state.error) {
+              emit(`event: error\ndata: ${JSON.stringify({ error: { message: `${state.error.code} ${state.error.msg}`.trim(), type: "upstream_error", code: "CODEARTS_STREAM_ERROR" } })}\n\n`);
+              emit("data: [DONE]\n\n");
+              controller.close();
+              return;
+            }
+            const delta = {};
+            const fwd = state.forward || {};
+            if (fwd.role) delta.role = fwd.role;
+            if (fwd.toolCalls) delta.tool_calls = fwd.toolCalls; // 工具调用分片原样转发（缺它=回合空停）
+            if (state.reason.length > beforeR) delta.reasoning_content = state.reason.slice(beforeR);
+            if (state.content.length > beforeC) delta.content = state.content.slice(beforeC);
+            if (Object.keys(delta).length) emit(chunkLine(id, model, delta, ""));
+            if (fwd.finish) finishChunk(); // 上游 finish_reason 出现即发（含 tool_calls；空 calls 自动降 stop）
+            if (state.done) {
+              finishChunk();
+              emit("data: [DONE]\n\n");
+              controller.close();
+              return;
+            }
+          }
+          if (done) {
+            finishChunk();
+            emit("data: [DONE]\n\n");
+            controller.close();
+            return;
+          }
+        }
+      } catch (err) { controller.error(err); }
+    },
+    cancel() { try { reader.cancel(); } catch {} },
+  });
+  return new Response(stream, { status: resp.status, headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no" } });
+}
+
+/** 上游 SSE → OpenAI chat.completion JSON（非流式聚合；内嵌错误抛 UpstreamEventError）。 */
+export async function aggregateToCompletion(resp, { model, id }) {
+  const dec = new TextDecoder();
+  const reader = resp.body.getReader();
+  let buf = "";
+  const state = createSseState();
+  outer: while (true) {
+    const { done, value } = await reader.read();
+    if (value?.length) buf += dec.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, idx);
+      buf = buf.slice(idx + 1);
+      const ev = scanLine(line, state);
+      if (ev) applyEvent(state, ev.event, ev.data);
+      if (state.error || state.done) break outer;
+    }
+    if (done) break;
+  }
+  try { await reader.cancel(); } catch {}
+  if (state.error) {
+    const status = embeddedErrorFromData(JSON.stringify({ error_code: state.error.code, error_msg: state.error.msg }))?.status || 502;
+    throw new UpstreamEventError(`${state.error.code} ${state.error.msg}`.trim(), { status, code: state.error.code });
+  }
+  const message = { role: "assistant", content: unwrapQAContent(state.content) };
+  if (state.reason) message.reasoning_content = state.reason;
+  const calls = sortedToolCalls(state);
+  if (calls.length) {
+    message.tool_calls = calls;
+    if (!state.content) message.content = null;
+  }
+  const usage = state.usage
+    ? { ...state.usage, total_tokens: (state.usage.prompt_tokens || 0) + (state.usage.completion_tokens || 0) }
+    : { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+  return {
+    id: id || `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [{ index: 0, message, finish_reason: effectiveFinish(state), logprobs: null }],
+    usage,
+  };
+}

package/src/providers/codearts/sts.js

@@ -0,0 +1,124 @@
+// STS /v1/oauth2/tokens：授权码换凭证 + refresh_token 续期（DPoP 必带）。
+// 终态失效（refresh_token 过期/已用/DPoP 或 client_id 不匹配）→ relogin=true，
+// 与网络/5xx 瞬时失败分开，避免好号被误杀或死号无限刷。
+import { STS_HOST, EP_OAUTH_TOKENS, CLIENT_ID } from "./const.js";
+import { signDpopProof } from "./dpop.js";
+import { compatFetch } from "../../compat.js";
+
+function tokenErr(rawText) {
+  try { return JSON.parse(rawText) || {}; } catch { return {}; }
+}
+
+// 对齐 codearts2api：invalid_grant / ExpiredRefreshToken / InvalidDPoPHeader /
+// invalid client id / has been used → 终态，必须重新登录。
+export function isReLoginRejected(status, rawText) {
+  const t = tokenErr(rawText);
+  const code = String(t.error_code || "");
+  const msg = String(t.error_msg || "");
+  const low = (t.error || msg).toLowerCase();
+  return t.error === "invalid_grant"
+    || code.includes("ExpiredRefreshToken")
+    || code.includes("InvalidDPoPHeader")
+    || low.includes("invalid client id")
+    || low.includes("has been used");
+}
+
+/** 归一化 STS 响应（新 credentials / 旧 credential 双形状）。 */
+export function normalizeTokenResponse(json) {
+  const c = json?.credentials || {};
+  const legacy = json?.credential || {};
+  const securityToken = c.security_token || legacy.securitytoken || "";
+  const accessKeyId = c.access_key_id || legacy.access || "";
+  const secretAccessKey = c.secret_access_key || legacy.secret || "";
+  const expiration = c.expiration || legacy.expires_at || "";
+  if (!securityToken || !accessKeyId || !secretAccessKey) return null;
+  const expiresAtMs = expiration ? Date.parse(expiration) : NaN;
+  return {
+    userId: String(json.user_id || ""),
+    userName: String(json.user_name || ""),
+    domainId: String(json.domain_id || ""),
+    refreshToken: String(json.refresh_token || ""),
+    accessKeyId,
+    secretAccessKey,
+    securityToken,
+    expiration,
+    expiresAtMs: Number.isFinite(expiresAtMs) ? expiresAtMs : 0,
+  };
+}
+
+async function postToken({ url, form, dpopJwk, fetchImpl }) {
+  const doFetch = fetchImpl || compatFetch;
+  const proof = signDpopProof(dpopJwk, url);
+  const res = await doFetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded", dpop: proof },
+    body: form.toString(),
+  });
+  const raw = await res.text().catch(() => "");
+  return { res, raw };
+}
+
+/**
+ * 授权码换凭证（登录用）。
+ * @param {object} p { code, verifier, redirectUri, clientId?, dpopJwk, fetchImpl?, stsHost? }
+ */
+export async function exchangeAuthorizationCode({ code, verifier, redirectUri, clientId = CLIENT_ID, dpopJwk, fetchImpl, stsHost } = {}) {
+  const url = (stsHost || STS_HOST) + EP_OAUTH_TOKENS;
+  const form = new URLSearchParams({
+    client_id: clientId,
+    code: String(code || ""),
+    code_verifier: String(verifier || ""),
+    grant_type: "authorization_code",
+    redirect_uri: String(redirectUri || ""),
+  });
+  const { res, raw } = await postToken({ url, form, dpopJwk, fetchImpl });
+  if (res.status >= 400) throw new Error(`codearts sts exchange http ${res.status}: ${String(raw).slice(0, 200)}`);
+  const json = JSON.parse(raw);
+  const account = normalizeTokenResponse(json);
+  if (!account) throw new Error("codearts sts exchange: response missing credentials");
+  account.clientId = clientId;
+  return account;
+}
+
+/**
+ * 用 refresh_token 换新 STS 凭证（refresh_token 单次轮换，响应里取新值写回）。
+ * @param {object} blob 账号凭证 blob（refreshToken/codeVerifier/dpopJwk/clientId）
+ * @param {object} [opts] { fetchImpl, stsHost }
+ * @returns {{account, refreshToken?, relogin?, error?}}
+ */
+export async function refreshStsCredential(blob, { fetchImpl, stsHost } = {}) {
+  const refreshToken = String(blob?.refreshToken || "");
+  const verifier = String(blob?.codeVerifier || "");
+  const jwk = blob?.dpopJwk;
+  const clientId = String(blob?.clientId || CLIENT_ID);
+  if (!refreshToken) return { account: null, relogin: true, error: "missing refresh_token" };
+  if (!verifier) return { account: null, relogin: true, error: "missing code_verifier" };
+  if (!jwk || !jwk.d) return { account: null, relogin: true, error: "missing DPoP private key — re-login required" };
+
+  const url = (stsHost || STS_HOST) + EP_OAUTH_TOKENS;
+  const form = new URLSearchParams({
+    client_id: clientId,
+    code_verifier: verifier,
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+  });
+  let res, raw;
+  try {
+    ({ res, raw } = await postToken({ url, form, dpopJwk: jwk, fetchImpl }));
+  } catch (err) {
+    return { account: null, error: `network: ${err?.message || err}` };
+  }
+  if (res.status >= 400) {
+    if (isReLoginRejected(res.status, raw)) {
+      const t = tokenErr(raw);
+      return { account: null, relogin: true, status: res.status, code: t.error_code, error: `refresh rejected: ${String(raw).slice(0, 200)}` };
+    }
+    return { account: null, status: res.status, error: `sts http ${res.status}: ${String(raw).slice(0, 200)}` };
+  }
+  let json;
+  try { json = JSON.parse(raw); } catch { return { account: null, error: "sts returned non-JSON body" }; }
+  const account = normalizeTokenResponse(json);
+  if (!account) return { account: null, error: "sts response missing credentials" };
+  account.clientId = clientId;
+  return { account, refreshToken: account.refreshToken || null };
+}

package/src/providers/codearts.js

@@ -0,0 +1 @@
+export * from "./codearts/index.js";

package/src/providers/model-id.js

@@ -12,9 +12,9 @@ import os from "node:os";
 
 export const DEFAULT_PROVIDER = "opencode";
 
-const ALIASES = { oc: "opencode", opencode: "opencode" };
+const ALIASES = { oc: "opencode", opencode: "opencode", clinebot: "cline", "cline-bot": "cline" };
 
-// WorkBuddy 别名映射（alias → canonical）：clinebot-z-ai-glm-5.3-flash → clinebot/z-ai/glm-5.3-flash
+// WorkBuddy 别名映射（alias → canonical）：cline-z-ai-glm-5.3-flash → cline/z-ai/glm-5.3-flash
 const _modelAliases = new Map();
 
 function aliasFile() {
@@ -62,7 +62,7 @@ export function getModelAlias(id) {
   return _modelAliases.get(key) || null;
 }
 
-// 反向查询：canonical id → alias（如 clinebot/z-ai/glm-5.3-flash → clinebot-z-ai-glm-5.3-flash）
+// 反向查询：canonical id → alias（如 cline/z-ai/glm-5.3-flash → cline-z-ai-glm-5.3-flash）
 export function getAliasForModel(canonicalId) {
   const c = String(canonicalId || "").trim();
   if (!_aliasLoaded) { try { loadModelAliases(); } catch {} }
@@ -116,7 +116,7 @@ export function toFullId(provider, raw) {
 export function normalizeFullId(id, knownProviders = []) {
   const s = String(id || "").trim();
   if (!s) return "";
-  // 1. 查别名表（clinebot-z-ai-glm-5.3-flash → clinebot/z-ai/glm-5.3-flash）
+  // 1. 查别名表（cline-z-ai-glm-5.3-flash → cline/z-ai/glm-5.3-flash）
   const aliased = getModelAlias(s);
   if (aliased) return aliased;
   // 2. 已含 /，走原有逻辑