@wengine-ai/ccr-provider-qoder 0.1.0 → 0.2.0

package/dist/plugin.js

@@ -0,0 +1,2534 @@
+// src/auth-service.ts
+import { constants as constants2 } from "node:fs";
+import { open, mkdir, rename, rm, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+
+// src/vendor/engine.mjs
+import { createCipheriv, createHash, publicEncrypt, randomUUID, constants } from "node:crypto";
+var SITES = Object.freeze({
+  qoder: Object.freeze({
+    id: "qoder",
+    name: "Qoder",
+    web: "https://qoder.com",
+    openapi: "https://openapi.qoder.sh",
+    api: "https://api3.qoder.sh"
+  }),
+  "qoder-cn": Object.freeze({
+    id: "qoder-cn",
+    name: "Qoder CN",
+    web: "https://qoder.cn",
+    openapi: "https://openapi.qoder.com.cn",
+    api: "https://gateway.qoder.com.cn"
+  })
+});
+function createQoderEngine(options) {
+  if (typeof options?.fetch !== "function") throw new TypeError("Qoder requires an injected fetch");
+  const site = SITES[options.site ?? "qoder"];
+  if (!site) throw new TypeError(`Qoder: unknown site "${options.site}"`);
+  const now = options.now ?? (() => Date.now());
+  const combine = (...signals) => AbortSignal.any([options.signal, ...signals].filter(Boolean));
+  const checkAbort = (signal) => {
+    const aborted = [signal, options.signal].find((s) => s?.aborted);
+    if (aborted) throw aborted.reason ?? new DOMException("aborted", "AbortError");
+  };
+  const fetch2 = async (input, init = {}) => {
+    const signal = combine(init.signal);
+    checkAbort(signal);
+    try {
+      const res = await options.fetch(input, { ...init, signal, redirect: "error" });
+      checkAbort(signal);
+      return res;
+    } catch (e) {
+      checkAbort(signal);
+      throw e;
+    }
+  };
+  const STATUS_CODES = { 400: "Bad Request", 401: "Unauthorized", 402: "Payment Required", 403: "Forbidden", 404: "Not Found", 405: "Method Not Allowed", 406: "Not Acceptable", 407: "Proxy Authentication Required", 408: "Request Timeout", 409: "Conflict", 410: "Gone", 411: "Length Required", 412: "Precondition Failed", 413: "Payload Too Large", 414: "URI Too Long", 415: "Unsupported Media Type", 416: "Range Not Satisfiable", 417: "Expectation Failed", 418: "I'm a Teapot", 421: "Misdirected Request", 422: "Unprocessable Entity", 423: "Locked", 424: "Failed Dependency", 425: "Too Early", 426: "Upgrade Required", 428: "Precondition Required", 429: "Too Many Requests", 431: "Request Header Fields Too Large", 451: "Unavailable For Legal Reasons", 500: "Internal Server Error", 501: "Not Implemented", 502: "Bad Gateway", 503: "Service Unavailable", 504: "Gateway Timeout", 505: "HTTP Version Not Supported", 506: "Variant Also Negotiates", 507: "Insufficient Storage", 508: "Loop Detected", 509: "Bandwidth Limit Exceeded", 510: "Not Extended", 511: "Network Authentication Required" };
+  const CHAT_PATH2 = "/algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1";
+  const MODELS_PATH = "/algo/api/v2/model/list?Encode=1";
+  const COSY_VERSION = "1.1.69";
+  const REFRESH_LEAD = 5 * 60 * 1e3;
+  const KEEP_SPENT_MS = 60 * 60 * 1e3;
+  const DAY = 24 * 60 * 60 * 1e3;
+  const RSA_KEY = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;
+  const QODER_SYS = "You are a Qoder agent. Use the instructions below and the tools available to you to assist the user.";
+  const hexID = () => randomUUID().replaceAll("-", "");
+  function machineOS() {
+    const arch = { x64: "x86_64", ia32: "x86", arm64: "aarch64" }[process.arch] ?? process.arch;
+    return arch + "_" + process.platform;
+  }
+  function userBlob(u, rsaKey = RSA_KEY) {
+    const raw = JSON.stringify({ uid: u.uid, aid: "", name: u.name ?? "", email: u.email ?? "", security_oauth_token: u.access });
+    const key = Buffer.from(hexID().slice(0, 16));
+    const c = createCipheriv("aes-128-cbc", key, key);
+    const info = Buffer.concat([c.update(raw, "utf8"), c.final()]).toString("base64");
+    const wrapped = publicEncrypt({ key: rsaKey, padding: constants.RSA_PKCS1_PADDING }, key).toString("base64");
+    return { info, key: wrapped };
+  }
+  function cosyHeaders(url, u, body, site2, ts = Math.floor(now() / 1e3)) {
+    if (!u?.machineId) throw new Error(`${site2?.name ?? "Qoder"}: the account has no machine id; sign in again`);
+    const cosyVersion = site2?.cosyVersion ?? COSY_VERSION;
+    const blob = userBlob(u, site2?.rsaKey);
+    const payload = Buffer.from(
+      JSON.stringify({ version: "v1", requestId: hexID(), info: blob.info, cosyVersion, ideVersion: "" })
+    ).toString("base64");
+    let path = new URL(url).pathname;
+    if (path.startsWith("/algo")) path = path.slice(5);
+    const sig = createHash("md5").update(`${payload}
+${blob.key}
+${ts}
+${body}
+${path}`).digest("hex");
+    const m = u.machineId;
+    return {
+      Accept: "application/json",
+      "Accept-Encoding": "identity",
+      "Content-Type": "application/json",
+      Authorization: `Bearer COSY.${payload}.${sig}`,
+      "Cosy-Business-Product": site2?.businessProduct ?? "app",
+      "Cosy-Business-Type": "agent",
+      "Cosy-ClientIp": m,
+      "Cosy-ClientType": site2?.clientType ?? "10",
+      "Cosy-Data-Policy": "disagree",
+      "Cosy-Date": String(ts),
+      "Cosy-Key": blob.key,
+      "Cosy-MachineId": m,
+      "Cosy-MachineToken": m,
+      "Cosy-MachineType": "5",
+      "Cosy-MachineOS": machineOS(),
+      "Cosy-Scene": site2?.modelScene ?? "app",
+      "Cosy-User": u.uid,
+      "Cosy-Version": cosyVersion,
+      "Login-Version": "v2"
+    };
+  }
+  const ALPHABET = "_doRTgHZBKcGVjlvpC,@aFSx#DPuNJme&i*MzLOEn)sUrthbf%Y^w.(kIQyXqWA!";
+  function segmentEncode(bytes) {
+    let s = "";
+    let acc = 0;
+    let nb = 0;
+    for (const b of bytes) {
+      acc = (acc << 8 | b) & 16777215;
+      nb += 8;
+      while (nb >= 6) {
+        nb -= 6;
+        s += ALPHABET[acc >> nb & 63];
+      }
+    }
+    if (nb > 0) s += ALPHABET[acc << 6 - nb & 63];
+    while (s.length % 4) s += "$";
+    return s;
+  }
+  function swapThirds(s) {
+    const t = Math.floor(s.length / 3);
+    return t ? s.slice(s.length - t) + s.slice(t, s.length - t) + s.slice(0, t) : s;
+  }
+  const encodeBody = (text) => swapThirds(segmentEncode(Buffer.from(text, "utf8")));
+  function decodeBody(wire) {
+    const s = swapThirds(wire);
+    const out = [];
+    for (let g = 0; g + 4 <= s.length; g += 4) {
+      const vals = [...s.slice(g, g + 4)].filter((c) => c !== "$").map((c) => ALPHABET.indexOf(c));
+      let x = 0;
+      for (const v of vals) x = x * 64 + v;
+      const n = Math.floor(6 * vals.length / 8);
+      for (let k = 0; k < n; k++) out.push(Math.floor(x / 2 ** (6 * vals.length - 8 * (k + 1))) & 255);
+    }
+    return Buffer.from(out).toString("utf8");
+  }
+  async function openapi(site2, path, { method = "GET", token, body, query, signal } = {}) {
+    const url = new URL(site2.openapi + path);
+    for (const [k, v] of Object.entries(query ?? {})) url.searchParams.set(k, v);
+    const headers = { Accept: "application/json" };
+    if (body) headers["Content-Type"] = "application/json";
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const res = await fetch2(url, { method, headers, body: body ? JSON.stringify(body) : void 0, signal: combine(signal, AbortSignal.timeout(2e4)) });
+    const text = await res.text();
+    checkAbort(signal);
+    let json = null;
+    try {
+      json = JSON.parse(text);
+    } catch {
+    }
+    return { status: res.status, json, text };
+  }
+  const expiresAt = (jt) => now() + (jt.expires_in > 0 ? jt.expires_in : DAY);
+  function exchangeExpiry(jt) {
+    for (const k of ["expire_time", "expires_at"]) {
+      const at = Date.parse(String(jt?.[k] ?? "").trim());
+      if (!isNaN(at)) return at;
+    }
+    if (jt?.expires_in > 0) return now() + jt.expires_in;
+    return now() + DAY;
+  }
+  function exchangeToken(jt) {
+    return String(jt?.token ?? jt?.device_token ?? jt?.access_token ?? "").trim();
+  }
+  async function patSignIn(site2, pat, signal) {
+    const machineId = randomUUID();
+    const r = await openapi(site2, "/api/v1/jobToken/exchange", { method: "POST", body: { personal_token: pat }, signal });
+    if (r.status === 400 || r.status === 401 || r.status === 403)
+      throw Object.assign(new Error(`${site2.name} refused the PAT \u2014 check it is still valid`), { status: r.status });
+    if (r.status !== 200) throw new Error(`${site2.name} PAT exchange: status ${r.status}`);
+    const token = exchangeToken(r.json);
+    if (!token) throw new Error(`${site2.name} PAT exchange: empty token in response`);
+    const refresh2 = String(r.json?.refresh_token ?? r.json?.refreshToken ?? "").trim();
+    const chat2 = { access: token, refresh: refresh2, expires: exchangeExpiry(r.json) };
+    let email = "";
+    let name = "";
+    let uid = "";
+    try {
+      const ui = await openapi(site2, "/api/v1/userinfo", { token, signal });
+      if (ui.status >= 200 && ui.status < 300) {
+        ;
+        [email, name] = [ui.json?.email ?? "", ui.json?.name ?? ""];
+        uid = String(ui.json?.id ?? ui.json?.user_id ?? ui.json?.uid ?? "");
+      }
+    } catch (e) {
+      checkAbort(signal);
+    }
+    if (!uid) throw new Error(`${site2.name} PAT sign-in: could not determine user id`);
+    return {
+      ...chat2,
+      // The same name its browser sign-in takes: magpie's plugin host replaces
+      // an account on a new sign-in when both the accountId and the uid match,
+      // so a renewed PAT sign-in must keep naming the same account. A suffix
+      // here would add a second row beside the lapsed one instead.
+      accountId: email || uid,
+      uid,
+      email,
+      name: name || "",
+      machineId,
+      pat
+    };
+  }
+  class SignInGone extends Error {
+    constructor(message, expired = false) {
+      super(message);
+      this.expired = expired;
+    }
+  }
+  async function refreshJob(site2, refresh2, user, signal) {
+    if (!String(refresh2 ?? "").trim()) throw new SignInGone(`${site2.name}: the sign-in lapsed; sign in again`);
+    const r = await openapi(site2, "/api/v1/jobToken/refresh", { method: "POST", body: { refresh_token: refresh2 }, signal });
+    if (r.status === 401 || r.status === 403)
+      throw new SignInGone(`${user}'s ${site2.name} sign-in has expired \u2014 sign in again (qoder job token refresh: status ${r.status})`, true);
+    if (r.status !== 200) throw new Error(`qoder job token refresh: status ${r.status}`);
+    if (!String(r.json?.token ?? "").trim() || !String(r.json?.refresh_token ?? "").trim())
+      throw new Error("qoder job token refresh: incomplete token pair");
+    return r.json;
+  }
+  const EFFORT_ORDER = ["minimal", "low", "medium", "high", "xhigh", "max"];
+  function freeOf(raw) {
+    const price = raw.price_factor ?? raw.priceFactor;
+    if (typeof price === "number" && Number.isFinite(price)) {
+      if (price !== 0) return false;
+      const p = raw.promotion ?? raw.prommotion;
+      const before = p?.before_promotion_price_factor ?? p?.beforePromotionPriceFactor;
+      return !(p?.active === true && typeof before === "number" && before > 0);
+    }
+    return (raw.is_free ?? raw.isFree) === true;
+  }
+  function rateOf(raw) {
+    const price = raw.price_factor ?? raw.priceFactor;
+    if (typeof price !== "number" || !Number.isFinite(price)) return { rate: 0, rateWas: 0 };
+    const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+    const p = raw.promotion ?? raw.prommotion;
+    const before = p?.before_promotion_price_factor ?? p?.beforePromotionPriceFactor;
+    const discount = num(p?.discount_factor) || num(p?.discountFactor);
+    const discounted = p?.active === true && typeof before === "number" && before > 0;
+    let rate = Math.max(price, 0);
+    let rateWas = Math.max(num(raw.original_price_factor), num(raw.originalPriceFactor));
+    if (discounted) {
+      rateWas = before;
+      if (rate === 0) rate = before * discount;
+    }
+    if (rateWas <= rate) rateWas = 0;
+    return { rate, rateWas };
+  }
+  function windowsOf(raw) {
+    const n = (v) => Number.isInteger(v) && v > 0 ? v : 0;
+    const windows = [];
+    let def = 0;
+    const cc = raw?.context_config ?? raw?.contextConfig;
+    if (cc && typeof cc === "object" && !Array.isArray(cc)) {
+      for (const e of Object.values(cc)) {
+        const t = n(e?.token_count);
+        if (!t) continue;
+        if (!windows.includes(t)) windows.push(t);
+        if (e.is_default === true || e.is_default === 1 || e.is_default === "1") def = t;
+      }
+    }
+    if (!windows.length) {
+      const list = raw?.available_context_windows ?? raw?.availableContextWindows;
+      for (const v of Array.isArray(list) ? list : []) if (n(v) && !windows.includes(v)) windows.push(v);
+      def = n(raw?.default_context_window ?? raw?.defaultContextWindow);
+      if (!windows.includes(def)) def = 0;
+    }
+    windows.sort((a, b) => a - b);
+    return { windows, defaultWindow: def };
+  }
+  function modelInfo(raw) {
+    const { windows, defaultWindow } = windowsOf(raw);
+    const m = {
+      key: raw.key,
+      source: raw.source ?? "",
+      name: raw.display_name || raw.key,
+      images: !!raw.is_vl,
+      context: windows.length ? windows[windows.length - 1] : raw.max_input_tokens || 0,
+      windows,
+      defaultWindow,
+      thinks: !!raw.is_reasoning,
+      alwaysThinks: false,
+      efforts: Array.isArray(raw.reasoning_efforts) ? [...raw.reasoning_efforts] : [],
+      defaultEffort: "",
+      free: freeOf(raw),
+      ...rateOf(raw),
+      config: raw
+    };
+    const tc = raw.thinking_config;
+    if (tc && typeof tc === "object") {
+      m.thinks = tc.enabled != null;
+      m.alwaysThinks = m.thinks && tc.disabled == null;
+      m.efforts = [];
+      if (m.thinks) {
+        for (const [name, e] of Object.entries(tc.enabled.efforts ?? {})) {
+          m.efforts.push(name);
+          if (e?.is_default) m.defaultEffort = name;
+        }
+        const rank = (s) => EFFORT_ORDER.includes(s) ? EFFORT_ORDER.indexOf(s) : EFFORT_ORDER.length;
+        m.efforts.sort((a, b) => rank(a) - rank(b) || (a < b ? -1 : a > b ? 1 : 0));
+      }
+    }
+    return m;
+  }
+  function sceneModels(listing) {
+    const app = Array.isArray(listing?.app) ? listing.app : [];
+    const chat2 = Array.isArray(listing?.chat) ? listing.chat : [];
+    const out = [...app];
+    let after = -1;
+    for (const m of chat2) {
+      const i = out.findIndex((x) => x?.key === m?.key);
+      if (i >= 0) {
+        after = i;
+        continue;
+      }
+      out.splice(++after, 0, m);
+    }
+    return out;
+  }
+  function modelInfos(listing, site2) {
+    if (site2?.modelScene) {
+      return (Array.isArray(listing?.[site2.modelScene]) ? listing[site2.modelScene] : []).filter((m) => (site2.listAllModels || m?.enable) && !["", "auto", "default"].includes(String(m.key ?? "").trim())).map(modelInfo);
+    }
+    return sceneModels(listing).filter((m) => m?.enable && !["", "auto", "default"].includes(String(m.key ?? "").trim())).map(modelInfo);
+  }
+  async function fetchListing(site2, cred, signal) {
+    const url = site2.api + MODELS_PATH;
+    const res = await fetch2(url, { headers: cosyHeaders(url, cred, "", site2), signal: combine(signal, AbortSignal.timeout(15e3)) });
+    const text = await res.text();
+    checkAbort(signal);
+    if (!res.ok) {
+      throw new Error(`${site2.name} models: HTTP ${res.status}: ${text.trim().slice(0, 512)}`);
+    }
+    return JSON.parse(text);
+  }
+  const EFFORT_RANK = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+  function fitEffort(want, levels) {
+    if (want === "ultra" && !levels.includes(want)) want = "max";
+    if (!levels.length || levels.includes(want)) return want;
+    const at = EFFORT_RANK.indexOf(want);
+    if (at < 0) return want;
+    let best = want;
+    let dist = EFFORT_RANK.length;
+    for (const l of levels) {
+      const i = EFFORT_RANK.indexOf(l);
+      if (i < 0 || l === "none") continue;
+      const d = Math.abs(i - at);
+      if (d < dist || d === dist && i > at) [best, dist] = [l, d];
+    }
+    return best;
+  }
+  function effortFor(asked, m) {
+    let want = String(asked ?? "").toLowerCase();
+    if (!EFFORT_RANK.includes(want)) want = "";
+    if (!m.thinks || want === "none" && !m.alwaysThinks) return [false, ""];
+    if (!m.efforts.length) return [true, ""];
+    if (want === "") return [true, m.defaultEffort];
+    if (want === "none") return [true, m.efforts[0]];
+    return [true, fitEffort(want, m.efforts)];
+  }
+  function imageBlock(p) {
+    const url = typeof p.image_url === "string" ? p.image_url : p.image_url?.url;
+    return url ? { type: "image_url", image_url: { url } } : null;
+  }
+  function blocksOf(content) {
+    if (typeof content === "string") return content ? [{ type: "text", text: content }] : [];
+    const out = [];
+    for (const p of content ?? []) {
+      if (p?.type === "text" && p.text != null) out.push({ type: "text", text: p.text });
+      else if (p?.type === "image_url") {
+        const b = imageBlock(p);
+        if (b) out.push(b);
+      }
+    }
+    return out;
+  }
+  const textOf = (c) => typeof c === "string" ? c : blocksOf(c).filter((b) => b.type === "text").map((b) => b.text).join("");
+  function callID(at, k, c) {
+    const args = c.function?.arguments;
+    const said = typeof args === "string" ? args : JSON.stringify(args ?? {});
+    return "call_" + createHash("sha256").update(`${at}\0${k}\0${c.function?.name ?? ""}\0${said}`).digest("hex").slice(0, 32);
+  }
+  function qoderMessages(msgs) {
+    const out = [];
+    const names = {};
+    let seen = [];
+    const showSeen = () => {
+      if (seen.length) out.push({ role: "user", content: seen });
+      seen = [];
+    };
+    let turn = null;
+    const asText = (txt, ims) => {
+      const said = txt.trim();
+      if (!said && !ims.length) return;
+      if (seen.length) seen.push({ type: "text", text: "\n\n" });
+      if (said) seen.push({ type: "text", text: said });
+      seen.push(...ims);
+    };
+    for (const [i, m] of msgs.entries()) {
+      if (m.role === "system" || m.role === "developer") continue;
+      if (m.role === "user") turn = null;
+      if (m.role !== "user" && m.role !== "tool") showSeen();
+      if (m.role === "tool") {
+        let txt = textOf(m.content);
+        const ims = Array.isArray(m.content) ? m.content.filter((p) => p?.type === "image_url").map(imageBlock).filter(Boolean) : [];
+        const named = String(m.tool_call_id ?? "").trim();
+        const at = named ? turn?.open.findIndex((id) => id === named) ?? -1 : -1;
+        const pick = at >= 0 ? at : turn ? turn.open.findIndex((id) => !turn.kept.has(id)) : -1;
+        if (pick < 0) {
+          asText(txt, ims);
+          continue;
+        }
+        const answered = turn.open.splice(pick, 1)[0];
+        if (ims.length) {
+          let of = "tool call " + answered;
+          const name = names[answered] || m.name;
+          if (name) of = `${name} (${of})`;
+          seen.push({ type: "text", text: `[From the result of ${of}:]` }, ...ims);
+          const note = ims.length === 1 ? "[The tool returned an image; it follows in the next message.]" : `[The tool returned ${ims.length} images; they follow in the next message.]`;
+          txt = txt.trim() ? txt + "\n\n" + note : txt + note;
+        }
+        out.push({ role: "tool", tool_call_id: answered, content: txt });
+        continue;
+      }
+      if (m.role === "assistant" && m.tool_calls?.length) {
+        const calls = m.tool_calls.map((c, k) => {
+          const id = String(c.id ?? "").trim() || callID(i, k, c);
+          names[id] = c.function?.name;
+          const args = c.function?.arguments;
+          return { id, type: "function", function: { name: c.function?.name, arguments: typeof args === "string" ? args : JSON.stringify(args ?? {}) } };
+        });
+        out.push({ role: "assistant", content: textOf(m.content), tool_calls: calls });
+        const open2 = calls.map((c) => c.id);
+        const kept = /* @__PURE__ */ new Set();
+        for (let j = i + 1; j < msgs.length && msgs[j].role === "tool"; j++) {
+          const id = String(msgs[j].tool_call_id ?? "").trim();
+          if (open2.includes(id)) kept.add(id);
+        }
+        turn = { open: open2, kept };
+        continue;
+      }
+      let blocks = blocksOf(m.content);
+      if (m.role === "assistant") blocks = blocks.filter((b) => b.type === "text");
+      if (!blocks.length) continue;
+      if (m.role === "user" && seen.length) [blocks, seen] = [[...seen, ...blocks], []];
+      out.push({ role: m.role, content: blocks });
+      turn = null;
+    }
+    showSeen();
+    return out;
+  }
+  function windowFor(chat2, m, reply = 0) {
+    const base = m.defaultWindow || (m.config?.max_input_tokens > 0 ? m.config.max_input_tokens : 0) || m.context;
+    if (!m.windows?.length) return m.context;
+    const need = Math.ceil(Buffer.byteLength(JSON.stringify({ m: chat2.messages ?? [], t: chat2.tools ?? [] })) / 3) + Math.max(0, reply);
+    if (base > 0 && need <= base) return base;
+    return m.windows.find((w) => w >= need) ?? m.windows[m.windows.length - 1];
+  }
+  const UNCACHED = /* @__PURE__ */ new Set(["thinking", "redacted_thinking", "tool_use", "tool_result"]);
+  function cacheMarked(msgs) {
+    const out = msgs.map((m) => m.role === "user" && Array.isArray(m.content) ? { ...m, contents: m.content } : m);
+    const last = out.at(-1);
+    if (last?.role !== "user" || !Array.isArray(last.content)) return out;
+    const at = last.content.findLastIndex((b) => b?.type && !UNCACHED.has(b.type));
+    if (at < 0) return out;
+    const blocks = last.content.slice();
+    blocks[at] = { ...blocks[at], cache_control: { type: "ephemeral" } };
+    out[out.length - 1] = { ...last, content: blocks, contents: blocks };
+    return out;
+  }
+  function sessionOf(chat2, named = "") {
+    let seed = named ? "session\0" + named : String(chat2.prompt_cache_key ?? "").trim() ? "key\0" + chat2.prompt_cache_key : String(chat2.user ?? "").trim() ? "user\0" + chat2.user : "";
+    if (!seed) {
+      const msgs = chat2.messages ?? [];
+      const sys = msgs.filter((x) => x.role === "system" || x.role === "developer").map((x) => textOf(x.content));
+      const first = msgs.find((x) => x.role === "user");
+      seed = "chat\0" + JSON.stringify([sys, first?.content ?? ""]);
+    }
+    const h = createHash("sha256").update(seed).digest("hex");
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+  }
+  const TASKS = /* @__PURE__ */ new Map();
+  const TASK_MAX = 512;
+  const TASK_IDLE = 2 * 60 * 60 * 1e3;
+  const taskName = (prompt) => prompt.length > 10 ? prompt.slice(0, 10) : prompt;
+  function taskOf(sid, chat2, atTime = now()) {
+    const msgs = chat2.messages ?? [];
+    const at = msgs.findLastIndex((x) => x?.role === "user");
+    const key = createHash("sha256").update(JSON.stringify([sid, at, at < 0 ? null : msgs[at].content ?? null])).digest("hex");
+    for (const [k, t2] of TASKS) {
+      if (atTime - t2.used <= TASK_IDLE) break;
+      TASKS.delete(k);
+    }
+    let t = TASKS.get(key);
+    if (t && atTime - t.used > TASK_IDLE) t = void 0;
+    TASKS.delete(key);
+    t ??= { id: randomUUID(), begin: atTime, answered: false, name: taskName(at < 0 ? "" : textOf(msgs[at].content)) };
+    t.used = atTime;
+    TASKS.set(key, t);
+    while (TASKS.size > TASK_MAX) TASKS.delete(TASKS.keys().next().value);
+    return t;
+  }
+  const SUB_ONE = ["items", "additionalItems", "unevaluatedItems", "contains", "not", "if", "then", "else", "propertyNames", "additionalProperties", "unevaluatedProperties"];
+  const SUB_LIST = ["anyOf", "oneOf", "allOf", "prefixItems"];
+  const SUB_MAP = ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"];
+  function typedUnions(schema) {
+    if (!schema || typeof schema !== "object") return schema;
+    const root = structuredClone(schema);
+    const isObj = (v) => v && typeof v === "object" && !Array.isArray(v);
+    const target = (ref) => {
+      if (!ref.startsWith("#/")) return void 0;
+      let at = root;
+      for (const k of ref.slice(2).split("/")) at = at?.[k.replaceAll("~1", "/").replaceAll("~0", "~")];
+      return isObj(at) ? at : void 0;
+    };
+    const object = (b, seen = []) => {
+      if (!isObj(b)) return false;
+      if ("type" in b) return b.type === "object";
+      if (typeof b.$ref !== "string" || seen.includes(b.$ref) || seen.length > 16) return false;
+      return object(target(b.$ref), [...seen, b.$ref]);
+    };
+    const walk = (s, depth) => {
+      if (!isObj(s) || depth > 64) return;
+      if (!("type" in s) && Array.isArray(s.oneOf) && s.oneOf.length && s.oneOf.every((b) => object(b))) s.type = "object";
+      for (const k of SUB_ONE) walk(s[k], depth + 1);
+      for (const k of SUB_LIST) for (const v of Array.isArray(s[k]) ? s[k] : []) walk(v, depth + 1);
+      for (const k of SUB_MAP) if (isObj(s[k])) for (const v of Object.values(s[k])) walk(v, depth + 1);
+    };
+    walk(root, 0);
+    return root;
+  }
+  function qoderBody(chat2, m, named = "", task, site2) {
+    const system = (chat2.messages ?? []).filter((x) => x.role === "system" || x.role === "developer").map((x) => textOf(x.content)).filter(Boolean).join("\n\n");
+    const tools = chat2.tool_choice !== "none" ? (chat2.tools ?? []).filter((t) => t?.type === "function" && t.function?.name) : [];
+    const baseSystem = site2?.systemPrompt ?? QODER_SYS;
+    let sysText = system ? baseSystem + "\n\n" + system : baseSystem;
+    if (chat2.tool_choice === "required" && tools.length) sysText += "\nYou must call an available function in this response.";
+    const sys = { type: "text", text: sysText };
+    const [thinking, effort] = effortFor(chat2.reasoning_effort, m);
+    const params = { enable_thinking: thinking, max_tokens: chat2.max_completion_tokens || chat2.max_tokens || 32e3 };
+    if (effort) params.reasoning_effort = effort;
+    const window = windowFor(chat2, m, params.max_tokens);
+    if (window > 0) params.context_length = window;
+    const request = randomUUID();
+    const session = sessionOf(chat2, named);
+    task ??= taskOf(session, chat2);
+    const body = {
+      request_id: request,
+      request_set_id: task.id,
+      chat_record_id: request,
+      session_id: session,
+      parameters: params,
+      business: { product: site2?.businessProduct ?? "app", version: site2?.cosyVersion ?? COSY_VERSION, type: "agent", id: task.id, name: task.name ?? "", begin_at: task.begin, stage: task.answered ? "processing" : "start" },
+      agent_id: "agent_common",
+      task_id: "common",
+      session_type: site2?.sessionType ?? "app",
+      model_config: m.config,
+      system: [sys],
+      messages: [{ role: "system", content: [sys] }, ...cacheMarked(qoderMessages(chat2.messages ?? []))]
+    };
+    if (tools.length)
+      body.tools = tools.map((t) => ({
+        type: "function",
+        function: { name: t.function.name, description: t.function.description ?? "", parameters: typedUnions(t.function.parameters) ?? { type: "object", properties: {} } }
+      }));
+    return body;
+  }
+  const QUEUED = "10605";
+  const QUOTA_CODES = /* @__PURE__ */ new Set(["110", "112", "113", "114", "115", "116", "117", "118", "119", "122"]);
+  const REQUEST_CODES = /* @__PURE__ */ new Set(["406", "416", "430", "80411", "80412", "100400", "100401", "100403"]);
+  const BUSY_WAIT = 30;
+  const UPSTREAM_FAILED = /\berror in upstream response\b/i;
+  function failure(status, text) {
+    if (status < 400 || status > 599) status = 502;
+    let msg = String(text ?? "").trim();
+    let code = "";
+    let queue;
+    try {
+      let j = JSON.parse(msg);
+      const outerCode = j?.code == null ? "" : String(j.code);
+      if (["", "401", "403"].includes(outerCode) && typeof j?.message === "string") {
+        try {
+          const inner = JSON.parse(j.message.trim());
+          if (inner && !Array.isArray(inner) && String(inner.code) === QUEUED) j = inner;
+        } catch {
+        }
+      }
+      code = j?.code == null ? "" : String(j.code);
+      if (j?.message) msg = String(j.message);
+      const d = typeof j?.details === "string" ? JSON.parse(j.details.trim()) : j?.details;
+      if (d?.error?.message) msg += ": " + d.error.message;
+      queue = j?.queue && typeof j.queue === "object" ? j.queue : void 0;
+      if (!queue && typeof j?.message === "string" && j.message.trim().startsWith("{")) {
+        const q = JSON.parse(j.message.trim());
+        if (q && typeof q === "object" && ("isQueued" in q || "serviceAvailable" in q || "retryAfterSeconds" in q)) queue = q;
+      }
+    } catch {
+    }
+    msg ||= STATUS_CODES[status] ?? `HTTP ${status}`;
+    if (code === QUEUED || queue?.isQueued === true || queue?.serviceAvailable === false) {
+      const n = Number(queue?.retryAfterSeconds);
+      const wait = Number.isFinite(n) && n > 0 ? Math.ceil(n) : BUSY_WAIT;
+      const model = queue?.modelKey ? ` for ${queue.modelKey}` : "";
+      const ahead = Number(queue?.queueCount) > 0 ? `, ${Math.floor(Number(queue.queueCount))} ahead` : "";
+      const tier = queue?.queueType ? ` (this plan's queue: ${queue.queueType}${ahead})` : ahead ? ` (${ahead.slice(2)})` : "";
+      const what = queue?.isQueued === true ? "queued the request" : "is busy";
+      return { status: 503, message: `Qoder ${what}${model}${tier}; try again in ${wait}s`, retryAfter: wait, signIn: "", queue: queue ?? {} };
+    }
+    if (QUOTA_CODES.has(code)) return { status: 429, message: "usage limit reached: " + msg, signIn: "" };
+    if (REQUEST_CODES.has(code)) return { status: 400, message: `Qoder refused the request (${code}): ${msg}`, signIn: "" };
+    if (UPSTREAM_FAILED.test(msg)) return { status: 502, message: msg, signIn: "" };
+    if (status === 401 || status === 403) {
+      const said = msg && msg !== STATUS_CODES[status] ? ` (Qoder said ${status}: ${msg.slice(0, 300)})` : "";
+      return { status: 401, message: "the sign-in lapsed \u2014 sign in again" + said };
+    }
+    if (status === 429 || msg.toLowerCase().includes("quota")) return { status: 429, message: "usage limit reached: " + msg };
+    return { status, message: msg };
+  }
+  const errorResponse = ({ status, message, signIn = status === 401 ? "kept" : void 0, retryAfter }) => new Response(JSON.stringify({ error: { message, type: "qoder_error", code: status }, ...status === 503 && retryAfter > 0 ? { retry_after: Math.ceil(Number(retryAfter)) } : {} }), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      ...signIn ? { "X-Magpie-Sign-In": signIn } : {},
+      ...retryAfter > 0 ? { "Retry-After": String(retryAfter) } : {}
+    }
+  });
+  const QUEUE_STATUS_PATH = "/algo/api/v2/service/ask/queue/status";
+  const QUEUE = {
+    budget: 4 * 60 * 1e3,
+    // the longest a request is held, its first answer's wait included
+    shortest: 500,
+    longest: 3e4,
+    unsaid: 3e4,
+    // a pause when the queue gives no retryAfterSeconds
+    recoveries: 10,
+    // the queue waited out this many times, at most, for one request
+    failures: 3,
+    // status asks failing in a row that end the wait
+    ask: 3e4,
+    // the longest one status ask may take
+    now: () => now(),
+    pause: (ms, signal) => new Promise((ok, no) => {
+      if (signal?.aborted) return no(signal.reason ?? new DOMException("aborted", "AbortError"));
+      const t = setTimeout(() => {
+        signal?.removeEventListener("abort", stop);
+        ok();
+      }, ms);
+      const stop = () => {
+        clearTimeout(t);
+        no(signal.reason ?? new DOMException("aborted", "AbortError"));
+      };
+      signal?.addEventListener("abort", stop, { once: true });
+    })
+  };
+  function queuePause(seconds) {
+    const n = Number(seconds);
+    const ms = Number.isFinite(n) ? n * 1e3 : QUEUE.unsaid;
+    return Math.min(QUEUE.longest, Math.max(QUEUE.shortest, ms));
+  }
+  class QueueEnd extends Error {
+  }
+  function queueState(text) {
+    let root;
+    try {
+      root = JSON.parse(text);
+    } catch {
+      return void 0;
+    }
+    const todo = [root];
+    const seen = /* @__PURE__ */ new Set();
+    while (todo.length) {
+      const o = todo.shift();
+      if (!o || typeof o !== "object" || Array.isArray(o) || seen.has(o)) continue;
+      seen.add(o);
+      const flag = (v) => typeof v === "boolean" ? v : v === "true" ? true : v === "false" ? false : void 0;
+      const isQueued = flag(o.isQueued);
+      const serviceAvailable = flag(o.serviceAvailable);
+      if (isQueued !== void 0 || serviceAvailable !== void 0) {
+        const num = (v) => v == null || v === "" || !Number.isFinite(Number(v)) ? void 0 : Number(v);
+        const str = (v) => typeof v === "string" && v ? v : void 0;
+        return { isQueued, serviceAvailable, modelKey: str(o.modelKey), queueType: str(o.queueType), retryAfterSeconds: num(o.retryAfterSeconds) };
+      }
+      for (const k of ["data", "result", "message", "body"]) {
+        const v = o[k];
+        if (v && typeof v === "object") todo.push(v);
+        else if (typeof v === "string")
+          try {
+            todo.push(JSON.parse(v));
+          } catch {
+          }
+      }
+    }
+    return void 0;
+  }
+  async function queueStatus(api, cred, { requestSetId, modelKey, queueType, requestId, sessionId }, signal, deadline, site2) {
+    const q = new URLSearchParams({ requestSetId, modelKey });
+    if (queueType) q.set("queueType", queueType);
+    const url = `${api}${QUEUE_STATUS_PATH}?${q}`;
+    const headers = { ...cosyHeaders(url, cred, "", site2), "X-Request-ID": requestId, "X-Session-ID": sessionId };
+    delete headers["Content-Type"];
+    const left = Math.min(QUEUE.ask, deadline - QUEUE.now());
+    if (left <= 0) throw new QueueEnd("the queue's wait ran out");
+    const res = await fetch2(url, { headers, signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(left)]) : AbortSignal.timeout(left) });
+    const text = await res.text();
+    checkAbort(signal);
+    if (res.status === 404) throw new QueueEnd("Qoder has no queue status here");
+    if (!res.ok) throw new Error(`queue status: HTTP ${res.status}`);
+    const st = queueState(text);
+    if (!st) throw new QueueEnd("the queue status said nothing of the queue");
+    return st;
+  }
+  async function queueWait(api, cred, ask, first, signal, deadline, site2) {
+    let q = first ?? {};
+    let asked = false;
+    let failed = 0;
+    for (; ; ) {
+      checkAbort(signal);
+      if (QUEUE.now() >= deadline) return false;
+      if (asked) await QUEUE.pause(Math.min(queuePause(q.retryAfterSeconds), Math.max(0, deadline - QUEUE.now())), signal);
+      asked = true;
+      if (QUEUE.now() >= deadline) return false;
+      let st;
+      try {
+        st = await queueStatus(api, cred, { ...ask, modelKey: q.modelKey ?? ask.modelKey, queueType: q.queueType ?? ask.queueType }, signal, deadline, site2);
+      } catch (e) {
+        checkAbort(signal);
+        if (e instanceof QueueEnd) return false;
+        if (++failed >= QUEUE.failures) return false;
+        q = { ...q, retryAfterSeconds: void 0 };
+        continue;
+      }
+      failed = 0;
+      q = { ...st, modelKey: st.modelKey ?? q.modelKey, queueType: st.queueType ?? q.queueType };
+      if (st.isQueued === false) {
+        if (st.retryAfterSeconds > 0) await QUEUE.pause(Math.min(queuePause(st.retryAfterSeconds), Math.max(0, deadline - QUEUE.now())), signal);
+        return QUEUE.now() < deadline;
+      }
+      if (st.serviceAvailable === false || st.isQueued === true) continue;
+      return false;
+    }
+  }
+  const CALL_OPEN = "<tool_call>";
+  const CALL_CLOSE = "</tool_call>";
+  const FUNC = /\x3cfunction=([^>]+)\x3e([\s\S]*?)\x3c\/function\x3e/;
+  const PARAM = /\x3cparameter=([^>]+)\x3e([\s\S]*?)\x3c\/parameter\x3e/g;
+  function parseCall(v, tools = []) {
+    try {
+      const f = JSON.parse(v.trim());
+      if (String(f?.name ?? "").trim() && f.arguments && typeof f.arguments === "object" && !Array.isArray(f.arguments))
+        return { name: f.name.trim(), args: JSON.stringify(f.arguments) };
+    } catch {
+    }
+    const m = FUNC.exec(v);
+    if (!m || !m[1].trim()) return null;
+    const name = m[1].trim();
+    const props = propsOf(tools, name);
+    const args = {};
+    for (const pm of m[2].matchAll(PARAM)) {
+      const key = pm[1].trim();
+      if (!key) continue;
+      args[key] = valueOf(pm[2].trim(), props[key]);
+    }
+    return { name, args: JSON.stringify(args) };
+  }
+  const propsOf = (tools, name) => (tools.find((t) => (t.function ?? t)?.name === name)?.function ?? {}).parameters?.properties ?? {};
+  function valueOf(v, prop) {
+    if (prop?.type === "string") return v;
+    try {
+      return JSON.parse(v.trim());
+    } catch {
+      return v;
+    }
+  }
+  const XML_AT = /<(?:antml:)?(?:function_calls>|invoke\s+name\s*=|function=)/;
+  const XML_HOLD = /<(?:antml:)?(?:invoke\s[^<>]{0,300}|function=[^<>]{0,300})$/;
+  const XML_STARTS = ["<invoke ", "<antml:invoke ", "<function="];
+  const XML_MARKS = ["<function_calls>", "<antml:function_calls>", ...XML_STARTS];
+  const XML_NEXT = /<(?:antml:)?invoke\s+name\s*=|<function=/;
+  const XML_PARAM = /<(?:antml:)?parameter(?:\s+name\s*=\s*"([^"]+)"|=([^\s>]+))\s*>/g;
+  const XML_CLOSES = ["</function_calls>", "</antml:function_calls>", "</invoke>", "</antml:invoke>", "</function>"];
+  const XML_LEFT = /^(?:\s+|<\/(?:antml:)?(?:function_calls|invoke|function)>)+/;
+  function xmlArgs(s, props) {
+    const opens = [...s.matchAll(XML_PARAM)];
+    const args = {};
+    let closed = opens.length > 0;
+    opens.forEach((m, k) => {
+      let v = s.slice(m.index + m[0].length, k + 1 < opens.length ? opens[k + 1].index : s.length);
+      const c = v.search(/<\/(?:antml:)?parameter>/);
+      if (c >= 0) v = v.slice(0, c);
+      else closed = false;
+      args[m[1] ?? m[2]] = valueOf(v.replace(/^\r?\n|\r?\n$/g, ""), props[m[1] ?? m[2]]);
+    });
+    return { args, closed };
+  }
+  function xmlCall(s, end, tools) {
+    const w = s.match(/^<(?:antml:)?function_calls>/);
+    if (w) {
+      const rest = s.slice(w[0].length).replace(/^\s+/, "");
+      if (!end && (!rest || XML_STARTS.some((k) => k.startsWith(rest)))) return { wait: true };
+      s = rest;
+    }
+    let m = s.match(/^<(?:antml:)?invoke\s+name\s*=\s*"([^"<>]+)"\s*>/);
+    let closeRe = /<\/(?:antml:)?invoke\s*>/;
+    if (!m) {
+      m = s.match(/^<function=([^\s<>]+?)\s*>/);
+      closeRe = /<\/function\s*>/;
+    }
+    if (!m) {
+      if (!end && (XML_STARTS.some((k) => k.startsWith(s)) || /^<(?:antml:)?(?:invoke\s|function=)[^<>]{0,300}$/.test(s))) return { wait: true };
+      return { text: true };
+    }
+    const name = m[1].trim();
+    if (!tools.some((t) => (t.function ?? t)?.name === name)) return { text: true };
+    const body = s.slice(m[0].length);
+    const c = body.match(closeRe);
+    const n = body.search(XML_NEXT);
+    let stop = c ? c.index : -1;
+    if (n >= 0 && (stop < 0 || n < stop)) stop = n;
+    if (stop < 0) {
+      if (!end) return { wait: true };
+      stop = body.length;
+    }
+    const whole = !!c && c.index === stop;
+    const p = xmlArgs(body.slice(0, stop), propsOf(tools, name));
+    if (!whole && !p.closed) {
+      if (!/<(?:antml:)?parameter\b/.test(body.slice(0, stop))) return { text: true };
+      return { error: CUT_SHORT };
+    }
+    return { call: { name, args: JSON.stringify(p.args) }, rest: whole ? body.slice(stop + c[0].length) : body.slice(stop) };
+  }
+  function quoted(text) {
+    if ((text.match(/```/g)?.length ?? 0) % 2) return true;
+    const line = text.slice(text.lastIndexOf("\n") + 1).replace(/```/g, "");
+    return (line.match(/`/g)?.length ?? 0) % 2 === 1;
+  }
+  const callish = (v) => v.trimStart().startsWith("{") || v.includes("<function=");
+  const CUT_SHORT = "the model's tool call, written as text, was cut short; it is not sent on as the answer";
+  const UNREADABLE = "the model's tool call, written as text, can't be read; it is not sent on as the answer";
+  class Splitter {
+    textBuf = "";
+    callBuf = "";
+    inCall = false;
+    sawTool = false;
+    after = false;
+    // a bare call just ended: the closes and blanks after it are dropped
+    sent = "";
+    // the text given out so far, to tell a block in code from a call
+    constructor(tools = []) {
+      this.tools = tools.filter((t) => (t?.function ?? t)?.name);
+    }
+    text(out, t) {
+      this.sent += t;
+      out.push({ text: t });
+    }
+    // bare reads text that may hold a bare call, comb starting at its tag x:
+    // the input left to read, null when comb is held for more, or false
+    // when the turn ended in an error
+    bare(out, comb, x, end) {
+      const head = comb.slice(0, x);
+      const at = comb.slice(x);
+      const opener = at.match(/^<[^<>]*>?/)[0];
+      if (quoted(this.sent + head)) {
+        this.text(out, head + opener);
+        return at.slice(opener.length);
+      }
+      const b = xmlCall(at, end, this.tools);
+      if (b.wait) {
+        if (head) this.text(out, head);
+        this.textBuf = at;
+        return null;
+      }
+      if (b.text) {
+        this.text(out, head + opener);
+        return at.slice(opener.length);
+      }
+      if (head) this.text(out, head);
+      if (b.error) {
+        out.push({ error: b.error });
+        return false;
+      }
+      this.sawTool = true;
+      out.push({ call: b.call });
+      this.after = true;
+      return b.rest;
+    }
+    // left drops what is left after a bare call; null while it may still be
+    // one of its closes
+    left(comb, end) {
+      const rest = comb.replace(XML_LEFT, "");
+      if (!end && (!rest || XML_CLOSES.some((c) => c.length > rest.length && c.startsWith(rest)))) return null;
+      this.after = false;
+      return rest;
+    }
+    feed(input) {
+      const out = [];
+      while (input) {
+        if (!this.inCall) {
+          let comb2 = this.textBuf + input;
+          this.textBuf = "";
+          if (this.after) {
+            const rest = this.left(comb2, false);
+            if (rest === null) {
+              this.textBuf = comb2;
+              break;
+            }
+            comb2 = rest;
+            if (!comb2) break;
+          }
+          const i = comb2.indexOf(CALL_OPEN);
+          const x = this.tools.length ? comb2.search(XML_AT) : -1;
+          if (x >= 0 && (i < 0 || x < i)) {
+            const next = this.bare(out, comb2, x, false);
+            if (next === false) return out;
+            if (next === null) break;
+            input = next;
+            continue;
+          }
+          if (i < 0) {
+            let keep = 0;
+            for (const mark of this.tools.length ? [CALL_OPEN, ...XML_MARKS] : [CALL_OPEN])
+              for (let n = Math.min(mark.length - 1, comb2.length); n > keep; n--)
+                if (comb2.endsWith(mark.slice(0, n))) {
+                  keep = n;
+                  break;
+                }
+            const h = this.tools.length ? comb2.search(XML_HOLD) : -1;
+            if (h >= 0) keep = Math.max(keep, comb2.length - h);
+            if (keep < comb2.length) this.text(out, comb2.slice(0, comb2.length - keep));
+            this.textBuf = comb2.slice(comb2.length - keep);
+            break;
+          }
+          if (i > 0) this.text(out, comb2.slice(0, i));
+          input = comb2.slice(i + CALL_OPEN.length);
+          this.inCall = true;
+          continue;
+        }
+        const comb = this.callBuf + input;
+        this.callBuf = "";
+        const j = comb.indexOf(CALL_CLOSE);
+        if (j < 0) {
+          this.callBuf = comb;
+          break;
+        }
+        const body = comb.slice(0, j);
+        const c = parseCall(body, this.tools);
+        if (c) {
+          this.sawTool = true;
+          out.push({ call: c });
+        } else if (callish(body) && !quoted(this.sent)) {
+          this.inCall = false;
+          out.push({ error: UNREADABLE });
+          return out;
+        } else this.text(out, CALL_OPEN + body + CALL_CLOSE);
+        input = comb.slice(j + CALL_CLOSE.length);
+        this.inCall = false;
+      }
+      return out;
+    }
+    flush() {
+      if (this.inCall) {
+        const body = this.callBuf;
+        this.inCall = false;
+        this.callBuf = "";
+        if (callish(body) && !quoted(this.sent)) {
+          const c = parseCall(body, this.tools);
+          if (!c) return [{ error: CUT_SHORT }];
+          this.sawTool = true;
+          return [{ call: c }];
+        }
+        const t = CALL_OPEN + body;
+        this.sent += t;
+        return [{ text: t }];
+      }
+      if (this.textBuf) {
+        let t = this.textBuf;
+        this.textBuf = "";
+        if (this.after) t = this.left(t, true);
+        const out = [];
+        while (t) {
+          const x = this.tools.length ? t.search(XML_AT) : -1;
+          if (x < 0) {
+            this.text(out, t);
+            break;
+          }
+          const next = this.bare(out, t, x, true);
+          if (next === false) break;
+          t = this.after ? this.left(next, true) : next;
+        }
+        return out;
+      }
+      return [];
+    }
+  }
+  async function* sseLines(body, signal) {
+    const dec = new TextDecoder();
+    let buf = "";
+    for await (const chunk of body) {
+      checkAbort(signal);
+      buf += dec.decode(chunk, { stream: true });
+      let n;
+      while ((n = buf.indexOf("\n")) >= 0) {
+        yield buf.slice(0, n).trim();
+        buf = buf.slice(n + 1);
+      }
+    }
+    checkAbort(signal);
+    if (buf.trim()) yield buf.trim();
+  }
+  async function* events(body, tools = [], signal) {
+    const a = new Splitter(tools);
+    let index = -1;
+    const native = /* @__PURE__ */ new Map();
+    const piece = (f) => f.call ? { tool: { index: ++index, id: "call_" + hexID(), name: f.call.name, args: f.call.args } } : f.error ? { error: { status: 502, message: f.error } } : { text: f.text };
+    let usage2;
+    let fr = "";
+    let sawData = false;
+    let parsed = false;
+    let semantic = false;
+    for await (const line of sseLines(body, signal)) {
+      if (!line.startsWith("data:")) continue;
+      sawData = true;
+      const payload = line.slice(5).trim();
+      let env;
+      try {
+        env = JSON.parse(payload);
+      } catch {
+        continue;
+      }
+      const inner = typeof env?.body === "string" ? env.body : "";
+      if (env?.statusCodeValue != null && env.statusCodeValue !== 200) {
+        yield { error: failure(Number(env.statusCodeValue), inner || payload) };
+        return;
+      }
+      if (inner.trim() === "[DONE]") break;
+      let chunk;
+      try {
+        chunk = JSON.parse(inner.trim());
+      } catch {
+        continue;
+      }
+      parsed = true;
+      const delta = chunk?.choices?.[0]?.delta ?? {};
+      const reasoning = delta.reasoning_content;
+      if (typeof reasoning === "string" && reasoning) {
+        semantic = true;
+        yield { reasoning };
+      }
+      if (typeof delta.content === "string")
+        for (const f of a.feed(delta.content)) {
+          if (!f.call && !f.error && !f.text) continue;
+          const e = piece(f);
+          if (e.text || e.tool) semantic = true;
+          yield e;
+          if (e.error) return;
+        }
+      for (const tc of delta.tool_calls ?? []) {
+        const i = Number(tc.index ?? 0);
+        const name = typeof tc.function?.name === "string" ? tc.function.name.trim() : "";
+        const args = tc.function?.arguments ?? "";
+        if (!tc.id && !name && !args) continue;
+        let call = native.get(i);
+        if (!call) {
+          call = { id: "", args: "" };
+          native.set(i, call);
+        }
+        if (tc.id) call.id = tc.id;
+        if (call.index === void 0) {
+          call.args += args;
+          if (!name) continue;
+          for (const f of a.flush()) {
+            const e = piece(f);
+            yield e;
+            if (e.error) return;
+          }
+          a.sawTool = true;
+          call.index = ++index;
+          semantic = true;
+          yield { tool: { index: call.index, id: call.id || "call_" + hexID(), name, args: call.args } };
+        } else if (args) yield { args: { index: call.index, text: args } };
+      }
+      fr = chunk?.choices?.[0]?.finish_reason || fr;
+      const u = chunk?.usage;
+      if (u) {
+        usage2 = {
+          prompt_tokens: u.prompt_tokens ?? 0,
+          completion_tokens: u.completion_tokens ?? 0,
+          total_tokens: (u.prompt_tokens ?? 0) + (u.completion_tokens ?? 0),
+          ...u.prompt_tokens_details?.cached_tokens ? { prompt_tokens_details: { cached_tokens: u.prompt_tokens_details.cached_tokens } } : {},
+          ...u.completion_tokens_details?.reasoning_tokens ? { completion_tokens_details: { reasoning_tokens: u.completion_tokens_details.reasoning_tokens } } : {}
+        };
+      }
+    }
+    for (const f of a.flush()) {
+      const e = piece(f);
+      if (e.text || e.tool) semantic = true;
+      yield e;
+      if (e.error) return;
+    }
+    if ([...native.values()].some((call) => call.index === void 0)) {
+      yield { error: { status: 502, message: "the model's native tool call has no name; it is not sent on as a tool" } };
+      return;
+    }
+    if (!sawData) return;
+    if (!parsed || !semantic) {
+      yield { error: { status: 502, message: "Qoder sent an unreadable answer" } };
+      return;
+    }
+    yield { stop: a.sawTool ? "tool_calls" : fr === "length" ? "length" : "stop", usage: usage2 };
+  }
+  async function opened(res, tools, signal) {
+    const it = events(res.body, tools, signal);
+    const first = await it.next();
+    checkAbort(signal);
+    return { it, first };
+  }
+  async function answer({ it, first }, chat2, servedName = chat2.model, signal) {
+    const id = "chatcmpl-" + hexID();
+    const created = Math.floor(now() / 1e3);
+    if (first.value?.error) return errorResponse(first.value.error);
+    if (first.done) return errorResponse({ status: 502, message: "Qoder ended without an answer" });
+    if (!chat2.stream) {
+      const msg = { role: "assistant", content: "" };
+      let reasoning = "";
+      const calls = [];
+      let stop = "stop";
+      let usage2;
+      for (let r = first; !r.done; r = await it.next()) {
+        checkAbort(signal);
+        const e = r.value;
+        if (e.error) return errorResponse(e.error);
+        if (e.text) msg.content += e.text;
+        if (e.reasoning) reasoning += e.reasoning;
+        if (e.tool) calls.push({ id: e.tool.id, type: "function", function: { name: e.tool.name, arguments: e.tool.args } });
+        if (e.args) calls[e.args.index].function.arguments += e.args.text;
+        if (e.stop) [stop, usage2] = [e.stop, e.usage];
+      }
+      checkAbort(signal);
+      if (reasoning) msg.reasoning_content = reasoning;
+      if (calls.length) msg.tool_calls = calls;
+      return Response.json({ id, object: "chat.completion", created, model: servedName, choices: [{ index: 0, message: msg, finish_reason: stop }], ...usage2 ? { usage: usage2 } : {} });
+    }
+    const enc = new TextEncoder();
+    const chunk = (delta, finish_reason = null, extra = {}) => enc.encode(`data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model: servedName, choices: [{ index: 0, delta, finish_reason }], ...extra })}
+
+`);
+    let pending = first;
+    let began = false;
+    const stream = new ReadableStream({
+      async pull(ctl) {
+        const r = pending ?? await it.next();
+        checkAbort(signal);
+        pending = null;
+        if (!began) {
+          began = true;
+          ctl.enqueue(chunk({ role: "assistant", content: "" }));
+        }
+        if (r.done) {
+          ctl.enqueue(enc.encode("data: [DONE]\n\n"));
+          return ctl.close();
+        }
+        const e = r.value;
+        if (e.text) ctl.enqueue(chunk({ content: e.text }));
+        else if (e.reasoning) ctl.enqueue(chunk({ reasoning_content: e.reasoning }));
+        else if (e.tool) ctl.enqueue(chunk({ tool_calls: [{ index: e.tool.index, id: e.tool.id, type: "function", function: { name: e.tool.name, arguments: e.tool.args } }] }));
+        else if (e.args) ctl.enqueue(chunk({ tool_calls: [{ index: e.args.index, function: { arguments: e.args.text } }] }));
+        else if (e.stop) ctl.enqueue(chunk({}, e.stop, e.usage ? { usage: e.usage } : {}));
+        else if (e.error) {
+          ctl.enqueue(enc.encode(`data: ${JSON.stringify({ error: { message: e.error.message, code: e.error.status } })}
+
+`));
+          ctl.close();
+        }
+      },
+      cancel() {
+        it.return?.();
+      }
+    });
+    return new Response(stream, { status: 200, headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" } });
+  }
+  class UsageStatus extends Error {
+    constructor(status) {
+      super(`qoder usage: upstream HTTP ${status}`);
+      this.status = status;
+    }
+  }
+  async function fetchUsage(site2, deviceToken, signal) {
+    if (!String(deviceToken ?? "").trim()) throw new Error("qoder usage: missing device token");
+    let res;
+    try {
+      res = await fetch2(site2.openapi + "/sash/api/v2/me/usage", {
+        headers: { Accept: "application/json", Authorization: `Bearer ${deviceToken}`, "Cosy-ClientType": "10", "User-Agent": "Qoder" },
+        signal: combine(signal, AbortSignal.timeout(2e4))
+      });
+    } catch (e) {
+      checkAbort(signal);
+      throw new Error(`qoder usage: request failed: ${e?.message ?? e}`);
+    }
+    if (res.status !== 200) throw new UsageStatus(res.status);
+    let env;
+    try {
+      env = JSON.parse(await res.text());
+    } catch (e) {
+      checkAbort(signal);
+      throw new Error(`qoder usage: decode response: ${e?.message ?? e}`);
+    }
+    checkAbort(signal);
+    if (env?.displayMode !== "qoder" && env?.displayMode !== "enterprise") throw new Error("qoder usage: unknown display mode");
+    if (env.displayMode === "qoder" && (env.qoderUsage === void 0 || env.qoderUsage === null)) throw new Error("qoder usage: missing quota data");
+    return env;
+  }
+  function gfmt(n) {
+    const [m, e] = n.toExponential().split("e");
+    const x = Number(e);
+    if (x < -4 || x >= 6) return `${m}e${x < 0 ? "-" : "+"}${String(Math.abs(x)).padStart(2, "0")}`;
+    return String(n);
+  }
+  const RFC3339 = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?(Z|[+-]\d\d:\d\d)$/i;
+  function when(v) {
+    if (typeof v === "string" && RFC3339.test(v) && !isNaN(Date.parse(v))) return new Date(v).toISOString();
+    const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v.trim()) : NaN;
+    if (!isFinite(n) || n <= 0) return void 0;
+    return new Date(Math.trunc(n < 1e12 ? n * 1e3 : n)).toISOString();
+  }
+  function parseUsage(env) {
+    if (env.displayMode === "enterprise") return { plan: "Enterprise" };
+    const u = env.qoderUsage;
+    if (env.displayMode !== "qoder" || !u || typeof u !== "object" || Array.isArray(u)) return { error: "Qoder: missing quota data" };
+    const field2 = (a, b) => u[a] !== void 0 ? u[a] : u[b];
+    const out = { windows: [] };
+    const plan = field2("userType", "user_type");
+    if (typeof plan === "string") out.plan = plan;
+    const until = when(field2("expiresAt", "expires_at"));
+    if (until) out.until = until;
+    const num = (v) => v === void 0 || v === null || typeof v === "number";
+    const str = (v) => v === void 0 || v === null || typeof v === "string";
+    const add = (b, name) => {
+      if (b === null || typeof b !== "object" || Array.isArray(b)) return;
+      if (![b.total, b.cap, b.used, b.remaining].every(num) || !str(b.name) || !str(b.unit)) return;
+      const total = b.total ?? b.cap;
+      if (total == null || total <= 0 || b.used == null && b.remaining == null) return;
+      const used = b.used != null ? b.used : total - b.remaining;
+      if (used < 0) return;
+      out.windows.push({ name: b.name || name, used: Math.min(100, 100 * used / total), display: `${gfmt(used)} / ${gfmt(total)} ${b.unit || "credits"}` });
+    };
+    add(field2("userQuota", "user_quota"), "Credits");
+    add(field2("addOnQuota", "add_on_quota"), "Add-on credits");
+    add(field2("orgResourcePackage", "org_resource_package"), "Shared credits");
+    const dedicated = field2("dedicatedResourcePackages", "dedicated_resource_packages");
+    for (const b of Array.isArray(dedicated) ? dedicated : []) add(b, "Dedicated credits");
+    return out;
+  }
+  let lock = Promise.resolve();
+  const locked = (fn) => {
+    const run = lock.then(fn, fn);
+    lock = run.catch(() => {
+    });
+    return run;
+  };
+  const spent = /* @__PURE__ */ new Map();
+  const pruneSpent = () => {
+    for (const [key, value] of spent) if (now() - value.at > KEEP_SPENT_MS) spent.delete(key);
+  };
+  const latest = (cred) => {
+    pruneSpent();
+    for (let i = 0; i < 16 && cred?.refresh; i++) {
+      const entry = spent.get(cred.refresh);
+      if (!entry) break;
+      cred = { ...cred, ...entry.got };
+    }
+    return cred;
+  };
+  const spend = (refresh2, got) => {
+    pruneSpent();
+    spent.set(refresh2, { got, at: now() });
+    return got;
+  };
+  const connectPAT = async (pat) => {
+    if (typeof pat !== "string" || !pat.startsWith("pt-") || pat.length > 4096)
+      throw new Error("PAT must start with pt- and be at most 4096 characters");
+    const cred = await patSignIn(site, pat);
+    checkAbort();
+    return cred;
+  };
+  const renew = async (cred, signal) => {
+    let jt;
+    try {
+      jt = await refreshJob(site, cred.refresh, cred.accountId || cred.email || cred.uid, signal);
+      checkAbort(signal);
+    } catch (e) {
+      checkAbort(signal);
+      if (!(e instanceof SignInGone) || !cred.pat) throw e;
+      let exchanged;
+      try {
+        exchanged = await patSignIn(site, cred.pat, signal);
+        checkAbort(signal);
+      } catch (p) {
+        checkAbort(signal);
+        if (!p?.status) throw p;
+        throw new SignInGone("Qoder refused the PAT \u2014 sign in again with a new one", true);
+      }
+      return spend(cred.refresh, { access: exchanged.access, refresh: exchanged.refresh, expires: exchanged.expires });
+    }
+    return spend(cred.refresh, { access: jt.token, refresh: jt.refresh_token, expires: expiresAt(jt) });
+  };
+  const refresh = (cred) => locked(async () => {
+    checkAbort();
+    const current = latest(cred);
+    if (current !== cred && current.expires - now() > REFRESH_LEAD) return current;
+    const next = { ...current, ...await renew(current) };
+    checkAbort();
+    return next;
+  });
+  const abortable = (work, signal) => {
+    checkAbort(signal);
+    if (!signal) return work;
+    return new Promise((resolve, reject) => {
+      const stop = () => reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+      signal.addEventListener("abort", stop, { once: true });
+      work.then(resolve, reject).finally(() => signal.removeEventListener("abort", stop));
+    });
+  };
+  const fresh = (cred, signal) => abortable(locked(async () => {
+    checkAbort(signal);
+    if (!cred?.access || !cred.uid) throw new SignInGone("Qoder: not signed in");
+    const current = latest(cred);
+    if (current.expires - now() >= REFRESH_LEAD) return current;
+    const next = { ...current, ...await renew(current) };
+    try {
+      Promise.resolve(options.onRefresh?.(next)).catch(() => {
+      });
+    } catch {
+    }
+    return next;
+  }), signal);
+  const listings = /* @__PURE__ */ new Map();
+  const modelsFor = async (cred, again = false, signal) => {
+    let listing = listings.get(cred.uid);
+    if (!listing || again) {
+      listing = modelInfos(await fetchListing(site, cred, signal), site);
+      checkAbort(signal);
+      listings.set(cred.uid, listing);
+    }
+    return listing;
+  };
+  const models = async (cred, again = false) => {
+    const current = await fresh(cred);
+    checkAbort();
+    return modelsFor(current, again);
+  };
+  const usage = async (cred) => {
+    const current = await fresh(cred);
+    checkAbort();
+    const env = await fetchUsage(site, current.access);
+    checkAbort();
+    return { windows: [], ...parseUsage(env), signIn: "kept" };
+  };
+  const signedInError = (e) => errorResponse({
+    status: e instanceof SignInGone || e?.expired ? 401 : 502,
+    message: String(e?.message ?? e).replace(/^Qoder: /, ""),
+    signIn: e?.expired ? "expired" : void 0
+  });
+  const chat = async (credential, chatBody, { session = "", signal: requestSignal } = {}) => {
+    const signal = combine(requestSignal);
+    checkAbort(signal);
+    try {
+      const cred = await fresh(credential, signal);
+      checkAbort(signal);
+      const m = (await modelsFor(cred, false, signal)).find((x) => x.key === chatBody.model) ?? (await modelsFor(cred, true, signal)).find((x) => x.key === chatBody.model);
+      checkAbort(signal);
+      if (!m) return errorResponse({ status: 400, message: `unknown or disabled model "${chatBody.model}"` });
+      const name = m.name?.trim();
+      const servedName = name && name !== m.key ? name : chatBody.model;
+      const api = site.api;
+      const url = api + CHAT_PATH2;
+      const task = taskOf(sessionOf(chatBody, session), chatBody);
+      const body = qoderBody(chatBody, m, session, task, site);
+      const deadline = QUEUE.now() + QUEUE.budget;
+      const ask = { requestSetId: body.request_set_id, requestId: body.request_id, sessionId: body.session_id, modelKey: m.key };
+      for (let waited = 0; ; waited++) {
+        checkAbort(signal);
+        if (waited) {
+          body.request_id = body.chat_record_id = randomUUID();
+          ask.requestId = body.request_id;
+        }
+        const wire = encodeBody(JSON.stringify(body));
+        const headers = {
+          ...cosyHeaders(url, cred, wire, site),
+          Accept: "text/event-stream",
+          "Cache-Control": "no-cache",
+          "X-Model-Key": m.key,
+          "X-Model-Source": m.source
+        };
+        const call = new AbortController();
+        const res = await fetch2(url, { method: "POST", headers, body: wire, signal: combine(signal, call.signal) });
+        checkAbort(signal);
+        let open2, f;
+        if (res.ok) {
+          open2 = await opened(res, chatBody.tool_choice !== "none" ? (chatBody.tools ?? []).filter((t) => t?.type === "function") : [], signal);
+          checkAbort(signal);
+          f = open2.first.value?.error;
+        } else {
+          f = failure(res.status, (await res.text()).slice(0, 1 << 20));
+          checkAbort(signal);
+        }
+        if (f) {
+          call.abort();
+          try {
+            if (open2) await open2.it.return?.();
+            else if (!res.bodyUsed) await res.body?.cancel();
+          } catch (e) {
+            if (e !== call.signal.reason) throw e;
+          }
+          checkAbort(signal);
+        } else task.answered = true;
+        if (!f?.queue || waited >= QUEUE.recoveries) {
+          const result = f ? errorResponse(f) : await answer(open2, chatBody, servedName, signal);
+          checkAbort(signal);
+          return result;
+        }
+        if (!await queueWait(api, cred, ask, f.queue, signal, deadline, site)) {
+          checkAbort(signal);
+          return errorResponse(f);
+        }
+        checkAbort(signal);
+      }
+    } catch (e) {
+      checkAbort(signal);
+      return signedInError(e);
+    }
+  };
+  return {
+    connectPAT,
+    refresh,
+    models,
+    chat,
+    usage,
+    dispose() {
+      listings.clear();
+      spent.clear();
+      TASKS.clear();
+    },
+    _internal: {
+      cosyHeaders,
+      userBlob,
+      machineOS,
+      encodeBody,
+      decodeBody,
+      segmentEncode,
+      swapThirds,
+      qoderBody,
+      qoderMessages,
+      cacheMarked,
+      sessionOf,
+      taskOf,
+      failure,
+      errorResponse,
+      parseUsage,
+      modelInfo,
+      typedUnions,
+      events,
+      QUEUE,
+      SITES,
+      site
+    }
+  };
+}
+
+// src/protocol.ts
+var CHAT_PATH = "/algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1";
+var QODER_SITES = Object.freeze([
+  {
+    id: "qoder",
+    label: "Qoder",
+    openapi: "https://openapi.qoder.sh",
+    api: "https://api3.qoder.sh",
+    web: "https://qoder.com",
+    chatUrl: `https://api3.qoder.sh${CHAT_PATH}`,
+    provider: "qoder-subscription",
+    marker: "ccr-managed-qoder",
+    credentialFile: "qoder-credentials.json",
+    routeBase: "/api/qoder"
+  },
+  {
+    id: "qoder-cn",
+    label: "Qoder CN",
+    openapi: "https://openapi.qoder.com.cn",
+    api: "https://gateway.qoder.com.cn",
+    web: "https://qoder.cn",
+    chatUrl: `https://gateway.qoder.com.cn${CHAT_PATH}`,
+    provider: "qoder-cn-subscription",
+    marker: "ccr-managed-qoder-cn",
+    credentialFile: "qoder-cn-credentials.json",
+    routeBase: "/api/qoder/cn"
+  }
+]);
+var QODER_CHAT = QODER_SITES[0].chatUrl;
+var QODER_PROVIDER = QODER_SITES[0].provider;
+var QODER_MARKER = QODER_SITES[0].marker;
+function qoderSite(site) {
+  return QODER_SITES.find((s) => s.id === site) ?? QODER_SITES[0];
+}
+function qoderError(code, status = 422) {
+  return Object.assign(new Error(code), { code, statusCode: status, nonRetryable: true });
+}
+function isQoderManaged(p, site = "qoder") {
+  const managedBy = qoderSite(site);
+  const name = p?.name;
+  const owner = typeof name === "string" ? QODER_SITES.find((s) => s.provider === name) : void 0;
+  if (owner) {
+    return owner.id === managedBy.id && (p?.qoder_managed === true || p?.qoderManaged === true || (p?.api_key ?? p?.apiKey) === managedBy.marker);
+  }
+  if (managedBy.id !== QODER_SITES[0].id) return false;
+  return p?.qoder_managed === true || p?.qoderManaged === true;
+}
+function lockQoderProvider(p, site = "qoder") {
+  const managedBy = qoderSite(site);
+  return {
+    ...p,
+    name: managedBy.provider,
+    qoder_managed: true,
+    qoderManaged: true,
+    api_base_url: managedBy.chatUrl,
+    api_key: managedBy.marker,
+    transformer: { use: [managedBy.id] }
+  };
+}
+function protectQoderConfig(next, previous) {
+  if (!next || typeof next !== "object") return;
+  const key = Array.isArray(next?.providers) && !Array.isArray(next?.Providers) ? "providers" : "Providers";
+  const old = previous?.Providers ?? previous?.providers ?? [];
+  const list = Array.isArray(next[key]) ? next[key] : [];
+  next[key] = list.map((p) => {
+    for (const managedBy of QODER_SITES) {
+      const previousEntry = old.find((o) => isQoderManaged(o, managedBy.id));
+      if (isQoderManaged(p, managedBy.id) || previousEntry && p?.name === managedBy.provider) {
+        return lockQoderProvider(p, managedBy.id);
+      }
+    }
+    return p;
+  });
+  for (const managedBy of QODER_SITES) {
+    const previousEntry = old.find((o) => isQoderManaged(o, managedBy.id));
+    if (previousEntry && !next[key].some((p) => isQoderManaged(p, managedBy.id))) {
+      next[key].push(lockQoderProvider(previousEntry, managedBy.id));
+    }
+  }
+}
+var configWriteQueues = /* @__PURE__ */ new Map();
+function serializeQoderConfigWrite(configDir, fn) {
+  const previous = configWriteQueues.get(configDir) ?? Promise.resolve();
+  const job = previous.then(fn, fn);
+  configWriteQueues.set(configDir, job.catch(() => {
+  }));
+  return job;
+}
+var RETRY_AFTER_MIN_MS = 3e4;
+var RETRY_AFTER_MAX_MS = 30 * 6e4;
+var DEFAULT_429_COOLDOWN_MS = 3e5;
+function classifyQoderError(status, body) {
+  if (status === 0) return { code: "qoder_upstream_error", message: "qoder_upstream_error", httpStatus: 502, retryable: true };
+  let hint = body;
+  if (typeof body === "string") {
+    try {
+      hint = JSON.parse(body);
+    } catch {
+      hint = void 0;
+    }
+  }
+  if (status === 401) return { code: "qoder_reauth_required", message: "qoder_reauth_required", httpStatus: 401, retryable: false };
+  if (status === 429) {
+    const seconds = Number(hint?.retry_after);
+    const cooldownMs = Number.isFinite(seconds) && seconds > 0 ? Math.min(Math.max(seconds * 1e3, RETRY_AFTER_MIN_MS), RETRY_AFTER_MAX_MS) : DEFAULT_429_COOLDOWN_MS;
+    return { code: "qoder_rate_limited", message: "qoder_rate_limited", httpStatus: 429, cooldownMs, retryable: false };
+  }
+  return {
+    code: "qoder_upstream_error",
+    message: "qoder_upstream_error",
+    httpStatus: status,
+    retryable: status >= 500
+  };
+}
+function isQoderErrorEnvelope(body) {
+  return body?.error?.type === "qoder_error";
+}
+function validPAT(value) {
+  return typeof value === "string" && value.startsWith("pt-") && value.length <= 4096 && !/[\x00-\x1f\x7f]/.test(value);
+}
+
+// src/auth-service.ts
+var REFRESH_LEAD_MS = 5 * 6e4;
+var USAGE_CACHE_MS = 6e4;
+var COOLDOWN_CAP_MS = 36e5;
+var DEFAULT_429_COOLDOWN_MS2 = 3e5;
+var FILE_MAX_BYTES = 1048576;
+var field = (v, max) => typeof v === "string" && v.length > 0 && v.length <= max && !/[\x00-\x1f]/.test(v);
+var softField = (v, max) => typeof v === "string" && v.length <= max;
+var validModels = (v) => Array.isArray(v) && v.length <= 2048 && v.every((m) => field(m, 256));
+var validModelRecords = (v) => Array.isArray(v) && v.length <= 512 && v.every((m) => m != null && typeof m === "object" && field(m.key, 256) && softField(m.name, 256) && typeof m.context === "number" && Number.isFinite(m.context) && m.context >= 0 && typeof m.free === "boolean");
+function validate(value) {
+  const c = value?.credential;
+  if (value?.version !== 1 || !c || typeof c !== "object" || !field(c.access, 32768) || !softField(c.refresh, 32768) || !Number.isFinite(c.expires) || !field(c.uid, 256) || !softField(c.email, 1024) || !softField(c.name, 1024) || !field(c.accountId, 256) || !field(c.machineId, 128) || !validPAT(c.pat) || !validModelRecords(value.models) || !validModels(value.hiddenModels)) throw qoderError("qoder_credential_invalid");
+  return {
+    version: 1,
+    credential: {
+      access: c.access,
+      refresh: c.refresh,
+      expires: c.expires,
+      uid: c.uid,
+      email: c.email,
+      name: c.name,
+      accountId: c.accountId,
+      machineId: c.machineId,
+      pat: c.pat
+    },
+    models: value.models.map((m) => ({ key: m.key, name: m.name, context: m.context, free: m.free })),
+    hiddenModels: [...new Set(value.hiddenModels)]
+  };
+}
+function maskEmail(email) {
+  if (!email) return null;
+  const at = email.indexOf("@");
+  if (at <= 0) return null;
+  return `${email[0]}***${email.slice(at)}`;
+}
+function toRecord(m) {
+  return { key: String(m.key), name: String(m.name ?? m.key), context: Number(m.context) || 0, free: m.free === true };
+}
+var QoderAuthService = class {
+  constructor(options) {
+    this.options = options;
+    this.site = qoderSite(options.site);
+    const network = options.fetch ?? ((input, init) => fetch(input, init));
+    const hostFetch = (input, init) => network(input, {
+      ...init,
+      redirect: "error",
+      dispatcher: options.host.getSubscriptionDispatcher?.() ?? options.host.getDirectDispatcher()
+    });
+    this.engine = options.engine ?? createQoderEngine({
+      fetch: hostFetch,
+      // The engine cannot know the host's connection generation, but a
+      // rotation preserves the credential machineId while every new PAT
+      // connect generates one. The bound machineId inside the rotated
+      // credential therefore identifies its originating connection, so a
+      // rotation delivered after a disconnect+reconnect (even with the SAME
+      // PAT) cannot overwrite the new connection.
+      onRefresh: (n) => this.handleEngineRefresh(n),
+      // The engine resolves its hosts from the site (see vendor/engine.mjs).
+      site: this.site.id
+    });
+    this.file = join(options.host.configDir, this.site.credentialFile);
+  }
+  engine;
+  site;
+  file;
+  loaded;
+  saved;
+  refresh;
+  queue = Promise.resolve();
+  persistChain = Promise.resolve();
+  generation = 0;
+  disconnecting = false;
+  expired = false;
+  lastError;
+  coolingUntil = 0;
+  usage;
+  usageJob;
+  /**
+   * Persist a credential the engine rotated on its own during a request
+   * (engine options.onRefresh). Credential-only mutation (no config write),
+   * guarded by generation + uid+pat so a stale rotation after disconnect or a
+   * different account can never resurrect state. Failures are swallowed: a
+   * crash before persistence still recovers through PAT re-exchange.
+   */
+  handleEngineRefresh(next) {
+    this.persistChain = this.persistChain.then(async () => {
+      const current = this.saved;
+      if (this.disconnecting || !current || current.credential.uid !== next.uid || current.credential.pat !== next.pat || current.credential.machineId !== next.machineId) return;
+      await this.persist({ ...current, credential: next });
+      this.expired = false;
+      this.lastError = void 0;
+    }).catch(() => {
+    });
+  }
+  exclusive(fn) {
+    const job = this.queue.then(fn);
+    this.queue = job.catch(() => {
+    });
+    return job;
+  }
+  async load() {
+    this.loaded ??= (async () => {
+      let handle;
+      try {
+        handle = await open(this.file, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > FILE_MAX_BYTES) throw qoderError("qoder_credential_invalid");
+        await handle.chmod(384);
+        this.saved = validate(JSON.parse(await handle.readFile("utf8")));
+      } catch (e) {
+        if (e?.code !== "ENOENT") throw qoderError("qoder_credential_unreadable", 500);
+      } finally {
+        await handle?.close();
+      }
+    })().catch((error) => {
+      this.loaded = void 0;
+      throw error;
+    });
+    return this.loaded;
+  }
+  /** Validate and serialize before replacing the file. The loader must never
+   *  accept a state this writer created, and JSON byte growth is bounded. */
+  serializeSaved(next) {
+    const checked = validate(next);
+    const text = JSON.stringify(checked);
+    if (Buffer.byteLength(text, "utf8") > FILE_MAX_BYTES) throw qoderError("qoder_persist_failed", 500);
+    return text;
+  }
+  async persist(next) {
+    await mkdir(this.options.host.configDir, { recursive: true, mode: 448 });
+    const text = this.serializeSaved(next);
+    const temp = `${this.file}.${randomBytes(12).toString("hex")}.tmp`;
+    let handle;
+    try {
+      handle = await open(temp, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY | constants2.O_NOFOLLOW, 384);
+      await handle.writeFile(text);
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      await rename(temp, this.file);
+      this.saved = next;
+    } catch {
+      throw qoderError("qoder_persist_failed", 500);
+    } finally {
+      await handle?.close();
+      await unlink(temp).catch(() => {
+      });
+    }
+  }
+  /**
+   * The ONLY writers of durable state (grok parity): each job re-reads the
+   * latest saved state at execution time, writes config first and persists
+   * after; a persist failure after a successful config write rolls the managed
+   * entry back so config never names models the private file lost.
+   */
+  mutate(merge, writeConfig = true) {
+    const job = this.persistChain.then(async () => {
+      const current = this.saved;
+      if (!current || this.disconnecting) throw qoderError("qoder_not_connected", 409);
+      const next = merge(current);
+      if (writeConfig) {
+        await this.updateConfig(next);
+        try {
+          await this.persist(next);
+        } catch (error) {
+          await this.updateConfig(current).catch(() => {
+          });
+          throw error;
+        }
+      } else {
+        await this.persist(next);
+      }
+    });
+    this.persistChain = job.catch(() => {
+    });
+    return job;
+  }
+  async rawConfig() {
+    if (!this.options.host.readRawConfig) throw qoderError("qoder_raw_config_required", 500);
+    return structuredClone(await this.options.host.readRawConfig());
+  }
+  async updateConfig(saved) {
+    await serializeQoderConfigWrite(this.options.host.configDir, async () => {
+      const cfg = await this.rawConfig();
+      const before = structuredClone(cfg);
+      const key = Array.isArray(cfg.providers) && !Array.isArray(cfg.Providers) ? "providers" : "Providers";
+      const list = cfg[key] ?? [];
+      const at = list.findIndex((p) => isQoderManaged(p, this.site.id));
+      if (saved) {
+        if (at < 0 && list.some((p) => p?.name === this.site.provider)) throw qoderError("qoder_provider_name_conflict");
+        const provider = lockQoderProvider({
+          ...at >= 0 ? list[at] : {},
+          models: saved.models.filter((m) => !saved.hiddenModels.includes(m.key)).map((m) => m.key),
+          enabled: at >= 0 ? list[at].enabled !== false : true
+        }, this.site.id);
+        if (at >= 0) list[at] = provider;
+        else list.push(provider);
+      } else if (at >= 0) list.splice(at, 1);
+      cfg[key] = list;
+      try {
+        await this.options.host.writeConfig(cfg);
+        await this.options.host.reloadRuntime(cfg);
+      } catch {
+        await this.options.host.writeConfig(before).then(() => this.options.host.reloadRuntime(before)).catch(() => {
+        });
+        throw qoderError("qoder_config_write_failed", 500);
+      }
+    });
+  }
+  /** Exchange a PAT for a job token: persist FIRST, then config, rollback on failure. */
+  async connectPAT(pat) {
+    return this.exclusive(async () => {
+      await this.load();
+      if (this.saved) throw qoderError("qoder_already_connected", 409);
+      if (!validPAT(pat)) throw qoderError("qoder_pat_invalid", 422);
+      let credential;
+      try {
+        credential = await this.engine.connectPAT(pat);
+      } catch (e) {
+        if (e?.code) throw e;
+        throw qoderError("qoder_upstream_error", 502);
+      }
+      const next = { version: 1, credential, models: [], hiddenModels: [] };
+      await this.persist(next);
+      try {
+        await this.updateConfig(next);
+      } catch (e) {
+        await rm(this.file, { force: true });
+        this.saved = void 0;
+        throw e;
+      }
+      this.expired = false;
+      this.lastError = void 0;
+      this.coolingUntil = 0;
+      return { success: true };
+    });
+  }
+  /**
+   * Single-flight job-token refresh (contract): rotated credentials persist
+   * through the mutate chain; a refresh that lands after a disconnect (or any
+   * generation bump) is discarded WITHOUT latching reauth. The engine's own
+   * PAT re-exchange recovery clears the expired latch on success.
+   */
+  async forceTokenRefresh() {
+    await this.load();
+    if (!this.saved || this.disconnecting) throw qoderError("qoder_not_connected", 409);
+    if (this.refresh) return this.refresh;
+    const saved = this.saved, generation = this.generation;
+    this.refresh = (async () => {
+      try {
+        const c = await this.engine.refresh(saved.credential);
+        if (generation !== this.generation || this.saved?.credential.machineId !== saved.credential.machineId || this.disconnecting) {
+          throw qoderError("qoder_not_connected", 409);
+        }
+        await this.mutate((current) => ({ ...current, credential: c }), false);
+        this.expired = false;
+        this.lastError = void 0;
+      } catch (error) {
+        if (generation !== this.generation || this.disconnecting || !this.saved) throw qoderError("qoder_not_connected", 409);
+        if (error?.expired === true) {
+          this.expired = true;
+          this.lastError = "qoder_reauth_required";
+          throw qoderError("qoder_reauth_required", 401);
+        }
+        if (["qoder_persist_failed", "qoder_credential_invalid", "qoder_raw_config_required", "qoder_proxy_invalid"].includes(error?.code)) {
+          this.lastError = "qoder_upstream_error";
+          throw error;
+        }
+        this.lastError = "qoder_upstream_error";
+        throw qoderError("qoder_upstream_error", 502);
+      } finally {
+        this.refresh = void 0;
+      }
+    })();
+    return this.refresh;
+  }
+  /** Circuit breaker BEFORE any refresh/network work (Gemini lesson, contract). */
+  async ensureUsable() {
+    await this.load();
+    if (!this.saved || this.disconnecting) throw qoderError("qoder_not_connected", 409);
+    if (this.coolingUntil > Date.now()) throw qoderError("qoder_rate_limited", 429);
+    if (this.expired) throw qoderError("qoder_reauth_required", 401);
+  }
+  /** Credential with the engine's refresh lead applied; single-flight coalesces callers. */
+  async waitWithSignal(work, signal) {
+    if (!signal) return work;
+    if (signal.aborted) throw Object.assign(new Error("aborted"), { name: "AbortError" });
+    return await new Promise((resolve, reject) => {
+      const stop = () => reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+      signal.addEventListener("abort", stop, { once: true });
+      work.then(
+        (value) => {
+          signal.removeEventListener("abort", stop);
+          resolve(value);
+        },
+        (error) => {
+          signal.removeEventListener("abort", stop);
+          reject(error);
+        }
+      );
+    });
+  }
+  /** Credential with the engine's refresh lead applied; the shared rotation
+   *  may continue after this caller stops waiting, so a token is never lost. */
+  async freshCredential(signal) {
+    await this.load();
+    if (!this.saved || this.disconnecting) throw qoderError("qoder_not_connected", 409);
+    if (this.saved.credential.expires - Date.now() < REFRESH_LEAD_MS) {
+      await this.waitWithSignal(this.forceTokenRefresh(), signal);
+    }
+    return this.saved.credential;
+  }
+  /** One bounded engine chat transaction for the managed runtime's dispatchRequest. */
+  async dispatch(chatBody, signal) {
+    await this.ensureUsable();
+    const cred = await this.freshCredential(signal);
+    const session = typeof chatBody?.prompt_cache_key === "string" && chatBody.prompt_cache_key ? chatBody.prompt_cache_key : "";
+    return this.engine.chat(cred, chatBody, { session, signal });
+  }
+  async syncModels() {
+    return this.exclusive(async () => {
+      const cred = await this.freshCredential();
+      let listing;
+      try {
+        listing = await this.engine.models(cred, true);
+      } catch (error) {
+        if (error?.expired === true) {
+          this.expired = true;
+          this.lastError = "qoder_reauth_required";
+          throw qoderError("qoder_reauth_required", 401);
+        }
+        if (error?.code) throw error;
+        throw qoderError("qoder_upstream_error", 502);
+      }
+      const models = (Array.isArray(listing) ? listing : []).map(toRecord).filter((m) => m.key && !["auto", "default"].includes(m.key)).slice(0, 512);
+      if (!models.length) throw qoderError("qoder_upstream_error");
+      this.noteUpstreamSuccess();
+      await this.mutate((current) => ({ ...current, models }));
+      return { success: true, models: models.map((m) => m.key), modelCount: models.length };
+    });
+  }
+  async setModelHidden(key, hidden) {
+    return this.exclusive(async () => {
+      await this.load();
+      if (!this.saved || this.disconnecting) throw qoderError("qoder_not_connected", 409);
+      if (typeof key !== "string" || !this.saved.models.some((m) => m.key === key)) throw qoderError("qoder_model_unknown");
+      await this.mutate((current) => ({
+        ...current,
+        hiddenModels: [.../* @__PURE__ */ new Set([...current.hiddenModels.filter((m) => m !== key), ...hidden ? [key] : []])]
+      }));
+      return { success: true };
+    });
+  }
+  async getUsage() {
+    await this.load();
+    if (!this.saved || this.disconnecting) throw qoderError("qoder_not_connected", 409);
+    const snapshot = () => this.usage ? { ...this.usage, stale: Date.now() - this.usage.observedAt > USAGE_CACHE_MS, coolingUntil: this.coolingUntil || void 0 } : { known: false, stale: false, windows: [], coolingUntil: this.coolingUntil || void 0 };
+    if (this.usage && Date.now() - this.usage.observedAt < USAGE_CACHE_MS) return snapshot();
+    if (this.usageJob) return this.usageJob;
+    this.usageJob = (async () => {
+      try {
+        const cred = await this.freshCredential();
+        const result = await this.engine.usage(cred);
+        if (!result || result.error || !Array.isArray(result.windows)) throw 0;
+        this.noteUpstreamSuccess();
+        this.usage = { known: true, stale: false, observedAt: Date.now(), windows: result.windows, plan: result.plan, until: result.until };
+      } catch {
+        return snapshot();
+      }
+      return snapshot();
+    })().finally(() => {
+      this.usageJob = void 0;
+    });
+    return this.usageJob;
+  }
+  /**
+   * Latched state heals ONLY per contract: success clears cooling + lastError,
+   * never the expired latch — that one clears solely through a successful
+   * engine refresh (PAT re-exchange) or an explicit reconnect.
+   */
+  noteUpstreamSuccess() {
+    this.lastError = void 0;
+    this.coolingUntil = 0;
+  }
+  async noteUpstreamError(info) {
+    if (info.code === "qoder_reauth_required" || info.httpStatus === 401) {
+      this.expired = true;
+      this.lastError = "qoder_reauth_required";
+      return;
+    }
+    this.lastError = ["qoder_rate_limited", "qoder_upstream_error"].includes(info.code) ? info.code : "qoder_upstream_error";
+    if (info.code === "qoder_rate_limited") {
+      this.coolingUntil = Date.now() + Math.min(Math.max(info.cooldownMs ?? DEFAULT_429_COOLDOWN_MS2, 0), COOLDOWN_CAP_MS);
+    }
+  }
+  async getStatus() {
+    await this.load();
+    const saved = this.saved;
+    const models = (saved?.models ?? []).map((m) => ({
+      id: m.key,
+      name: m.name,
+      context: m.context,
+      free: m.free,
+      hidden: saved.hiddenModels.includes(m.key)
+    }));
+    return {
+      status: saved ? "connected" : "not_connected",
+      providerName: this.site.provider,
+      account: saved ? maskEmail(saved.credential.email) ?? maskEmail(saved.credential.accountId) ?? void 0 : void 0,
+      models,
+      modelCount: models.length,
+      ...this.coolingUntil > Date.now() ? { coolingUntil: this.coolingUntil } : {},
+      ...this.expired ? { expired: true } : {},
+      ...this.lastError ? { lastError: this.lastError } : {}
+    };
+  }
+  async disconnect() {
+    return this.exclusive(async () => {
+      await this.load().catch(() => {
+      });
+      this.disconnecting = true;
+      this.generation++;
+      await this.refresh?.catch(() => {
+      });
+      await this.usageJob?.catch(() => {
+      });
+      await this.persistChain.catch(() => {
+      });
+      try {
+        await this.updateConfig();
+      } catch (e) {
+        this.disconnecting = false;
+        throw e;
+      }
+      await rm(this.file, { force: true });
+      this.saved = void 0;
+      try {
+        this.engine.dispose();
+      } catch {
+      }
+      this.usage = void 0;
+      this.expired = false;
+      this.lastError = void 0;
+      this.coolingUntil = 0;
+      this.disconnecting = false;
+      return { success: true };
+    });
+  }
+};
+
+// src/transformer.ts
+function qoderRequest(request, context) {
+  const body = structuredClone(request ?? {});
+  const reasoning = body.reasoning;
+  delete body.system;
+  delete body.reasoning;
+  delete body.prompt_cache_key;
+  body.messages = (request?.messages ?? []).map((message) => {
+    const { thinking, ...next } = message;
+    delete next.thinking;
+    if (thinking && typeof thinking.content === "string" && thinking.content) next.reasoning_content = thinking.content;
+    else if (typeof next.reasoning_content !== "string" || !next.reasoning_content) delete next.reasoning_content;
+    return next;
+  });
+  if (request?.system) {
+    const text = typeof request.system === "string" ? request.system : Array.isArray(request.system) ? request.system.filter((p) => p?.type === "text").map((p) => p.text).join("\n") : "";
+    if (text) body.messages.unshift({ role: "system", content: text });
+  }
+  const session = request?.prompt_cache_key ?? context?.req?.clientContext?.stableSessionId;
+  if (typeof session === "string" && session && session.length <= 1024) body.prompt_cache_key = session;
+  if (reasoning?.effort) body.reasoning_effort = reasoning.effort;
+  return body;
+}
+function mapMessage(message) {
+  if (!message || typeof message !== "object") return;
+  if (typeof message.reasoning_content === "string") {
+    message.thinking = { content: message.reasoning_content };
+    delete message.reasoning_content;
+  }
+}
+function mapUsage(usage) {
+  if (!usage || typeof usage !== "object") return;
+  const cached = usage.prompt_tokens_details?.cached_tokens;
+  const written = usage.prompt_tokens_details?.cache_write_tokens;
+  if (Number.isFinite(usage.prompt_tokens) && Number.isFinite(cached) && Number.isFinite(written) && usage.prompt_tokens < cached + written) usage.prompt_tokens += cached + written;
+  if (Number.isFinite(written)) usage.cache_creation_input_tokens = written;
+}
+function frameInfo(raw) {
+  const status = Number(raw?.code ?? raw?.status ?? 0);
+  const text = `${raw?.message ?? ""} ${raw?.type ?? ""}`.toLowerCase();
+  if (status === 429 || /rate.?limit|usage.?limit|quota/.test(text)) {
+    const seconds = Number(raw?.retry_after);
+    return {
+      code: "qoder_rate_limited",
+      httpStatus: 429,
+      cooldownMs: Number.isFinite(seconds) && seconds > 0 ? Math.min(Math.max(seconds * 1e3, 3e4), 30 * 6e4) : 3e5
+    };
+  }
+  if (status === 401 || /unauthorized|invalid.?token|authentication|sign.?in/.test(text)) {
+    return { code: "qoder_reauth_required", httpStatus: 401 };
+  }
+  return { code: "qoder_upstream_error", httpStatus: status >= 400 && status <= 599 ? status : 502 };
+}
+function mapChunk(event) {
+  if (event?.error) {
+    const info = frameInfo(event.error);
+    throw Object.assign(new Error(info.code), {
+      code: info.code,
+      statusCode: info.httpStatus,
+      nonRetryable: true,
+      ...info.cooldownMs ? { cooldownMs: info.cooldownMs } : {}
+    });
+  }
+  for (const c of event?.choices ?? []) {
+    mapMessage(c.message);
+    mapMessage(c.delta);
+  }
+  mapUsage(event?.usage);
+  return event;
+}
+function fire(callback, ...args) {
+  try {
+    const noted = callback?.(...args);
+    if (noted && typeof noted.then === "function") noted.then(void 0, () => {
+    });
+  } catch {
+  }
+}
+async function qoderResponse(response, note, heal) {
+  if (!response.ok) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const info = classifyQoderError(response.status, body);
+    await response.body?.cancel().catch(() => {
+    });
+    throw Object.assign(new Error(info.code), {
+      code: info.code,
+      statusCode: info.httpStatus,
+      nonRetryable: !info.retryable,
+      ...info.cooldownMs ? { cooldownMs: info.cooldownMs } : {}
+    });
+  }
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  if (!headers.get("content-type")?.includes("text/event-stream")) {
+    let event;
+    try {
+      event = mapChunk(await response.json());
+    } catch (error) {
+      throw error?.code ? error : qoderError("qoder_upstream_error", 502);
+    }
+    const message = event?.choices?.[0]?.message;
+    if (!message || !(message.content || message.tool_calls?.length)) throw qoderError("qoder_upstream_error", 502);
+    fire(heal);
+    return Response.json(event, { headers });
+  }
+  if (!response.body) throw qoderError("qoder_stream_truncated", 502);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const encoder = new TextEncoder();
+  let pending = "", done = false, finished = false, visible = false, healed = false;
+  let pendingBytes = 0;
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        while (true) {
+          const boundary = /\r\n\r\n|\n\n|\r\r/.exec(pending);
+          if (boundary) {
+            const raw = pending.slice(0, boundary.index);
+            const frameBytes = encoder.encode(raw).byteLength;
+            if (frameBytes > 1048576) throw qoderError("qoder_stream_invalid", 502);
+            pending = pending.slice(boundary.index + boundary[0].length);
+            pendingBytes -= frameBytes + boundary[0].length;
+            const data = raw.split(/\r\n|\n|\r/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart()).join("\n");
+            if (!data) continue;
+            if (data === "[DONE]") {
+              if (!finished || !visible) throw qoderError("qoder_stream_truncated", 502);
+              done = true;
+              if (!healed) {
+                healed = true;
+                fire(heal);
+              }
+              await reader.cancel();
+              controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+              controller.close();
+              return;
+            }
+            let event;
+            try {
+              event = mapChunk(JSON.parse(data));
+            } catch (error) {
+              if (error?.code === "qoder_rate_limited" || error?.code === "qoder_reauth_required" || error?.code === "qoder_upstream_error") {
+                fire(note, {
+                  code: error.code,
+                  httpStatus: error.statusCode,
+                  ...error.cooldownMs ? { cooldownMs: error.cooldownMs } : {}
+                });
+              }
+              throw error;
+            }
+            for (const c of event.choices ?? []) {
+              const reasoningVisible = typeof c.delta?.reasoning_content === "string" && c.delta.reasoning_content.length > 0;
+              if (reasoningVisible || c.delta?.content || c.delta?.tool_calls?.length) visible = true;
+              if (c.finish_reason) finished = true;
+            }
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}
+
+`));
+            return;
+          }
+          if (pending.length > 1048576) throw qoderError("qoder_stream_invalid", 502);
+          const next = await reader.read();
+          if (next.done) {
+            pending += decoder.decode();
+            if (!done) throw qoderError("qoder_stream_truncated", 502);
+            controller.close();
+            return;
+          }
+          pending += decoder.decode(next.value, { stream: true });
+          pendingBytes += next.value.byteLength;
+          if (pendingBytes > 2097152) throw qoderError("qoder_stream_invalid", 502);
+        }
+      } catch (error) {
+        await reader.cancel().catch(() => {
+        });
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+  return new Response(stream, { headers });
+}
+var QoderTransformer = class {
+  constructor(engine, note, heal) {
+    this.engine = engine;
+    this.note = note;
+    this.heal = heal;
+  }
+  static TransformerName = "qoder";
+  name = "qoder";
+  async transformRequestIn(request, _provider, context) {
+    return { body: qoderRequest(request, context) };
+  }
+  async transformResponseOut(response) {
+    return qoderResponse(response, this.note, this.heal);
+  }
+};
+
+// src/managed-runtime.ts
+async function chatFailure(response) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+  }
+  const info = classifyQoderError(response.status, body);
+  return Object.assign(new Error(info.code), {
+    code: info.code,
+    message: info.code,
+    statusCode: info.httpStatus,
+    pluginClassified: true,
+    nonRetryable: !info.retryable,
+    ...info.cooldownMs ? { cooldownMs: info.cooldownMs } : {}
+  });
+}
+function classifiedInfo(error) {
+  if (!error?.pluginClassified) return null;
+  return {
+    code: String(error.code ?? "qoder_upstream_error"),
+    message: String(error.message ?? error.code ?? "qoder_upstream_error"),
+    httpStatus: Number(error.statusCode) || 502,
+    ...Number.isFinite(error.cooldownMs) ? { cooldownMs: error.cooldownMs } : {}
+  };
+}
+function streamError(error, aborted) {
+  if (aborted || error instanceof Error && error.name === "AbortError") {
+    return Object.assign(new Error(error instanceof Error ? error.message : "aborted"), { name: "AbortError" });
+  }
+  return qoderError("qoder_upstream_error", 502);
+}
+function createQoderManagedRuntime(service, host, site = "qoder", timeoutMs = 6e5) {
+  const managedBy = qoderSite(site);
+  return {
+    // Name = site id: the core keys runtimes (and 401 bookkeeping) by it.
+    name: managedBy.id,
+    isManaged: (provider) => isQoderManaged(provider, managedBy.id),
+    suppressDebugLog: true,
+    ensureUsable: () => service.ensureUsable(),
+    lockUpstream: async (config) => {
+      config.url = managedBy.chatUrl;
+      config.redirect = "error";
+      config.dispatcher = host.getSubscriptionDispatcher?.() ?? host.getDirectDispatcher();
+    },
+    // COSY signing happens inside the vendored engine's chat(); the core's
+    // header chain carries nothing provider-specific.
+    signRequest: async () => ({}),
+    classifyError: (status, body) => classifyQoderError(status, body),
+    // Secondary net for HTTP-200 hidden error envelopes (host contract types.ts).
+    isErrorEnvelope: (body) => isQoderErrorEnvelope(body),
+    noteUpstreamError: (info) => service.noteUpstreamError(info),
+    // The core owns exactly one data-plane 401 replay; the engine owns the rest.
+    authRefresh: { forceRefresh: () => service.forceTokenRefresh() },
+    // No core attempt(): that would send the marker credential to the SSE API.
+    // The vendored engine owns one bounded chat transaction (queue wait and
+    // this wrapper owns exactly one bounded 401 force-refresh/replay).
+    async dispatchRequest({ requestBody, config, req }) {
+      const controller = new AbortController();
+      const abort = () => controller.abort();
+      const socket = req?.raw?.socket;
+      req?.raw?.on?.("aborted", abort);
+      socket?.on?.("close", abort);
+      if (req?.raw?.aborted) controller.abort();
+      const deadline = Number(config?.TIMEOUT ?? timeoutMs);
+      const signal = AbortSignal.any([
+        controller.signal,
+        AbortSignal.timeout(Number.isFinite(deadline) && deadline > 0 ? Math.min(deadline, 36e5) : timeoutMs),
+        ...config?.signal instanceof AbortSignal ? [config.signal] : [],
+        ...req?.signal instanceof AbortSignal ? [req.signal] : []
+      ]);
+      const cleanup = () => {
+        req?.raw?.off?.("aborted", abort);
+        socket?.off?.("close", abort);
+      };
+      const send = async () => service.dispatch(requestBody, signal);
+      const wrap = (response) => {
+        if (!response.body) {
+          cleanup();
+          return response;
+        }
+        const reader = response.body.getReader();
+        return new Response(new ReadableStream({
+          async pull(ctl) {
+            try {
+              const next = await reader.read();
+              if (next.done) {
+                cleanup();
+                ctl.close();
+              } else ctl.enqueue(next.value);
+            } catch (error) {
+              cleanup();
+              ctl.error(streamError(error, signal.aborted));
+            }
+          },
+          async cancel(reason) {
+            abort();
+            cleanup();
+            await reader.cancel(reason).catch(() => {
+            });
+          }
+        }), { status: response.status, statusText: response.statusText, headers: response.headers });
+      };
+      try {
+        let response = await send();
+        if (response.status === 401) {
+          await response.body?.cancel().catch(() => {
+          });
+          await service.forceTokenRefresh();
+          response = await send();
+        }
+        if (!response.ok) {
+          const error = await chatFailure(response);
+          const info = classifiedInfo(error);
+          if (info) await service.noteUpstreamError(info).catch(() => {
+          });
+          throw error;
+        }
+        return wrap(response);
+      } catch (error) {
+        cleanup();
+        if (signal.aborted || error?.name === "AbortError") {
+          throw Object.assign(new Error(error?.message ?? "aborted"), { name: "AbortError" });
+        }
+        const info = classifiedInfo(error);
+        if (info) await service.noteUpstreamError(info).catch(() => {
+        });
+        throw error?.pluginClassified ? error : Object.assign(qoderError("qoder_upstream_error", 502), { pluginClassified: true });
+      }
+    }
+  };
+}
+
+// src/admin-routes.ts
+function assertLocalQoderRequest(req, app) {
+  const deny = () => {
+    throw Object.assign(new Error("qoder_unauthorized"), { statusCode: 403 });
+  };
+  const remote = req.raw?.socket?.remoteAddress ?? req.socket?.remoteAddress ?? req.connection?.remoteAddress ?? req.ip;
+  if (!["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(remote)) deny();
+  const address = app.server.address();
+  const port = address && typeof address === "object" ? address.port : 3456;
+  const allowed = /* @__PURE__ */ new Set([`localhost:${port}`, `127.0.0.1:${port}`, `[::1]:${port}`]);
+  if (typeof req.headers?.host !== "string" || !allowed.has(req.headers.host)) deny();
+  if (req.headers.origin !== void 0) {
+    try {
+      const origin = new URL(req.headers.origin);
+      if (!["http:", "https:"].includes(origin.protocol) || origin.username || origin.password || !allowed.has(origin.host)) deny();
+    } catch {
+      deny();
+    }
+  }
+}
+function registerQoderAdminRoutes(app, service, site = "qoder") {
+  const routeBase = qoderSite(site).routeBase;
+  const routes = [
+    ["GET", "status", () => service.getStatus()],
+    ["POST", "connect", (body) => {
+      if (!validPAT(body?.pat)) throw Object.assign(new Error(), { code: "qoder_pat_invalid", statusCode: 422 });
+      return service.connectPAT(body.pat);
+    }],
+    ["POST", "sync", () => service.syncModels()],
+    ["POST", "usage", () => service.getUsage()],
+    ["POST", "models/visibility", (body) => {
+      if (typeof body?.model !== "string" || typeof body.hidden !== "boolean") throw Object.assign(new Error(), { code: "qoder_model_unknown", statusCode: 422 });
+      return service.setModelHidden(body.model, body.hidden);
+    }],
+    ["POST", "disconnect", () => service.disconnect()]
+  ];
+  const safe = /* @__PURE__ */ new Set(["qoder_unauthorized", "qoder_pat_invalid", "qoder_already_connected", "qoder_not_connected", "qoder_reauth_required", "qoder_persist_failed", "qoder_config_write_failed", "qoder_provider_name_conflict", "qoder_credential_invalid", "qoder_credential_unreadable", "qoder_raw_config_required", "qoder_proxy_invalid", "qoder_upstream_error", "qoder_rate_limited", "qoder_request_failed", "qoder_model_unknown"]);
+  for (const [method, path, action] of routes) app.route({ method, url: `${routeBase}/${path}`, handler: async (req, reply) => {
+    try {
+      assertLocalQoderRequest(req, app);
+      return await action(req.body);
+    } catch (e) {
+      const unauthorized = e?.statusCode === 403;
+      const code = unauthorized ? "qoder_unauthorized" : safe.has(e?.code) ? e.code : "qoder_request_failed";
+      const status = unauthorized ? 403 : Number.isInteger(e?.statusCode) && e.statusCode !== 401 && e.statusCode >= 400 && e.statusCode <= 599 ? e.statusCode : 500;
+      reply.status(status);
+      return { success: false, error: code };
+    }
+  } });
+}
+
+// src/locales.ts
+var qoderLocales = {
+  en: { qoder: {
+    title: "Qoder Subscription",
+    description: "Connects a qoder.com personal access token (PAT). Tokens stay on this machine, are never logged and are cleared from the form after connecting.",
+    cnTitle: "Qoder CN Subscription",
+    cnDescription: "Connects a qoder.cn (Qoder China) personal access token (PAT). Tokens stay on this machine, are never logged and are cleared from the form after connecting.",
+    loading: "Loading\u2026",
+    not_connected: "Not connected",
+    connected: "Connected",
+    expired: "Sign-in lapsed \u2014 reconnect with a fresh PAT",
+    error: "Management request failed",
+    account: "Account",
+    models: "Models",
+    models_count: "{{count}} models",
+    pat: "Personal access token",
+    patPlaceholder: "pt-\u2026",
+    connect: "Connect",
+    sync: "Refresh models",
+    usage: "Refresh quota",
+    unknown: "Quota unknown",
+    stale: "Last known quota (stale)",
+    used: "Allowance",
+    restore_partial: "Partially completed: restored {{count}} of {{total}} models. Management request failed.",
+    hide_partial: "Partially completed: hid {{count}} of {{total}} models. Management request failed.",
+    restore_model: "Restore {{model}}",
+    disconnect: "Disconnect",
+    hide_model: "Hide {{model}}",
+    hidden_models: "Hidden models ({{count}})",
+    restore: "Restore",
+    restore_all: "Restore all",
+    cooling: "Rate limited until",
+    noModels: "Refresh models after connecting",
+    free: "free",
+    refresh: "Refresh status"
+  } },
+  zh: { qoder: {
+    title: "Qoder \u8BA2\u9605",
+    description: "\u4F7F\u7528 qoder.com \u4E2A\u4EBA\u8BBF\u95EE\u4EE4\u724C\uFF08PAT\uFF09\u8FDE\u63A5\u3002\u4EE4\u724C\u4EC5\u4FDD\u5B58\u5728\u672C\u673A\uFF0C\u4E0D\u4F1A\u88AB\u8BB0\u5F55\uFF0C\u8FDE\u63A5\u6210\u529F\u540E\u5373\u4ECE\u8868\u5355\u6E05\u9664\u3002",
+    cnTitle: "Qoder \u56FD\u5185\u7248\u8BA2\u9605",
+    cnDescription: "\u4F7F\u7528 qoder.cn\uFF08Qoder \u56FD\u5185\u7248\uFF09\u4E2A\u4EBA\u8BBF\u95EE\u4EE4\u724C\uFF08PAT\uFF09\u8FDE\u63A5\u3002\u4EE4\u724C\u4EC5\u4FDD\u5B58\u5728\u672C\u673A\uFF0C\u4E0D\u4F1A\u88AB\u8BB0\u5F55\uFF0C\u8FDE\u63A5\u6210\u529F\u540E\u5373\u4ECE\u8868\u5355\u6E05\u9664\u3002",
+    loading: "\u52A0\u8F7D\u4E2D\u2026",
+    not_connected: "\u672A\u8FDE\u63A5",
+    connected: "\u5DF2\u8FDE\u63A5",
+    expired: "\u767B\u5F55\u5DF2\u5931\u6548 \u2014 \u8BF7\u4F7F\u7528\u65B0\u7684 PAT \u91CD\u65B0\u8FDE\u63A5",
+    error: "\u7BA1\u7406\u64CD\u4F5C\u5931\u8D25",
+    account: "\u8D26\u53F7",
+    models: "\u6A21\u578B",
+    models_count: "{{count}} \u4E2A\u6A21\u578B",
+    pat: "\u4E2A\u4EBA\u8BBF\u95EE\u4EE4\u724C",
+    patPlaceholder: "pt-\u2026",
+    connect: "\u8FDE\u63A5",
+    sync: "\u5237\u65B0\u6A21\u578B",
+    usage: "\u5237\u65B0\u989D\u5EA6",
+    unknown: "\u989D\u5EA6\u672A\u77E5",
+    stale: "\u4E0A\u6B21\u989D\u5EA6\uFF08\u5DF2\u8FC7\u671F\uFF09",
+    used: "\u5DF2\u7528\u989D\u5EA6",
+    restore_partial: "\u90E8\u5206\u5B8C\u6210\uFF1A\u5DF2\u6062\u590D {{count}} \u4E2A\u6A21\u578B\uFF0C\u5171 {{total}} \u4E2A\u3002\u7BA1\u7406\u64CD\u4F5C\u5931\u8D25\u3002",
+    hide_partial: "\u90E8\u5206\u5B8C\u6210\uFF1A\u5DF2\u9690\u85CF {{count}} \u4E2A\u6A21\u578B\uFF0C\u5171 {{total}} \u4E2A\u3002\u7BA1\u7406\u64CD\u4F5C\u5931\u8D25\u3002",
+    restore_model: "\u6062\u590D {{model}}",
+    disconnect: "\u65AD\u5F00\u8FDE\u63A5",
+    hide_model: "\u9690\u85CF {{model}}",
+    hidden_models: "\u5DF2\u9690\u85CF\u6A21\u578B\uFF08{{count}}\uFF09",
+    restore: "\u6062\u590D",
+    restore_all: "\u6062\u590D\u5168\u90E8",
+    cooling: "\u9650\u6D41\u81F3",
+    noModels: "\u8FDE\u63A5\u540E\u8BF7\u5237\u65B0\u6A21\u578B",
+    free: "\u514D\u8D39",
+    refresh: "\u5237\u65B0\u72B6\u6001"
+  } }
+};
+
+// src/plugin.ts
+var manifest = { name: "qoder", version: "0.2.0", coreApi: "1", description: "Qoder (qoder.com / qoder.cn) subscription provider with PAT sign-in, model management and usage." };
+function activatedTransformer(site, service) {
+  return class ActivatedQoderTransformer extends QoderTransformer {
+    static TransformerName = site;
+    name = site;
+    constructor() {
+      super(service.engine, (info) => service.noteUpstreamError(info), () => service.noteUpstreamSuccess());
+    }
+  };
+}
+async function activate(ctx) {
+  const services = new Map(QODER_SITES.map((site) => [site.id, new QoderAuthService({ host: ctx.host, site: site.id })]));
+  for (const site of QODER_SITES) {
+    const service = services.get(site.id);
+    ctx.registerTransformer(activatedTransformer(site.id, service));
+    ctx.registerManagedRuntime(createQoderManagedRuntime(service, ctx.host, site.id));
+    ctx.registerAdminRoutes((app) => registerQoderAdminRoutes(app, service, site.id));
+  }
+  ctx.registerConfigProtector(protectQoderConfig);
+  ctx.registerUiCard({ cardPath: "card.js" });
+  ctx.registerLocales(qoderLocales);
+  ctx.log.info("qoder plugin active");
+}
+var plugin_default = { manifest, activate };
+export {
+  activate,
+  plugin_default as default,
+  manifest
+};