mslxdff 0.1.138 → 0.1.141

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/qoder/account-store.js

@@ -0,0 +1,107 @@
+// qoder 账号落盘单一源：auths/qoder-<uid>.json（0600 tmp+rename）+ state.json providerConfigs.qoder keys/auths 按 uid 去重。
+// 凭证形状对齐 qoder2api：secret = {"device_token":"dt-xxx","refresh_token":"drt-xxx"}，region 进 auth 行。
+import { writeFileSync, mkdirSync, existsSync, renameSync, unlinkSync, readdirSync, readFileSync, chmodSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { isTestEnv, defaultStateFile } from "../../state/store.js";
+import { normalizeRegion } from "./constants.js";
+
+export function authDirFor({ explicit = "", testEnv = false, stateFile } = {}) {
+  if (explicit) return explicit;
+  if (testEnv) return join(tmpdir(), "mslxdff-test-auths");
+  return join(dirname(stateFile), "auths");
+}
+
+export function resolveAuthDir() {
+  return authDirFor({
+    explicit: process.env.QODER_AUTH_DIR || "",
+    testEnv: isTestEnv(),
+    stateFile: defaultStateFile(),
+  });
+}
+
+export function resolveAuthDirs() {
+  const primary = resolveAuthDir();
+  const cwdDir = join(process.cwd(), "auths");
+  return primary === cwdDir ? [primary] : [primary, cwdDir];
+}
+
+export function listAccountDocs({ dirs } = {}) {
+  const out = [];
+  const seen = new Set();
+  for (const dir of dirs || resolveAuthDirs()) {
+    let files = [];
+    try {
+      if (!existsSync(dir)) continue;
+      files = readdirSync(dir).filter((f) => f.startsWith("qoder-") && f.endsWith(".json"));
+    } catch { continue; }
+    for (const f of files) {
+      try {
+        const doc = JSON.parse(readFileSync(join(dir, f), "utf8"));
+        const uid = doc?.account?.uid;
+        if (!uid || !doc?.auth?.deviceToken) continue;
+        if (seen.has(String(uid))) continue;
+        seen.add(String(uid));
+        out.push({ uid: String(uid), file: join(dir, f), dir, doc });
+      } catch {}
+    }
+  }
+  return out;
+}
+
+function writeAccountFile({ uid, deviceToken, refreshToken = "", region = "global", name = "", email = "", userType = "personal_standard", organizationId = "", organizationName = "" }) {
+  const authDir = resolveAuthDir();
+  mkdirSync(authDir, { recursive: true });
+  const doc = {
+    account: { uid, name, email, userType, organizationId, organizationName },
+    auth: { deviceToken, refreshToken, region: normalizeRegion(region) },
+  };
+  const fp = join(authDir, `qoder-${uid}.json`);
+  const tmp = `${fp}.tmp`;
+  writeFileSync(tmp, JSON.stringify(doc, null, 2), { mode: 0o600 });
+  try {
+    if (existsSync(fp)) { try { chmodSync(fp, 0o600); } catch {} unlinkSync(fp); }
+    renameSync(tmp, fp);
+  } catch {
+    writeFileSync(fp, JSON.stringify(doc, null, 2), { mode: 0o600 });
+    try { unlinkSync(tmp); } catch {}
+  }
+  try { chmodSync(fp, 0o600); } catch {}
+  return fp;
+}
+
+// state 落盘：key 存 JSON blob（对齐 qoder2api ParseOAuthSecret 形状），auths 存 uid 索引行。
+async function persistAccounts(accounts, file) {
+  const { loadProviderConfigs, saveProviderConfig } = await import("../../state.js");
+  const cfg = (loadProviderConfigs(file ? { file } : {})?.qoder) || {};
+  const keys = [...(Array.isArray(cfg.keys) ? cfg.keys : [])];
+  const auths = [...(Array.isArray(cfg.auths) ? cfg.auths : [])];
+  let updated = 0;
+  for (const acc of accounts) {
+    if (!acc?.uid || !acc?.deviceToken) continue;
+    const blob = JSON.stringify({ device_token: acc.deviceToken, refresh_token: acc.refreshToken || "" });
+    const row = { uid: acc.uid, domain: acc.domain || "qoder.com", region: normalizeRegion(acc.region), name: acc.name || "", refreshToken: acc.refreshToken || "" };
+    const idx = auths.findIndex((a) => a?.uid === acc.uid);
+    if (idx >= 0) { keys[idx] = blob; auths[idx] = row; updated += 1; }
+    else { keys.push(blob); auths.push(row); }
+  }
+  saveProviderConfig("qoder", { baseUrl: cfg.baseUrl || "", keys, auths }, file ? { file } : {});
+  return { keys, auths, updated };
+}
+
+export async function saveQoderAccount({ uid, deviceToken, refreshToken = "", region = "global", name = "", email = "", userType = "personal_standard", organizationId = "", organizationName = "", domain = "qoder.com", file } = {}) {
+  if (!uid || !deviceToken) throw new Error("saveQoderAccount: 缺少 uid/deviceToken");
+  const fp = writeAccountFile({ uid, deviceToken, refreshToken, region, name, email, userType, organizationId, organizationName });
+  const st = await persistAccounts([{ uid, deviceToken, refreshToken, region, name, domain }], file);
+  return { file: fp, accounts: st.keys.length, updated: st.updated > 0 };
+}
+
+// 重建 provider 的行级 auth：由 keys[i] blob + auths[i] 还原 deviceToken。
+export function accountFromBlob(blob) {
+  try {
+    const j = JSON.parse(String(blob || "{}"));
+    return { deviceToken: String(j.device_token || ""), refreshToken: String(j.refresh_token || "") };
+  } catch {
+    return null;
+  }
+}

package/src/providers/qoder/aggregate.js

@@ -0,0 +1,51 @@
+// qoder 非流式聚合：上游 SSE 全读完 → chat.completion JSON。
+// 真流式走 stream.js；本模块只服务 stream:false（行为与旧 callQoder 聚合同）。
+import { extractDelta } from "./sse.js";
+
+export async function aggregateQoderStream(upstreamRes) {
+  const reader = upstreamRes.body.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  let usage = null;
+  let content = "";
+  let reasoning = "";
+  const toolCalls = [];
+  let sawContent = false;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (value) buf += dec.decode(value, { stream: !done });
+    const lines = buf.split("\n");
+    buf = lines.pop();
+    for (const raw of lines) {
+      const line = raw.replace(/\r$/, "");
+      if (!line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (!payload || payload === "[DONE]") continue;
+      const d = extractDelta(payload);
+      if (d.err) throw d.err;
+      if (d.usageIn > 0 || d.usageOut > 0) {
+        usage = { prompt_tokens: d.usageIn, completion_tokens: d.usageOut, total_tokens: d.usageIn + d.usageOut };
+      }
+      if (d.content) { content += d.content; sawContent = true; }
+      if (d.reasoning) { reasoning += d.reasoning; sawContent = true; }
+      if (d.toolCalls) { toolCalls.push(...d.toolCalls); sawContent = true; }
+    }
+    if (done) break;
+  }
+  if (!sawContent && !usage) throw { kind: "upstream", status: 502, detail: "empty upstream stream" };
+  return { usage, content, reasoning, toolCalls };
+}
+
+export function toCompletionJson({ model, chatId, content, reasoning, toolCalls, usage }) {
+  const msg = { role: "assistant", content: content || (toolCalls.length ? null : "") };
+  if (reasoning) msg.reasoning_content = reasoning;
+  if (toolCalls.length) msg.tool_calls = toolCalls;
+  return {
+    id: chatId,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [{ index: 0, message: msg, finish_reason: toolCalls.length ? "tool_calls" : "stop" }],
+    usage: usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+  };
+}