mslxdff 0.1.136 → 0.1.140

package/src/providers/traework/chat.js

@@ -0,0 +1,211 @@
+// traework 对话服务：createTransport 直调（仿 workbuddy/chat.js），不走 base.js Bearer runner。
+// 上游恒 stream:true；请求方 stream=true 直接透传转换后的 OpenAI SSE，false 则聚合回 JSON。
+import { joinUrl } from "../base.js";
+import { createTransport } from "../../transport/index.js";
+import { AGENT_HOST, EP_CHAT, FUNCTION } from "./constants.js";
+import { soloHeaders } from "./headers.js";
+import { prepareBody } from "./payload.js";
+import { ErrKind, UpstreamError, SOLOStreamError, classify, isSessionDead } from "./errors.js";
+import { aggregateStreamReader, convertToOpenAIChunks } from "./sse.js";
+import { exchangeRefresh } from "./token.js";
+import { applyTokenRefresh } from "./account-store.js";
+
+const REFRESH_SKEW_S = 24 * 60 * 60;
+
+function needsRefresh(auth) {
+  const exp = Number(auth?.expiresAt) || 0;
+  if (!exp) return false;
+  return Math.floor(Date.now() / 1000) + REFRESH_SKEW_S >= exp;
+}
+
+function stripOwnPrefix(model, providerId) {
+  const s = String(model || "");
+  const i = s.indexOf("/");
+  if (i <= 0) return s;
+  return s.slice(0, i).toLowerCase() === String(providerId || "").toLowerCase() ? s.slice(i + 1) : s;
+}
+
+function errRes(status, msg, reason) {
+  return new Response(JSON.stringify({ error: { message: msg, type: "upstream_error", reason } }), {
+    status, headers: { "Content-Type": "application/json" },
+  });
+}
+
+// 上游 SOLO SSE Response → OpenAI SSE Response（边读边转，透传流）。
+function reshapeSoloStream(upstreamRes, { model, chatId }) {
+  const src = upstreamRes.body;
+  const enc = new TextEncoder();
+  const dec = new TextDecoder();
+  let buf = "";
+  let usage = null;
+  let finishSent = false;
+  const stream = new ReadableStream({
+    async start(ctrl) {
+      const reader = src.getReader();
+      const send = (text) => ctrl.enqueue(enc.encode(text));
+      const sendChunk = (delta, finish) => {
+        const chunk = { id: chatId, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model: model || "", choices: [{ index: 0, delta }] };
+        if (finish) chunk.choices[0].finish_reason = finish;
+        if (usage) { chunk.usage = usage; usage = null; }
+        send(`data: ${JSON.stringify(chunk)}\n\n`);
+      };
+      try {
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (value) buf += dec.decode(value, { stream: !done });
+          const lines = buf.split("\n");
+          buf = lines.pop();
+          let event = "";
+          let data = "";
+          const emit = (ev, dt) => {
+            if (ev === "output") {
+              let raw = null;
+              try { raw = JSON.parse(dt); } catch { return; }
+              const delta = {};
+              if (typeof raw.response === "string" && raw.response) delta.content = raw.response;
+              if (typeof raw.reasoning_content === "string" && raw.reasoning_content) delta.reasoning_content = raw.reasoning_content;
+              if (raw.tool_calls != null) {
+                const arr = Array.isArray(raw.tool_calls) ? raw.tool_calls : [raw.tool_calls];
+                delta.tool_calls = arr.filter(Boolean).map((c) => {
+                  const call = { ...(c || {}) };
+                  if (call.function_call && typeof call.function_call === "object") { call.function = call.function_call; delete call.function_call; }
+                  if (call.function && typeof call.function === "object") { delete call.function.namespace; delete call.function.partial_arguments; }
+                  return call;
+                });
+              }
+              if (Object.keys(delta).length) sendChunk(delta, "");
+            } else if (ev === "token_usage") { try { usage = JSON.parse(dt); } catch {} }
+            else if (ev === "done") { let f = "stop"; try { f = JSON.parse(dt)?.finish_reason || "stop"; } catch {} sendChunk({}, f); send("data: [DONE]\n\n"); finishSent = true; }
+            else if (ev === "error") { let m = dt; try { const j = JSON.parse(dt); m = `solo error code=${j.code} msg=${j.message}`; } catch {} send(`event: error\ndata: ${JSON.stringify(m)}\n\n`); send("data: [DONE]\n\n"); finishSent = true; }
+          };
+          for (const line of lines) {
+            const s = line.replace(/\r$/, "");
+            if (s === "") { if (event) { emit(event, data); event = ""; data = ""; } continue; }
+            if (s.startsWith("event:")) event = s.slice(6).trim();
+            else if (s.startsWith("data:")) data += s.slice(5);
+          }
+          if (done) { if (event) emit(event, data); break; }
+        }
+      } catch (e) { try { ctrl.error(e); } catch {} return; }
+      if (!finishSent) { try { send("data: [DONE]\n\n"); } catch {} }
+      try { ctrl.close(); } catch {}
+    },
+  });
+  return new Response(stream, { status: 200, headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
+}
+
+export function createChatService({
+  id = "traework",
+  baseUrl = AGENT_HOST,
+  chatPath = EP_CHAT,
+  keys = [],
+  authList = [],
+  ring,
+  fetchImpl,
+  dispatcher,
+  connectTimeoutMs = 30_000,
+  file,
+  clock = Date.now,
+  cooldownMs = 30_000,
+} = {}) {
+  const resolvedBase = String(baseUrl || AGENT_HOST).trim().replace(/\/+$/, "");
+  const transport = createTransport({ fetchImpl, dispatcher, keepAlive: !!dispatcher, timeoutMs: connectTimeoutMs, retry: {} });
+
+  function authForKey(key) {
+    const idx = keys.indexOf(key);
+    if (idx >= 0 && authList[idx]) return authList[idx];
+    if (authList.length) return authList[0];
+    return { uid: "", accessToken: key || "", refreshToken: "", expiresAt: 0, domain: "trae.cn", apiHost: "", machineId: "", deviceId: "" };
+  }
+
+  async function maybeRefresh(auth, key) {
+    if (!auth?.uid || !needsRefresh(auth) || !auth.refreshToken) return;
+    try {
+      const r = await exchangeRefresh(fetchImpl, auth.apiHost, auth.refreshToken);
+      await applyTokenRefresh({ uid: auth.uid, oldKey: key, newToken: r.token, refreshToken: r.refreshToken, domain: auth.domain, apiHost: auth.apiHost, machineId: auth.machineId, deviceId: auth.deviceId, enterpriseId: auth.enterpriseId, auth, keys, authList, file });
+      try { ring.replace(key, r.token); } catch {}
+    } catch {}
+  }
+
+  async function postOnce(key, auth, payload) {
+    const cred = { ...auth, accessToken: key };
+    return transport.request({
+      url: joinUrl(resolvedBase, chatPath),
+      method: "POST",
+      headers: soloHeaders(cred, true),
+      body: payload,
+      stream: true,
+      timeoutMs: connectTimeoutMs,
+    });
+  }
+
+  async function runChat(body, activeRing, opts = {}) {
+    const t0 = clock();
+    const wantStream = body?.stream !== false;
+    const rawModel = stripOwnPrefix(body?.model, id);
+    const payload = prepareBody({ ...(body || {}), model: rawModel || body?.model, stream: true, function: FUNCTION });
+    const chatId = `chatcmpl-${Date.now()}`;
+    const tried = new Set();
+    const maxTries = Math.min(3, Math.max(1, activeRing?.size || keys.length || 1));
+    let lastErr = null;
+    for (let attempt = 0; attempt < maxTries; attempt++) {
+      const key = activeRing ? activeRing.next() : keys[attempt];
+      if (!key) break;
+      const auth = authForKey(key);
+      const uid = auth?.uid || "";
+      if (tried.has(uid || key)) continue;
+      tried.add(uid || key);
+      await maybeRefresh(auth, key);
+      const curKey = keys.includes(key) ? key : (keys[keys.indexOf(key)] || key);
+      let res;
+      try { res = await postOnce(curKey, authForKey(curKey), payload); }
+      catch (e) { try { activeRing?.onError(key); } catch {} lastErr = e; continue; }
+      if (res.status >= 400) {
+        const txt = await res.text().catch(() => "");
+        const kind = classify(res.status, txt);
+        if (kind === ErrKind.SESSION_DEAD || isSessionDead(res.status, txt)) {
+          try { activeRing?.onError(key); } catch {}
+          continue; // 禁用语义：换号（同请求最多轮转3号）
+        }
+        if (kind === ErrKind.PLAN_LIMIT || kind === ErrKind.SOFT_RATE || res.status >= 500) {
+          try { activeRing?.onError(key); } catch {}
+          lastErr = new UpstreamError(kind, res.status, txt.slice(0, 200));
+          continue;
+        }
+        if (res.status === 404) { lastErr = new UpstreamError(kind, res.status, txt.slice(0, 200)); continue; }
+        return new Response(txt, { status: res.status, headers: { "Content-Type": "application/json" } });
+      }
+      if (wantStream) {
+        const out = reshapeSoloStream(res, { model: rawModel, chatId });
+        try { out._t = { attempts: [], waitMs: 0, totalMs: Math.round(clock() - t0) }; } catch {}
+        return out;
+      }
+      try {
+        const completion = await aggregateStreamReader(res.body, { model: rawModel, chatId });
+        const out = new Response(JSON.stringify(completion), { status: 200, headers: { "Content-Type": "application/json" } });
+        try { out._t = { attempts: [], waitMs: 0, totalMs: Math.round(clock() - t0) }; } catch {}
+        return out;
+      } catch (e) {
+        // 流内 event:error：4023 上游瞬时错误/1005 plan 权益不足等。错误体原样透传给客户端（冷却按分类）：
+        // 1005 → 长冷却语义；其他 code（如 4023 通用失败）→ 短冷却换号重试，不把号拉黑。
+        if (e instanceof SOLOStreamError) {
+          const kind = e.kind();
+          // 1005 plan 权益不足：冷却该号换号重试；其余 code 上游通用失败：错误透传（不冷却，防雪崩）
+          if (kind === ErrKind.PLAN_LIMIT) {
+            try { activeRing?.onError(key); } catch {}
+            if ((activeRing?.available?.() ?? keys.length) > tried.size) { lastErr = e; continue; }
+          }
+          lastErr = e;
+          return errRes(502, e.message, kind);
+        }
+        if (e?.code !== undefined) { try { activeRing?.onError(key); } catch {} lastErr = e; continue; }
+        throw e;
+      }
+    }
+    if (lastErr instanceof UpstreamError) return errRes(lastErr.status >= 400 ? lastErr.status : 502, lastErr.message, lastErr.kind);
+    if (lastErr) throw lastErr;
+    return errRes(503, `${id}: all traework accounts exhausted or unavailable`, "exhausted");
+  }
+
+  return { runChat, authForKey, convertToOpenAIChunks, aggregateStreamReader };
+}

package/src/providers/traework/checkin.js

@@ -0,0 +1,35 @@
+// traework 签到/积分（照抄 traework2api internal/upstream/client.go Checkin* + UserEntUsage）。
+import { UG_HOST, EP_CHECKIN_STATUS, EP_CHECKIN_CLAIM, EP_ENT_USAGE } from "./constants.js";
+import { ugHeaders } from "./headers.js";
+import { compatFetch, timeoutSignal } from "../../compat.js";
+
+async function postJson(fetchImpl, url, cred, timeoutMs = 15000) {
+  const res = await fetchImpl(url, { method: "POST", headers: ugHeaders(cred), body: "{}", signal: timeoutSignal(timeoutMs) });
+  const txt = await res.text().catch(() => "");
+  let j = null;
+  try { j = JSON.parse(txt); } catch { j = { _raw: txt.slice(0, 200) }; }
+  return { res, json: j };
+}
+
+export async function checkinStatus({ cred, baseUrl = UG_HOST, fetchImpl = compatFetch, timeoutMs = 15000 } = {}) {
+  const { res, json } = await postJson(fetchImpl, `${String(baseUrl).replace(/\/+$/, "")}${EP_CHECKIN_STATUS}`, cred, timeoutMs);
+  if (res.status >= 400) throw Object.assign(new Error(`checkin status http ${res.status}`), { status: res.status });
+  return { checkedIn: Boolean(json?.checked_in), credits: Number(json?.credits) || 0, enable: Boolean(json?.enable) };
+}
+
+export async function checkinClaim({ cred, baseUrl = UG_HOST, fetchImpl = compatFetch, timeoutMs = 15000 } = {}) {
+  const { res } = await postJson(fetchImpl, `${String(baseUrl).replace(/\/+$/, "")}${EP_CHECKIN_CLAIM}`, cred, timeoutMs);
+  if (res.status >= 400) throw Object.assign(new Error(`checkin claim http ${res.status}`), { status: res.status });
+  return { ok: true };
+}
+
+// 积分：ide_user_ent_usage 的 credits_limit 求和。
+export async function entUsage({ cred, baseUrl = UG_HOST, fetchImpl = compatFetch, timeoutMs = 15000 } = {}) {
+  const { res, json } = await postJson(fetchImpl, `${String(baseUrl).replace(/\/+$/, "")}${EP_ENT_USAGE}`, cred, timeoutMs);
+  if (res.status >= 400) throw Object.assign(new Error(`ent usage http ${res.status}`), { status: res.status });
+  const packs = json?.user_entitlement_pack_list;
+  if (!Array.isArray(packs)) return { remain: 0, isCreditsBilling: Boolean(json?.is_credits_billing) };
+  let remain = 0;
+  for (const p of packs) remain += Number(p?.entitlement_base_info?.quota?.credits_limit) || 0;
+  return { remain, isCreditsBilling: Boolean(json?.is_credits_billing) };
+}

package/src/providers/traework/constants.js

@@ -0,0 +1,21 @@
+// traework SOLO 上游技术常量（照抄 traework2api internal/upstream/constants.go，禁止改值）。
+export const AGENT_HOST = "https://trae-api-cn.mchost.guru";
+export const UG_HOST = "https://api.trae.cn";
+export const OAUTH_HOST = "https://api.trae.com.cn";
+export const CONSOLE_HOST = "https://www.trae.cn";
+export const CLIENT_ID = "en1oxy7wnw8j9n";
+export const APP_ID = "6eefa01c-1036-4c7e-9ca5-d891f63bfcd8";
+export const IDE_VERSION = "0.1.43";
+export const IDE_VERSION_CODE = "20260716";
+export const DEVICE_BRAND = "83DG";
+export const OS_VERSION = "Windows 11 Pro";
+export const FUNCTION = "solo_work_lite";
+export const TRAE_UA = "Trae/0.1.43";
+export const DEFAULT_MODEL = "glm-5.2";
+export const EP_CHAT = "/api/agent/v3/llm_utils_chat";
+export const EP_MODELS = "/api/ide/v1/get_detail_param";
+export const EP_EXCHANGE = "/cloudide/api/v3/trae/oauth/ExchangeToken";
+export const EP_USER_INFO = "/cloudide/api/v3/trae/GetUserInfo";
+export const EP_CHECKIN_STATUS = "/trae/api/v2/ug/checkin_credits/status";
+export const EP_CHECKIN_CLAIM = "/trae/api/v2/ug/checkin_credits/claim";
+export const EP_ENT_USAGE = "/trae/api/v2/pay/ide_user_ent_usage";

package/src/providers/traework/errors.js

@@ -0,0 +1,52 @@
+// SOLO 上游错误分类（照抄 traework2api internal/upstream/client.go Classify）。
+export const ErrKind = {
+  NONE: "none",
+  PLAN_LIMIT: "plan_limit",
+  SOFT_RATE: "soft_rate",
+  SESSION_DEAD: "session_dead",
+  NOT_FOUND: "not_found",
+  SERVER: "server",
+  CLIENT: "client",
+};
+
+// 长冷却时长：plan_limit → 12h。
+export const PLAN_COOLDOWN_MS = 12 * 60 * 60 * 1000;
+export const SOFT_COOLDOWN_MS = 60 * 1000;
+
+const SESSION_DEAD_MARKERS = ["login", "token 失效", "token invalid", "session", "unauthorized", "401"];
+
+export class UpstreamError extends Error {
+  constructor(kind, status, msg) {
+    super(`upstream ${kind} (http ${status}): ${msg}`);
+    this.kind = kind;
+    this.status = status;
+  }
+}
+
+// 流内业务错误（event:error）。
+export class SOLOStreamError extends Error {
+  constructor(code, msg) {
+    super(`solo error code=${code} msg=${msg}`);
+    this.code = code;
+    this.msg = msg;
+  }
+  kind() { return this.code === 1005 ? ErrKind.PLAN_LIMIT : ErrKind.CLIENT; }
+}
+
+export function classify(status, body) {
+  const txt = String(body || "");
+  const lower = txt.toLowerCase();
+  if (txt.includes('"code":1005') || (txt.includes("1005") && lower.includes("plan"))) return ErrKind.PLAN_LIMIT;
+  if (status === 401) return ErrKind.SESSION_DEAD;
+  if (status === 429) return ErrKind.SOFT_RATE;
+  if (status === 404) return ErrKind.NOT_FOUND;
+  if (status >= 500) return ErrKind.SERVER;
+  if (status >= 400) return ErrKind.CLIENT;
+  return ErrKind.NONE;
+}
+
+export function isSessionDead(status, body) {
+  if (status === 401) return true;
+  const lower = String(body || "").toLowerCase();
+  return SESSION_DEAD_MARKERS.some((m) => lower.includes(m.toLowerCase()));
+}

package/src/providers/traework/headers.js

@@ -0,0 +1,47 @@
+// SOLO 三类请求头（照抄 traework2api internal/upstream/headers.go）。纯函数，可测。
+import { APP_ID, DEVICE_BRAND, IDE_VERSION, IDE_VERSION_CODE, OS_VERSION, TRAE_UA } from "./constants.js";
+
+// 对话/模型表（Cloud-IDE-JWT 鉴权 + IDE 指纹）。
+export function soloHeaders(cred = {}, stream = true) {
+  const at = cred?.accessToken || "";
+  const h = {
+    "Content-Type": "application/json",
+    Accept: stream ? "text/event-stream" : "application/json",
+    "User-Agent": TRAE_UA,
+    Authorization: `Cloud-IDE-JWT ${at}`,
+    "X-Cloudide-Token": at,
+    "X-Ide-Token": at,
+    "X-App-Id": APP_ID,
+    "X-App-Version": "default",
+    "X-Ide-Version": IDE_VERSION,
+    "X-Ide-Version-Code": IDE_VERSION_CODE,
+    "X-App-Version-Code": IDE_VERSION_CODE,
+    "X-Ide-Version-Type": "stable",
+    "X-Device-Type": "windows",
+    "X-OS-Version": OS_VERSION,
+    "X-Device-Brand": DEVICE_BRAND,
+    "Request-Traffic-Type": "prod",
+  };
+  if (cred?.uid) h["X-Uid"] = cred.uid;
+  if (cred?.machineId) h["X-Machine-Id"] = cred.machineId;
+  if (cred?.deviceId) h["X-Device-Id"] = cred.deviceId;
+  return h;
+}
+
+// 签到/积分（api.trae.cn）。
+export function ugHeaders(cred = {}) {
+  const h = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "User-Agent": TRAE_UA,
+    Authorization: `Cloud-IDE-JWT ${cred?.accessToken || ""}`,
+    "X-User-Region": "CN",
+  };
+  if (cred?.deviceId) h["X-Device-Id"] = cred.deviceId;
+  return h;
+}
+
+// ExchangeToken / GetUserInfo（无签名，仅 UA）。
+export function oauthHeaders() {
+  return { "Content-Type": "application/json", Accept: "application/json", "User-Agent": TRAE_UA };
+}

package/src/providers/traework/index.js

@@ -0,0 +1,122 @@
+// traework provider 门面：薄聚合（读 state keys/auths，无则扫 auth 目录）。
+import { createKeyRing } from "../keyring.js";
+import { loadProviderKeys, loadProviderAuths, loadProviderBaseUrl } from "../../state.js";
+import { compatFetch, getUndici } from "../../compat.js";
+import { envInt, createAgent } from "../base.js";
+import { AGENT_HOST } from "./constants.js";
+import { listAccountDocs } from "./account-store.js";
+import { createChatService } from "./chat.js";
+import { createModelsService } from "./models.js";
+
+const { UndiciFetch } = getUndici();
+
+function resolveBaseUrl(baseUrl) {
+  if (baseUrl) return String(baseUrl).trim().replace(/\/+$/, "");
+  try {
+    const env = loadProviderBaseUrl("traework");
+    if (env) return env;
+  } catch {}
+  return AGENT_HOST;
+}
+
+export function createTraeworkProvider({
+  id = "traework",
+  baseUrl,
+  apiKeys,
+  apiKey,
+  auths,
+  connectTimeoutMs = Number(process.env.MSLXDFF_TRAEWORK_TIMEOUT_MS) || 30_000,
+  cooldownMs = envInt("MSLXDFF_TRAEWORK_COOLDOWN_MS", 30_000),
+  fetchImpl,
+  file,
+  clock = Date.now,
+} = {}) {
+  if (id !== "traework") throw new Error(`traework provider id mismatch: ${id}`);
+  const resolvedBase = resolveBaseUrl(baseUrl);
+  if (!fetchImpl) fetchImpl = UndiciFetch || compatFetch;
+
+  const keysFromState = (() => { try { return loadProviderKeys(id, file ? { file } : {}); } catch { return []; } })();
+  const authsFromState = (() => { try { return loadProviderAuths(id, file ? { file } : {}); } catch { return []; } })();
+  const keys = (() => {
+    const list = [
+      ...(Array.isArray(apiKeys) ? apiKeys : [apiKeys].filter(Boolean)),
+      apiKey,
+      ...(apiKeys === undefined && apiKey === undefined ? keysFromState : []),
+    ].filter((k) => typeof k === "string" && k.trim().length);
+    return [...new Set(list.map((k) => k.trim()))];
+  })();
+  let authList = Array.isArray(auths) && auths.length ? [...auths] : [...authsFromState];
+
+  if (!authList.length && !keys.length) {
+    try {
+      for (const { uid, doc } of listAccountDocs()) {
+        const at = doc?.auth?.accessToken || doc?.accessToken;
+        if (at && !keys.includes(at)) keys.push(at);
+        authList.push({
+          uid,
+          domain: doc?.auth?.domain || "trae.cn",
+          apiHost: doc?.auth?.apiHost || "",
+          machineId: doc?.auth?.machineId || "",
+          deviceId: doc?.auth?.deviceId || "",
+          enterpriseId: doc?.account?.enterpriseId || "",
+          refreshToken: doc?.auth?.refreshToken || "",
+          expiresAt: doc?.auth?.expiresAt || 0,
+          nickname: doc?.account?.nickname || "",
+        });
+      }
+    } catch {}
+  }
+  // auths 行自带 refreshToken 但无 accessToken（login 后 keys 与 auths 平行）；
+  // keys 与 authList 不配对（如 state 被外部改写）→ 从 auth 目录按 uid 补齐 accessToken，防 ring 空
+  if (authList.length && keys.length !== authList.length) {
+    try {
+      const docs = new Map(listAccountDocs().map((d) => [String(d.uid), d.doc]));
+      authList.forEach((a, i) => {
+        const at = docs.get(String(a.uid))?.auth?.accessToken;
+        if (at && !keys.includes(at)) keys[i] = at;
+      });
+    } catch {}
+  }
+
+  const ring = createKeyRing(keys, { cooldownMs, now: clock });
+  let agent = null; let dispatcher = null;
+  try {
+    const a = createAgent({
+      keepAliveTimeout: envInt("MSLXDFF_TRAEWORK_KEEPALIVE_TIMEOUT", 30_000),
+      keepAliveMaxTimeout: envInt("MSLXDFF_TRAEWORK_KEEPALIVE_MAX_TIMEOUT", 60_000),
+      connections: envInt("MSLXDFF_TRAEWORK_KEEPALIVE_CONNECTIONS", 20),
+    });
+    agent = a.agent; dispatcher = a.dispatcher;
+  } catch {}
+
+  function getKey() { return ring.next() || keys[0] || ""; }
+  function getAuth(k) {
+    const idx = keys.indexOf(k);
+    if (idx >= 0 && authList[idx]) return authList[idx];
+    if (authList.length) return authList[0];
+    return { uid: "", accessToken: k || "", refreshToken: "", expiresAt: 0, domain: "trae.cn", apiHost: "", machineId: "", deviceId: "" };
+  }
+
+  const chatSvc = createChatService({ id, baseUrl: resolvedBase, keys, authList, ring, fetchImpl, dispatcher, connectTimeoutMs, file, clock, cooldownMs });
+  const modelsSvc = createModelsService({ id, baseUrl: resolvedBase, fetchImpl, getKey, getAuth, clock });
+
+  async function chat(body, opts = {}) { return chatSvc.runChat(body, ring, opts); }
+
+  async function chatWithKeys(body, keysOverride) {
+    const tmpKeys = [...keysOverride].filter((k) => typeof k === "string" && k.trim().length).map((k) => k.trim());
+    const tmpAuth = authList[0] || getAuth("");
+    const tmpAuthList = tmpKeys.map(() => tmpAuth);
+    const tmpRing = createKeyRing(tmpKeys, { cooldownMs, now: clock });
+    const tmpSvc = createChatService({ id, baseUrl: resolvedBase, keys: tmpKeys, authList: tmpAuthList, ring: tmpRing, fetchImpl, dispatcher: null, connectTimeoutMs, file, clock, cooldownMs });
+    return tmpSvc.runChat(body, tmpRing);
+  }
+
+  async function close() { if (agent && typeof agent.close === "function") { try { await agent.close(); } catch {} } }
+
+  return { id, chat, chatWithKeys, listModels: modelsSvc.listModels, preheat: modelsSvc.preheat, close, agent, keyRing: ring, baseUrl: resolvedBase };
+}
+
+export { mapModel, normalizeModelName, staticModels } from "./models.js";
+export { soloHeaders, ugHeaders, oauthHeaders } from "./headers.js";
+export { prepareBody } from "./payload.js";
+export { classify, ErrKind } from "./errors.js";

package/src/providers/traework/models.js

@@ -0,0 +1,97 @@
+// traework 模型服务：get_detail_param 动态拉取（10min 缓存）+ 静态 32 个回退。
+import { AGENT_HOST, EP_MODELS, FUNCTION, DEFAULT_MODEL } from "./constants.js";
+import { soloHeaders } from "./headers.js";
+import { joinModelId } from "../model-id.js";
+
+const CTX = 131072;
+const CREATED = 1753600000;
+const OWNER = "trae-solo";
+
+export const STATIC_MODEL_IDS = [
+  "Doubao-Seed-2.1-Pro", "seed-code-pro-0430", "Doubao-Seed-2.1-Turbo", "Doubao-Seed-2.0-Code",
+  "DeepSeek-V4-Flash-Official", "browser_use_subagent", "glm-5.2", "glm-5-turbo", "glm-5",
+  "DeepSeek-V4-Pro", "DeepSeek-V4-Flash", "kimi-k3", "kimi-k2.7-code", "kimi-k2.6",
+  "minimax-m3", "qwen-3.7-plus", "sagitta", "aquila", "custom_model_gemini",
+  "custom_model_placeholder", "custom_model_1M_text", "custom_model_1M", "custom_model_kimi",
+  "custom_model_claude", "custom_model_gpt-5", "custom_model_no-fc", "custom_model_deepseek_chat",
+  "custom_model_deepseek_reasoner", "custom_model_deepseek_v4", "explore_sub_agent_v13",
+  "explore_sub_agent_v2", "summary",
+];
+
+export function staticModels(id = "traework") {
+  return STATIC_MODEL_IDS.map((m) => ({ id: joinModelId(id, m), object: "model", created: CREATED, owned_by: OWNER, context_length: CTX }));
+}
+
+export function normalizeModelName(s) {
+  return String(s || "").split("_").map((p) => (p ? p[0].toUpperCase() + p.slice(1).toLowerCase() : p)).join("-");
+}
+
+// 模型映射：空/auto→默认；去 __ 后缀；下划线转横线宽松匹配；未知→400。
+export function mapModel(model, knownIds, def = DEFAULT_MODEL) {
+  const m = String(model || "").trim();
+  if (!m || m === "auto") return { configName: def };
+  const base = m.includes("__") ? m.slice(0, m.indexOf("__")) : m;
+  const known = new Set(knownIds || []);
+  if (known.has(base)) return { configName: base };
+  const norm = normalizeModelName(base);
+  if (known.has(norm)) return { configName: norm };
+  // 大小写不敏感兜底
+  const low = new Map([...known].map((k) => [String(k).toLowerCase(), k]));
+  if (low.has(base.toLowerCase())) return { configName: low.get(base.toLowerCase()) };
+  if (low.has(norm.toLowerCase())) return { configName: low.get(norm.toLowerCase()) };
+  const err = new Error(`unknown model ${JSON.stringify(model)}`);
+  err.status = 400;
+  throw err;
+}
+
+export function createModelsService({
+  id = "traework",
+  baseUrl = AGENT_HOST,
+  fetchImpl,
+  getKey,
+  getAuth,
+  clock = Date.now,
+} = {}) {
+  const CACHE_TTL_MS = 10 * 60 * 1000;
+  let cache = null;
+  let fetchedAt = 0;
+  const resolvedBase = String(baseUrl || AGENT_HOST).trim().replace(/\/+$/, "");
+
+  async function fetchDynamic() {
+    const key = getKey ? getKey() : "";
+    const auth = getAuth ? getAuth(key) : null;
+    const cred = { ...(auth || {}), accessToken: key || auth?.accessToken || "" };
+    const res = await fetchImpl(`${resolvedBase}${EP_MODELS}`, {
+      method: "POST",
+      headers: soloHeaders(cred, false),
+      body: JSON.stringify({ function: FUNCTION, config_names: null, need_prompt: false, current_config_info: null, poly_prompt: true, mode_type: null, agent_type: null }),
+    });
+    if (!res.ok) throw new Error(`models http ${res.status}`);
+    const j = await res.json().catch(() => ({}));
+    const list = j?.config_info_list;
+    if (!Array.isArray(list) || !list.length) throw new Error("models api returned empty list");
+    return list.filter((c) => c?.config_name).map((c) => ({ id: c.config_name, name: c?.display_config?.display_name || c.config_name }));
+  }
+
+  async function listModels() {
+    const now = clock();
+    if (cache && now - fetchedAt < CACHE_TTL_MS) return cache;
+    try {
+      const dyn = await fetchDynamic();
+      cache = dyn.map((m) => ({ id: joinModelId(id, m.id), object: "model", created: CREATED, owned_by: OWNER, context_length: CTX, name: m.name }));
+      fetchedAt = now;
+      return cache;
+    } catch {
+      cache = staticModels(id);
+      fetchedAt = now;
+      return cache;
+    }
+  }
+
+  async function preheat() {
+    try { await listModels(); return { ok: true }; }
+    catch (err) { return { ok: false, error: String(err?.message || err).slice(0, 120) }; }
+  }
+
+  return { listModels, preheat, mapModel: (m, known) => mapModel(m, known), staticModels: () => staticModels(id), normalizeModelName };
+}