pi-provider-qoder 0.1.0

package/dist/index.js

@@ -0,0 +1,1530 @@
+// src/login-ui.ts
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { Container, SelectList, Text } from "@earendil-works/pi-tui";
+var _ctx;
+function setExtensionContext(ctx) {
+  _ctx = ctx;
+}
+function hasExtensionContext() {
+  return _ctx !== void 0;
+}
+async function showLoginUI() {
+  if (!_ctx) return null;
+  const ctx = _ctx;
+  return ctx.ui.custom((tui, theme, _kb, done) => {
+    const mainItems = [
+      { value: "web", label: "Browser Login", description: "Sign in via browser (OAuth device flow)" }
+    ];
+    const container = new Container();
+    const border = new DynamicBorder((s) => theme.fg("accent", s));
+    const title = new Text(theme.fg("accent", theme.bold("Qoder Login")), 1, 0);
+    const hint = new Text(theme.fg("dim", "\u2191\u2193 navigate \u2022 enter select \u2022 esc cancel"), 1, 0);
+    const borderBottom = new DynamicBorder((s) => theme.fg("accent", s));
+    const selectList = new SelectList(mainItems, mainItems.length, {
+      selectedPrefix: (t) => theme.fg("accent", t),
+      selectedText: (t) => theme.fg("accent", t),
+      description: (t) => theme.fg("muted", t),
+      scrollInfo: (t) => theme.fg("dim", t),
+      noMatch: (t) => theme.fg("warning", t)
+    });
+    selectList.onSelect = (item) => {
+      done({ method: item.value });
+    };
+    selectList.onCancel = () => done(null);
+    container.addChild(border);
+    container.addChild(title);
+    container.addChild(selectList);
+    container.addChild(hint);
+    container.addChild(borderBottom);
+    tui.requestRender();
+    return {
+      render(width) {
+        return container.render(width);
+      },
+      invalidate() {
+        container.invalidate();
+      },
+      handleInput(data) {
+        selectList.handleInput(data);
+        tui.requestRender();
+      }
+    };
+  });
+}
+async function showWaitingUI(outerCallbacks, runAuth) {
+  if (!_ctx) {
+    return runAuth(outerCallbacks);
+  }
+  const ctx = _ctx;
+  return ctx.ui.custom((tui, theme, _kb, done) => {
+    const container = new Container();
+    const border = new DynamicBorder((s) => theme.fg("accent", s));
+    const title = new Text(theme.fg("accent", theme.bold("Qoder Login - Authorization")), 1, 0);
+    const borderBottom = new DynamicBorder((s) => theme.fg("accent", s));
+    const statusText = new Text("Initiating login flow...", 1, 0);
+    const urlText = new Text("", 1, 0);
+    const instructionsText = new Text("", 1, 0);
+    const hint = new Text(theme.fg("dim", "esc cancel / back"), 1, 0);
+    container.addChild(border);
+    container.addChild(title);
+    container.addChild(statusText);
+    container.addChild(urlText);
+    container.addChild(instructionsText);
+    container.addChild(hint);
+    container.addChild(borderBottom);
+    const abortCtrl = new AbortController();
+    let onAuthCalled = false;
+    const mergedCallbacks = {
+      ...outerCallbacks,
+      onProgress: (msg) => {
+        outerCallbacks.onProgress?.(msg);
+        statusText.setText(msg);
+        tui.requestRender();
+      },
+      onAuth: (info) => {
+        if (!onAuthCalled) {
+          onAuthCalled = true;
+          outerCallbacks.onAuth?.(info);
+        }
+        urlText.setText(`URL: ${info.url}`);
+        instructionsText.setText(info.instructions || "");
+        tui.requestRender();
+      },
+      signal: abortCtrl.signal
+    };
+    runAuth(mergedCallbacks).then(
+      (creds) => {
+        done(creds);
+      },
+      (err) => {
+        if (abortCtrl.signal.aborted) {
+          done(null);
+        } else {
+          statusText.setText(theme.fg("warning", `Error: ${err.message || err}`));
+          tui.requestRender();
+          setTimeout(() => done(null), 3e3);
+        }
+      }
+    );
+    return {
+      render(width) {
+        return container.render(width);
+      },
+      invalidate() {
+        container.invalidate();
+      },
+      handleInput(data) {
+        if (data.length === 1 && data.charCodeAt(0) === 27 || data === "q") {
+          abortCtrl.abort();
+          done(null);
+        }
+      }
+    };
+  });
+}
+
+// src/models.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+
+// src/cosy.ts
+import crypto from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var qoderRSAPublicKey = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;
+var QoderIDEVersion = "1.0.0";
+var QoderClientType = "5";
+var QoderDataPolicy = "disagree";
+var QoderLoginVersion = "v2";
+var QoderMachineOS = "x86_64_windows";
+var QoderMachineTypeMagic = "5";
+function rsaEncryptBase64(data) {
+  const key = {
+    key: qoderRSAPublicKey,
+    padding: crypto.constants.RSA_PKCS1_PADDING
+  };
+  const encrypted = crypto.publicEncrypt(key, typeof data === "string" ? Buffer.from(data) : data);
+  return encrypted.toString("base64");
+}
+function aesEncryptCBCBase64(plaintext, keyStr) {
+  const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.from(keyStr), Buffer.from(keyStr));
+  let encrypted = cipher.update(plaintext, "utf8", "base64");
+  encrypted += cipher.final("base64");
+  return encrypted;
+}
+function computeSigPath(urlStr) {
+  const parsed = new URL(urlStr);
+  let sigPath = parsed.pathname;
+  if (sigPath.startsWith("/algo")) {
+    sigPath = sigPath.substring("/algo".length);
+  }
+  return sigPath;
+}
+function getMachineId() {
+  const paths = [join(homedir(), ".qoder", ".auth", "machine_id"), join(homedir(), ".pi", "agent", "qoder-machine-id")];
+  for (const p of paths) {
+    if (existsSync(p)) {
+      try {
+        const val = readFileSync(p, "utf8").trim();
+        if (val) return val;
+      } catch {
+      }
+    }
+  }
+  const newId = crypto.randomUUID();
+  try {
+    const savePath = paths[1];
+    mkdirSync(dirname(savePath), { recursive: true });
+    writeFileSync(savePath, newId, "utf8");
+  } catch {
+  }
+  return newId;
+}
+function buildAuthHeaders(body, requestURL, creds) {
+  if (!creds.userID) {
+    throw new Error("cosy: user id is empty");
+  }
+  if (!creds.authToken) {
+    throw new Error("cosy: auth token is empty");
+  }
+  const aesKey = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+  const userInfo = {
+    uid: creds.userID,
+    security_oauth_token: creds.authToken,
+    name: creds.name || "",
+    aid: "",
+    email: creds.email || ""
+  };
+  const infoB64 = aesEncryptCBCBase64(JSON.stringify(userInfo), aesKey);
+  const cosyKey = rsaEncryptBase64(aesKey);
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const requestId = crypto.randomUUID();
+  const cosyPayload = {
+    version: "v1",
+    requestId,
+    info: infoB64,
+    cosyVersion: QoderIDEVersion,
+    ideVersion: ""
+  };
+  const payloadB64 = Buffer.from(JSON.stringify(cosyPayload)).toString("base64");
+  const sigPath = computeSigPath(requestURL);
+  const bodyStr = body ? Buffer.isBuffer(body) ? body.toString("utf8") : body : "";
+  const sigInput = `${payloadB64}
+${cosyKey}
+${timestamp}
+${bodyStr}
+${sigPath}`;
+  const sig = crypto.createHash("md5").update(sigInput).digest("hex");
+  const bodyHash = crypto.createHash("md5").update(body || "").digest("hex");
+  const bodyLen = body ? (Buffer.isBuffer(body) ? body.length : Buffer.from(body).length).toString() : "0";
+  const machineID = creds.machineID || getMachineId();
+  return {
+    Authorization: `Bearer COSY.${payloadB64}.${sig}`,
+    "Cosy-Key": cosyKey,
+    "Cosy-User": creds.userID,
+    "Cosy-Date": timestamp,
+    "Cosy-Version": QoderIDEVersion,
+    "Cosy-Machineid": machineID,
+    "Cosy-Machinetoken": machineID,
+    "Cosy-Machinetype": QoderMachineTypeMagic,
+    "Cosy-Machineos": QoderMachineOS,
+    "Cosy-Clienttype": QoderClientType,
+    "Cosy-Clientip": "127.0.0.1",
+    "Cosy-Bodyhash": bodyHash,
+    "Cosy-Bodylength": bodyLen,
+    "Cosy-Sigpath": sigPath,
+    "Cosy-Data-Policy": QoderDataPolicy,
+    "Cosy-Organization-Id": "",
+    "Cosy-Organization-Tags": "",
+    "Login-Version": QoderLoginVersion,
+    "X-Request-Id": crypto.randomUUID()
+  };
+}
+
+// src/models.ts
+var CACHE_PATH = join2(homedir2(), ".pi", "agent", "qoder-models-cache.json");
+var ZERO_COST = Object.freeze({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+var staticModels = [
+  {
+    id: "auto",
+    name: "Qoder Auto",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: true,
+    supportsEffort: false,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 18e4,
+    maxTokens: 32768
+  },
+  {
+    id: "ultimate",
+    name: "Qoder Ultimate",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: true,
+    supportsEffort: true,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 1e6,
+    maxTokens: 32768
+  },
+  {
+    id: "performance",
+    name: "Qoder Performance",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: true,
+    supportsEffort: true,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 1e6,
+    maxTokens: 32768
+  },
+  {
+    id: "efficient",
+    name: "Qoder Efficient",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: false,
+    supportsEffort: false,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 18e4,
+    maxTokens: 32768
+  },
+  {
+    id: "lite",
+    name: "Qoder Lite",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: false,
+    supportsEffort: false,
+    input: ["text"],
+    cost: ZERO_COST,
+    contextWindow: 18e4,
+    maxTokens: 32768
+  },
+  {
+    id: "qmodel",
+    name: "Qwen3.7 Plus (Qoder)",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: false,
+    supportsEffort: false,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 1e6,
+    maxTokens: 32768
+  },
+  {
+    id: "qmodel_latest",
+    name: "Qwen3.7 Max (Qoder)",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: false,
+    supportsEffort: false,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 1e6,
+    maxTokens: 32768
+  },
+  {
+    id: "dmodel",
+    name: "DeepSeek V4 Pro (Qoder)",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: true,
+    supportsEffort: true,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 1e6,
+    maxTokens: 32768
+  },
+  {
+    id: "dfmodel",
+    name: "DeepSeek V4 Flash (Qoder)",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: true,
+    supportsEffort: true,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 1e6,
+    maxTokens: 32768
+  },
+  {
+    id: "gm51model",
+    name: "GLM 5.1 (Qoder)",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: true,
+    supportsEffort: true,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 18e4,
+    maxTokens: 32768
+  },
+  {
+    id: "kmodel",
+    name: "Kimi K2.6 (Qoder)",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: false,
+    supportsEffort: false,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 256e3,
+    maxTokens: 32768
+  },
+  {
+    id: "mmodel",
+    name: "MiniMax M3 (Qoder)",
+    api: "qoder-api",
+    provider: "qoder",
+    baseUrl: "https://api3.qoder.sh/",
+    reasoning: false,
+    supportsEffort: false,
+    input: ["text", "image"],
+    cost: ZERO_COST,
+    contextWindow: 1e6,
+    maxTokens: 32768
+  }
+];
+function getCachedModels() {
+  if (existsSync2(CACHE_PATH)) {
+    try {
+      const data = JSON.parse(readFileSync2(CACHE_PATH, "utf8"));
+      if (data && Array.isArray(data.models)) {
+        return data.models;
+      }
+    } catch {
+    }
+  }
+  return staticModels;
+}
+function getCachedModelConfig(modelKey) {
+  if (existsSync2(CACHE_PATH)) {
+    try {
+      const data = JSON.parse(readFileSync2(CACHE_PATH, "utf8"));
+      if (data && data.configs && data.configs[modelKey]) {
+        return data.configs[modelKey];
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function isCacheStale() {
+  if (!existsSync2(CACHE_PATH)) return true;
+  try {
+    const data = JSON.parse(readFileSync2(CACHE_PATH, "utf8"));
+    if (!data || typeof data.updatedAt !== "number") return true;
+    return Date.now() - data.updatedAt > 36e5;
+  } catch {
+    return true;
+  }
+}
+async function updateQoderModelsCache(authToken, userID, name, email) {
+  const modelListURL = "https://api3.qoder.sh/algo/api/v2/model/list";
+  try {
+    const headers = buildAuthHeaders(null, modelListURL, {
+      userID,
+      authToken,
+      name,
+      email
+    });
+    const response = await fetch(modelListURL, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        ...headers
+      }
+    });
+    if (!response.ok) {
+      return;
+    }
+    const resData = await response.json();
+    const chatModels = resData.chat || [];
+    if (chatModels.length === 0) return;
+    const newModels = [];
+    const configs = {};
+    for (const entry of chatModels) {
+      const key = entry.key;
+      if (!key || !entry.enable) continue;
+      const display = entry.display_name || key;
+      let ctxLen = entry.max_input_tokens || 18e4;
+      if (entry.context_config && typeof entry.context_config === "object") {
+        for (const configVal of Object.values(entry.context_config)) {
+          if (configVal && typeof configVal === "object" && typeof configVal.token_count === "number") {
+            const tc = configVal.token_count;
+            if (tc > ctxLen) {
+              ctxLen = tc;
+            }
+          }
+        }
+      }
+      const isVL = !!entry.is_vl;
+      const isReasoning = !!entry.is_reasoning || !!entry.thinking_config;
+      const supportsEffort = !!entry.thinking_config?.enabled?.efforts;
+      configs[key] = entry;
+      newModels.push({
+        id: key,
+        name: display,
+        api: "qoder-api",
+        provider: "qoder",
+        baseUrl: "https://api3.qoder.sh/",
+        reasoning: isReasoning,
+        supportsEffort,
+        input: isVL ? ["text", "image"] : ["text"],
+        cost: ZERO_COST,
+        contextWindow: ctxLen,
+        maxTokens: entry.max_output_tokens || 32768
+      });
+    }
+    if (newModels.length === 0) return;
+    if (!newModels.some((m) => m.id === "auto")) {
+      newModels.unshift({
+        id: "auto",
+        name: "Qoder Auto",
+        api: "qoder-api",
+        provider: "qoder",
+        baseUrl: "https://api3.qoder.sh/",
+        reasoning: true,
+        supportsEffort: false,
+        input: ["text", "image"],
+        cost: ZERO_COST,
+        contextWindow: 18e4,
+        maxTokens: 32768
+      });
+    }
+    const cacheData = {
+      updatedAt: Date.now(),
+      models: newModels,
+      configs
+    };
+    mkdirSync2(dirname2(CACHE_PATH), { recursive: true });
+    writeFileSync2(CACHE_PATH, JSON.stringify(cacheData, null, 2), "utf-8");
+  } catch {
+  }
+}
+
+// src/oauth.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/login.ts
+import crypto2 from "node:crypto";
+function getPrompt(callbacks) {
+  return callbacks.onPrompt;
+}
+function getProgress(callbacks) {
+  return callbacks.onProgress;
+}
+function getSignal(callbacks) {
+  return callbacks.signal;
+}
+function generatePKCE() {
+  const codeVerifier = crypto2.randomBytes(32).toString("base64url");
+  const codeChallenge = crypto2.createHash("sha256").update(codeVerifier).digest("base64url");
+  return { codeVerifier, codeChallenge };
+}
+function parseExpiresAt(s, expiresInSeconds) {
+  if (s) {
+    const t = Date.parse(s);
+    if (!Number.isNaN(t)) return t;
+    const ms = Number.parseInt(s, 10);
+    if (!Number.isNaN(ms) && ms > 0) return ms;
+  }
+  if (expiresInSeconds && expiresInSeconds > 0) {
+    return Date.now() + expiresInSeconds * 1e3;
+  }
+  return Date.now() + 30 * 24 * 60 * 60 * 1e3;
+}
+async function interactiveLogin(callbacks) {
+  if (hasExtensionContext()) {
+    const choice = await showLoginUI();
+    if (!choice) {
+      throw new Error("Login cancelled");
+    }
+    const runAuth = async (mergedCallbacks) => {
+      return runDeviceFlow(mergedCallbacks);
+    };
+    const creds = await showWaitingUI(callbacks, runAuth);
+    if (!creds) {
+      throw new Error("Login cancelled");
+    }
+    return creds;
+  }
+  const prompt = getPrompt(callbacks);
+  const proceed = await prompt({
+    message: "Press Enter to start browser login for Qoder",
+    placeholder: "press enter",
+    allowEmpty: true
+  });
+  if (getSignal(callbacks)?.aborted) throw new Error("Login cancelled");
+  return runDeviceFlow(callbacks);
+}
+function abortableDelay(ms, signal) {
+  if (signal?.aborted) return Promise.reject(signal.reason || new Error("Login cancelled"));
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason || new Error("Login cancelled"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function runDeviceFlow(callbacks) {
+  const { codeVerifier, codeChallenge } = generatePKCE();
+  const nonce = crypto2.randomUUID();
+  const machineID = getMachineId();
+  const verificationURI = `https://qoder.com/device/selectAccounts?challenge=${codeChallenge}&challenge_method=S256&machine_id=${machineID}&nonce=${nonce}`;
+  getProgress(callbacks)?.("Please complete login in your browser...");
+  callbacks.onAuth({
+    url: verificationURI,
+    instructions: "Click to sign in with your Qoder account in the browser."
+  });
+  const pollURL = `https://openapi.qoder.sh/api/v1/deviceToken/poll?nonce=${encodeURIComponent(nonce)}&verifier=${encodeURIComponent(codeVerifier)}&challenge_method=S256`;
+  const pollInterval = 2e3;
+  const maxAttempts = 90;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (getSignal(callbacks)?.aborted) throw new Error("Login cancelled");
+    await abortableDelay(pollInterval, getSignal(callbacks));
+    try {
+      const response = await fetch(pollURL, {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          "User-Agent": "pi-provider-qoder"
+        },
+        signal: getSignal(callbacks)
+      });
+      if (response.status === 202 || response.status === 404) {
+        continue;
+      }
+      if (!response.ok) {
+        const errText = await response.text();
+        throw new Error(`Device token poll failed: ${response.status} ${response.statusText}. Response: ${errText}`);
+      }
+      const tokenData = await response.json();
+      if (!tokenData.token) {
+        throw new Error("Device token poll returned empty access token");
+      }
+      const expireMs = parseExpiresAt(tokenData.expires_at, tokenData.expires_in);
+      getProgress(callbacks)?.("Fetching user profile...");
+      let email = "";
+      let name = "";
+      try {
+        const userinfoRes = await fetch("https://openapi.qoder.sh/api/v1/userinfo", {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${tokenData.token}`,
+            Accept: "application/json",
+            "User-Agent": "pi-provider-qoder"
+          }
+        });
+        if (userinfoRes.ok) {
+          const userinfo = await userinfoRes.json();
+          email = userinfo.email || "";
+          name = userinfo.name || userinfo.username || "";
+        }
+      } catch {
+      }
+      getProgress(callbacks)?.("Login successful!");
+      return {
+        refresh: `${tokenData.refresh_token}|${tokenData.user_id}|${machineID}`,
+        access: tokenData.token,
+        expires: expireMs - 5 * 60 * 1e3,
+        // 5 min buffer
+        userID: tokenData.user_id,
+        email,
+        name,
+        machineID
+      };
+    } catch (e) {
+      if (e.name === "AbortError" || getSignal(callbacks)?.aborted) {
+        throw new Error("Login cancelled");
+      }
+      throw e;
+    }
+  }
+  throw new Error("Authorization timed out");
+}
+
+// src/oauth.ts
+var AUTH_FILE = join3(homedir3(), ".pi", "agent", "auth.json");
+function getCachedCredentials(_accessToken) {
+  if (existsSync3(AUTH_FILE)) {
+    try {
+      const auth = JSON.parse(readFileSync3(AUTH_FILE, "utf-8"));
+      const creds = auth?.qoder;
+      if (creds && creds.userID) {
+        return creds;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function loginQoder(callbacks) {
+  const pat = process.env.QODER_PERSONAL_ACCESS_TOKEN || process.env.QODER_PAT;
+  if (pat) {
+    try {
+      const userinfoRes = await fetch("https://openapi.qoder.sh/api/v1/userinfo", {
+        headers: {
+          Authorization: `Bearer ${pat}`,
+          Accept: "application/json",
+          "User-Agent": "pi-provider-qoder"
+        }
+      });
+      if (userinfoRes.ok) {
+        const userinfo = await userinfoRes.json();
+        const email = userinfo.email || "";
+        const name = userinfo.name || userinfo.username || "";
+        const userID = userinfo.id || "pat";
+        const machineID = getMachineId();
+        const creds2 = {
+          refresh: `pat|${userID}|${machineID}`,
+          access: pat,
+          expires: Date.now() + 30 * 24 * 60 * 60 * 1e3,
+          // 30 days
+          userID,
+          email,
+          name,
+          machineID
+        };
+        updateQoderModelsCache(pat, userID, name, email).catch(() => {
+        });
+        return creds2;
+      }
+    } catch {
+    }
+  }
+  const creds = await interactiveLogin(callbacks);
+  try {
+    const qCreds = creds;
+    updateQoderModelsCache(qCreds.access, qCreds.userID, qCreds.name, qCreds.email).catch(() => {
+    });
+  } catch {
+  }
+  return creds;
+}
+async function refreshQoderToken(credentials) {
+  const parts = credentials.refresh.split("|");
+  const refreshToken = parts[0] || "";
+  const userID = parts[1] || "";
+  const machineID = parts[2] || getMachineId();
+  if (refreshToken === "pat") {
+    return {
+      ...credentials,
+      expires: Date.now() + 30 * 24 * 60 * 60 * 1e3
+    };
+  }
+  const refreshURL = "https://center.qoder.sh/algo/api/v3/user/refresh_token";
+  try {
+    const response = await fetch(refreshURL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${credentials.access}`,
+        Accept: "application/json",
+        "User-Agent": "pi-provider-qoder"
+      },
+      body: JSON.stringify({ refreshToken })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      const newAccess = data.token;
+      const newRefresh = data.refresh_token || refreshToken;
+      let expireMs = Date.now() + 30 * 24 * 60 * 60 * 1e3;
+      if (data.expires_at) {
+        const parsed = Date.parse(data.expires_at);
+        if (!Number.isNaN(parsed)) expireMs = parsed;
+      } else if (data.expires_in) {
+        expireMs = Date.now() + data.expires_in * 1e3;
+      }
+      const refreshed = {
+        ...credentials,
+        refresh: `${newRefresh}|${userID}|${machineID}`,
+        access: newAccess,
+        expires: expireMs - 5 * 60 * 1e3,
+        userID,
+        email: credentials.email || "",
+        name: credentials.name || "",
+        machineID
+      };
+      updateQoderModelsCache(
+        newAccess,
+        userID,
+        credentials.name || "",
+        credentials.email || ""
+      ).catch(() => {
+      });
+      return refreshed;
+    }
+  } catch {
+  }
+  const refreshedFallback = {
+    ...credentials,
+    expires: Date.now() + 60 * 60 * 1e3
+    // extend for 1 hour
+  };
+  return refreshedFallback;
+}
+
+// src/stream.ts
+import crypto3 from "node:crypto";
+import * as PiAi from "@earendil-works/pi-ai";
+
+// src/qoder-encoding.ts
+var qoderCustomAlphabet = "_doRTgHZBKcGVjlvpC,@aFSx#DPuNJme&i*MzLOEn)sUrthbf%Y^w.(kIQyXqWA!";
+var qoderStdAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function qoderEncodeBody(plaintext) {
+  const std = Buffer.isBuffer(plaintext) ? plaintext.toString("base64") : Buffer.from(plaintext).toString("base64");
+  const n = std.length;
+  const a = Math.floor(n / 3);
+  const rearranged = std.slice(n - a) + std.slice(a, n - a) + std.slice(0, a);
+  let out = "";
+  for (let i = 0; i < n; i++) {
+    const c = rearranged[i];
+    if (c === "=") {
+      out += "$";
+    } else {
+      const idx = qoderStdAlphabet.indexOf(c);
+      if (idx >= 0) {
+        out += qoderCustomAlphabet[idx];
+      } else {
+        out += c;
+      }
+    }
+  }
+  return out;
+}
+
+// src/thinking-parser.ts
+var THINKING_END_TAG = "</thinking>";
+var THINKING_TAG_VARIANTS = [
+  { open: "<thinking>", close: "</thinking>" },
+  { open: "<think>", close: "</think>" },
+  { open: "<reasoning>", close: "</reasoning>" },
+  { open: "<thought>", close: "</thought>" }
+];
+function getTrailingPossibleTagPrefixLength(text, tag) {
+  const maxPrefixLength = Math.min(text.length, tag.length - 1);
+  for (let len = maxPrefixLength; len > 0; len--) {
+    if (text.endsWith(tag.slice(0, len))) return len;
+  }
+  return 0;
+}
+function getMaxTrailingPossibleTagPrefixLength(text, tags) {
+  let maxLength = 0;
+  for (const tag of tags) {
+    maxLength = Math.max(maxLength, getTrailingPossibleTagPrefixLength(text, tag));
+  }
+  return maxLength;
+}
+var ThinkingTagParser = class {
+  constructor(output, stream) {
+    this.output = output;
+    this.stream = stream;
+  }
+  textBuffer = "";
+  inThinking = false;
+  thinkingExtracted = false;
+  thinkingBlockIndex = null;
+  textBlockIndex = null;
+  lastTextBlockIndex = null;
+  activeEndTag = THINKING_END_TAG;
+  processChunk(chunk) {
+    this.textBuffer += chunk;
+    while (this.textBuffer.length > 0) {
+      const prevLength = this.textBuffer.length;
+      if (!this.inThinking && !this.thinkingExtracted) {
+        this.processBeforeThinking();
+        if (this.textBuffer.length === 0) break;
+      }
+      if (this.inThinking) {
+        this.processInsideThinking();
+        if (this.textBuffer.length === 0) break;
+      }
+      if (this.thinkingExtracted) {
+        this.processAfterThinking();
+        break;
+      }
+      if (this.textBuffer.length >= prevLength) break;
+    }
+  }
+  finalize() {
+    if (this.textBuffer.length === 0) return;
+    if (this.inThinking && this.thinkingBlockIndex !== null) {
+      const block = this.output.content[this.thinkingBlockIndex];
+      block.thinking += this.textBuffer;
+      this.stream.push({
+        type: "thinking_delta",
+        contentIndex: this.thinkingBlockIndex,
+        delta: this.textBuffer,
+        partial: this.output
+      });
+      this.stream.push({
+        type: "thinking_end",
+        contentIndex: this.thinkingBlockIndex,
+        content: block.thinking,
+        partial: this.output
+      });
+    } else {
+      this.emitText(this.textBuffer);
+    }
+    this.textBuffer = "";
+  }
+  getTextBlockIndex() {
+    return this.textBlockIndex ?? this.lastTextBlockIndex;
+  }
+  processBeforeThinking() {
+    let bestPos = -1;
+    let bestVariant = null;
+    for (const variant of THINKING_TAG_VARIANTS) {
+      const pos = this.textBuffer.indexOf(variant.open);
+      if (pos !== -1 && (bestPos === -1 || pos < bestPos)) {
+        bestPos = pos;
+        bestVariant = variant;
+      }
+    }
+    if (bestPos !== -1 && bestVariant) {
+      if (bestPos > 0) this.emitText(this.textBuffer.slice(0, bestPos));
+      this.textBuffer = this.textBuffer.slice(bestPos + bestVariant.open.length);
+      this.activeEndTag = bestVariant.close;
+      this.inThinking = true;
+      return;
+    }
+    const trailingPrefixLength = getMaxTrailingPossibleTagPrefixLength(
+      this.textBuffer,
+      THINKING_TAG_VARIANTS.map((variant) => variant.open)
+    );
+    const safeLen = this.textBuffer.length - trailingPrefixLength;
+    if (safeLen > 0) {
+      this.emitText(this.textBuffer.slice(0, safeLen));
+      this.textBuffer = this.textBuffer.slice(safeLen);
+    }
+  }
+  processInsideThinking() {
+    const endPos = this.textBuffer.indexOf(this.activeEndTag);
+    if (endPos !== -1) {
+      if (endPos > 0) this.emitThinking(this.textBuffer.slice(0, endPos));
+      if (this.thinkingBlockIndex !== null) {
+        const block = this.output.content[this.thinkingBlockIndex];
+        this.stream.push({
+          type: "thinking_end",
+          contentIndex: this.thinkingBlockIndex,
+          content: block.thinking,
+          partial: this.output
+        });
+      }
+      this.textBuffer = this.textBuffer.slice(endPos + this.activeEndTag.length);
+      this.inThinking = false;
+      this.thinkingExtracted = true;
+      this.lastTextBlockIndex = this.textBlockIndex;
+      this.textBlockIndex = null;
+      if (this.textBuffer.startsWith("\n\n")) this.textBuffer = this.textBuffer.slice(2);
+      return;
+    }
+    const trailingPrefixLength = getTrailingPossibleTagPrefixLength(this.textBuffer, this.activeEndTag);
+    const safeLen = this.textBuffer.length - trailingPrefixLength;
+    if (safeLen > 0) {
+      this.emitThinking(this.textBuffer.slice(0, safeLen));
+      this.textBuffer = this.textBuffer.slice(safeLen);
+    }
+  }
+  processAfterThinking() {
+    this.emitText(this.textBuffer);
+    this.textBuffer = "";
+  }
+  emitText(text) {
+    if (!text) return;
+    if (this.textBlockIndex === null) {
+      this.textBlockIndex = this.output.content.length;
+      this.output.content.push({ type: "text", text: "" });
+      this.stream.push({ type: "text_start", contentIndex: this.textBlockIndex, partial: this.output });
+    }
+    const block = this.output.content[this.textBlockIndex];
+    block.text += text;
+    this.stream.push({ type: "text_delta", contentIndex: this.textBlockIndex, delta: text, partial: this.output });
+  }
+  emitThinking(thinking) {
+    if (!thinking) return;
+    if (this.thinkingBlockIndex === null) {
+      if (this.textBlockIndex !== null) {
+        this.thinkingBlockIndex = this.textBlockIndex;
+        this.output.content.splice(this.thinkingBlockIndex, 0, { type: "thinking", thinking: "" });
+        this.textBlockIndex = this.textBlockIndex + 1;
+      } else {
+        this.thinkingBlockIndex = this.output.content.length;
+        this.output.content.push({ type: "thinking", thinking: "" });
+      }
+      this.stream.push({ type: "thinking_start", contentIndex: this.thinkingBlockIndex, partial: this.output });
+    }
+    const block = this.output.content[this.thinkingBlockIndex];
+    block.thinking += thinking;
+    this.stream.push({
+      type: "thinking_delta",
+      contentIndex: this.thinkingBlockIndex,
+      delta: thinking,
+      partial: this.output
+    });
+  }
+};
+
+// src/transform.ts
+function getContentText(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content.map((c) => {
+      if (c.type === "text") return c.text;
+      if (c.type === "thinking") return c.thinking;
+      return "";
+    }).join("");
+  }
+  return "";
+}
+function transformTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+function transformMessagesForQoder(messages) {
+  const normalizedMessages = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant" && (msg.stopReason === "error" || msg.stopReason === "aborted")) {
+      continue;
+    }
+    if (msg.role === "user") {
+      let content = "";
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        const hasImage = msg.content.some((c) => c.type === "image");
+        if (hasImage) {
+          content = msg.content.map((c) => {
+            if (c.type === "text") {
+              return { type: "text", text: c.text };
+            }
+            if (c.type === "image") {
+              const img = c;
+              return {
+                type: "image_url",
+                image_url: {
+                  url: `data:${img.mimeType};base64,${img.data}`
+                }
+              };
+            }
+            return null;
+          }).filter(Boolean);
+        } else {
+          content = getContentText(msg);
+        }
+      }
+      normalizedMessages.push({
+        role: "user",
+        content
+      });
+    } else if (msg.role === "assistant") {
+      const am = msg;
+      let content = "";
+      const toolCalls = [];
+      if (Array.isArray(am.content)) {
+        for (const block of am.content) {
+          if (block.type === "text") {
+            content += block.text;
+          } else if (block.type === "thinking") {
+            content += `<thinking>${block.thinking}</thinking>
+
+`;
+          } else if (block.type === "toolCall") {
+            const tc = block;
+            toolCalls.push({
+              id: tc.id,
+              type: "function",
+              function: {
+                name: tc.name,
+                arguments: typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments)
+              }
+            });
+          }
+        }
+      } else {
+        content = am.content || "";
+      }
+      const mapped = {
+        role: "assistant",
+        content: content || null
+      };
+      if (toolCalls.length > 0) {
+        mapped.tool_calls = toolCalls;
+      }
+      normalizedMessages.push(mapped);
+    } else if (msg.role === "toolResult") {
+      const tr = msg;
+      normalizedMessages.push({
+        role: "tool",
+        tool_call_id: tr.toolCallId,
+        content: getContentText(tr)
+      });
+    }
+  }
+  return normalizedMessages;
+}
+
+// src/stream.ts
+function stableHash(prefix, ...inputs) {
+  const hash = crypto3.createHash("sha256");
+  hash.update(prefix);
+  for (const input of inputs) {
+    hash.update("\0");
+    hash.update(input);
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function stableChatRecordID(model, messages, tools, maxTokens) {
+  const hash = crypto3.createHash("sha256");
+  hash.update("qoder-record");
+  hash.update("\0");
+  hash.update(model);
+  for (const msg of messages) {
+    if (msg && msg.role) {
+      hash.update("\0");
+      hash.update(msg.role);
+    }
+    if (msg && msg.content) {
+      hash.update("\0");
+      hash.update(typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content));
+    }
+  }
+  if (tools) {
+    hash.update("\0");
+    hash.update(JSON.stringify(tools));
+  }
+  hash.update("\0");
+  hash.update(`mt=${maxTokens}`);
+  return hash.digest("hex").slice(0, 16);
+}
+function streamQoder(model, context, options) {
+  const StreamCtor = PiAi.AssistantMessageEventStream;
+  const stream = new StreamCtor();
+  const output = {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
+  (async () => {
+    try {
+      const accessToken = options?.apiKey;
+      if (!accessToken) {
+        throw new Error("Qoder credentials not set. Run /login qoder or set QODER_PERSONAL_ACCESS_TOKEN.");
+      }
+      const cachedCreds = getCachedCredentials(accessToken);
+      const userID = cachedCreds?.userID || "qoder-user";
+      const name = cachedCreds?.name || "Qoder User";
+      const email = cachedCreds?.email || "user@qoder.com";
+      const machineID = cachedCreds?.machineID || getMachineId();
+      if (isCacheStale()) {
+        updateQoderModelsCache(accessToken, userID, name, email).catch(() => {
+        });
+      }
+      const qoderModel = model.id;
+      const modelConfig = getCachedModelConfig(qoderModel) || {
+        key: qoderModel,
+        is_reasoning: qoderModel === "ultimate" || qoderModel === "performance" || qoderModel.includes("dmodel") || qoderModel.includes("dfmodel"),
+        max_output_tokens: 32768,
+        source: "system"
+      };
+      modelConfig.key = qoderModel;
+      const isReasoning = !!modelConfig.is_reasoning;
+      const maxOutputTokens = modelConfig.max_output_tokens || 32768;
+      const normalizedMessages = transformMessagesForQoder(context.messages);
+      const systemText = context.systemPrompt || "";
+      let lastUserText = "";
+      for (let i = normalizedMessages.length - 1; i >= 0; i--) {
+        if (normalizedMessages[i].role === "user") {
+          const content = normalizedMessages[i].content;
+          lastUserText = typeof content === "string" ? content : Array.isArray(content) ? content.map((c) => c.text || "").join("") : "";
+          break;
+        }
+      }
+      const sessionID = stableHash("qoder-session", userID, qoderModel);
+      let maxTokens = 32768;
+      if (maxOutputTokens > 0) {
+        maxTokens = maxOutputTokens;
+      }
+      if (options?.maxTokens && options.maxTokens < maxTokens) {
+        maxTokens = options.maxTokens;
+      }
+      const toolsRaw = context.tools && context.tools.length > 0 ? transformTools(context.tools) : void 0;
+      const recordID = stableChatRecordID(qoderModel, normalizedMessages, toolsRaw, maxTokens);
+      const reqBody = {
+        request_id: crypto3.randomUUID(),
+        request_set_id: recordID,
+        chat_record_id: recordID,
+        session_id: sessionID,
+        stream: true,
+        chat_task: "FREE_INPUT",
+        is_reply: true,
+        is_retry: false,
+        source: 1,
+        version: "3",
+        session_type: "qodercli",
+        agent_id: "agent_common",
+        task_id: "common",
+        code_language: "",
+        chat_prompt: "",
+        image_urls: null,
+        aliyun_user_type: "",
+        system: systemText,
+        messages: normalizedMessages,
+        tools: toolsRaw || [],
+        parameters: { max_tokens: maxTokens },
+        chat_context: {
+          chatPrompt: "",
+          imageUrls: null,
+          extra: {
+            context: [],
+            modelConfig: {
+              key: qoderModel,
+              is_reasoning: isReasoning
+            },
+            originalContent: lastUserText
+          },
+          features: [],
+          text: lastUserText
+        },
+        model_config: modelConfig,
+        business: {
+          product: "cli",
+          version: "1.0.0",
+          type: "agent",
+          stage: "start",
+          id: crypto3.randomUUID(),
+          name: lastUserText.substring(0, 30),
+          begin_at: Date.now()
+        }
+      };
+      const bodyBytes = Buffer.from(JSON.stringify(reqBody));
+      const encodedBody = qoderEncodeBody(bodyBytes);
+      const encodedBytes = Buffer.from(encodedBody, "utf8");
+      const chatURL = "https://api3.qoder.sh/algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1";
+      const headers = buildAuthHeaders(encodedBytes, chatURL, {
+        userID,
+        authToken: accessToken,
+        name,
+        email,
+        machineID
+      });
+      const modelSource = modelConfig.source || "system";
+      const response = await fetch(chatURL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Accept-Encoding": "identity",
+          "X-Model-Key": qoderModel,
+          "X-Model-Source": modelSource,
+          ...headers
+        },
+        body: encodedBytes,
+        signal: options?.signal
+      });
+      if (!response.ok) {
+        const errText = await response.text();
+        throw new Error(`Qoder API request failed: ${response.status} ${response.statusText}. Response: ${errText}`);
+      }
+      const reader = response.body?.getReader();
+      if (!reader) throw new Error("No response body");
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let contentBlockIndex = -1;
+      let thinkingBlockIndex = -1;
+      const toolCallsState = [];
+      const thinkingEnabled = options?.reasoning !== false && options?.reasoning !== "off";
+      const thinkingParser = thinkingEnabled ? new ThinkingTagParser(output, stream) : null;
+      stream.push({ type: "start", partial: output });
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        while (true) {
+          const lineEnd = buffer.indexOf("\n");
+          if (lineEnd === -1) break;
+          const line = buffer.substring(0, lineEnd).trim();
+          buffer = buffer.substring(lineEnd + 1);
+          if (!line.startsWith("data:")) continue;
+          const dataStr = line.substring(5).trim();
+          if (dataStr === "[DONE]") {
+            break;
+          }
+          try {
+            const envelope = JSON.parse(dataStr);
+            if (envelope.statusCodeValue && envelope.statusCodeValue !== 200) {
+              throw new Error(`Upstream status ${envelope.statusCodeValue}: ${envelope.body}`);
+            }
+            const innerStr = envelope.body;
+            if (!innerStr || innerStr === "[DONE]") continue;
+            const inner = JSON.parse(innerStr);
+            if (inner.choices && inner.choices.length > 0) {
+              const choice = inner.choices[0];
+              const delta = choice.delta;
+              if (delta) {
+                if (delta.reasoning_content) {
+                  if (thinkingBlockIndex === -1) {
+                    thinkingBlockIndex = output.content.length;
+                    output.content.push({ type: "thinking", thinking: "" });
+                    stream.push({ type: "thinking_start", contentIndex: thinkingBlockIndex, partial: output });
+                  }
+                  const block = output.content[thinkingBlockIndex];
+                  block.thinking += delta.reasoning_content;
+                  stream.push({
+                    type: "thinking_delta",
+                    contentIndex: thinkingBlockIndex,
+                    delta: delta.reasoning_content,
+                    partial: output
+                  });
+                }
+                if (delta.content) {
+                  if (thinkingBlockIndex !== -1) {
+                    const block = output.content[thinkingBlockIndex];
+                    stream.push({
+                      type: "thinking_end",
+                      contentIndex: thinkingBlockIndex,
+                      content: block.thinking,
+                      partial: output
+                    });
+                    thinkingBlockIndex = -1;
+                  }
+                  if (thinkingParser) {
+                    thinkingParser.processChunk(delta.content);
+                  } else {
+                    if (contentBlockIndex === -1) {
+                      contentBlockIndex = output.content.length;
+                      output.content.push({ type: "text", text: "" });
+                      stream.push({ type: "text_start", contentIndex: contentBlockIndex, partial: output });
+                    }
+                    const block = output.content[contentBlockIndex];
+                    block.text += delta.content;
+                    stream.push({
+                      type: "text_delta",
+                      contentIndex: contentBlockIndex,
+                      delta: delta.content,
+                      partial: output
+                    });
+                  }
+                }
+                if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
+                  for (const tc of delta.tool_calls) {
+                    const idx = tc.index ?? 0;
+                    if (!toolCallsState[idx]) {
+                      toolCallsState[idx] = { arguments: "" };
+                    }
+                    const state = toolCallsState[idx];
+                    if (tc.id) state.id = tc.id;
+                    if (tc.function?.name) state.name = tc.function.name;
+                    if (tc.function?.arguments) {
+                      const argDelta = tc.function.arguments;
+                      state.arguments += argDelta;
+                      if (state.emittedStart === void 0) {
+                        state.emittedStart = true;
+                        state.contentIndex = output.content.length;
+                        const block = { type: "toolCall", id: state.id, name: state.name, arguments: {} };
+                        output.content.push(block);
+                        stream.push({ type: "toolcall_start", contentIndex: state.contentIndex, partial: output });
+                      }
+                      stream.push({
+                        type: "toolcall_delta",
+                        contentIndex: state.contentIndex,
+                        delta: argDelta,
+                        partial: output
+                      });
+                    }
+                  }
+                }
+              }
+              if (choice.finish_reason) {
+                output.stopReason = choice.finish_reason;
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      if (thinkingParser) {
+        thinkingParser.finalize();
+      }
+      if (thinkingBlockIndex !== -1) {
+        const block = output.content[thinkingBlockIndex];
+        stream.push({
+          type: "thinking_end",
+          contentIndex: thinkingBlockIndex,
+          content: block.thinking,
+          partial: output
+        });
+      }
+      for (const state of toolCallsState) {
+        if (state && state.emittedStart && !state.emittedEnd) {
+          state.emittedEnd = true;
+          let args = {};
+          try {
+            args = JSON.parse(state.arguments || "{}");
+          } catch {
+          }
+          const block = output.content[state.contentIndex];
+          block.arguments = args;
+          stream.push({
+            type: "toolcall_end",
+            contentIndex: state.contentIndex,
+            toolCall: {
+              type: "toolCall",
+              id: state.id,
+              name: state.name,
+              arguments: args
+            },
+            partial: output
+          });
+        }
+      }
+      if (toolCallsState.length > 0) {
+        output.stopReason = "toolUse";
+      } else {
+        output.stopReason = "stop";
+      }
+      stream.push({ type: "done", reason: output.stopReason, message: output });
+      stream.end();
+    } catch (e) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = e instanceof Error ? e.message : String(e);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      try {
+        stream.end();
+      } catch {
+      }
+    }
+  })();
+  return stream;
+}
+
+// src/usage.ts
+async function fetchQoderUsage(credentials) {
+  const usageURL = "https://openapi.qoder.sh/api/v2/quota/usage";
+  const response = await fetch(usageURL, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${credentials.access}`,
+      Accept: "application/json",
+      "User-Agent": "pi-provider-qoder"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch Qoder usage: ${response.status} ${response.statusText}`);
+  }
+  const raw = await response.json();
+  const usageBuckets = [];
+  if (raw.userQuota) {
+    usageBuckets.push({
+      id: "user-quota",
+      label: "User Quota",
+      usedDisplay: raw.userQuota.used.toFixed(2),
+      limitDisplay: raw.userQuota.total.toFixed(2),
+      unit: raw.userQuota.unit,
+      resetAt: raw.expiresAt ? new Date(raw.expiresAt).toISOString() : void 0
+    });
+  }
+  if (raw.orgResourcePackage && raw.orgResourcePackage.total > 0) {
+    usageBuckets.push({
+      id: "org-resource-package",
+      label: "Org Resource Package",
+      usedDisplay: raw.orgResourcePackage.used.toFixed(2),
+      limitDisplay: raw.orgResourcePackage.total.toFixed(2),
+      unit: raw.orgResourcePackage.unit,
+      resetAt: raw.expiresAt ? new Date(raw.expiresAt).toISOString() : void 0
+    });
+  }
+  const remainingText = raw.userQuota ? `${raw.userQuota.remaining.toFixed(2)} ${raw.userQuota.unit} remaining` : "";
+  return {
+    summary: remainingText,
+    subscriptionTitle: "Qoder AI Plan",
+    resetAt: raw.expiresAt ? new Date(raw.expiresAt).toISOString() : void 0,
+    manageUrl: "https://qoder.com",
+    usageBuckets,
+    raw
+  };
+}
+
+// src/index.ts
+function index_default(pi) {
+  pi.on("session_start", async (_event, ctx) => {
+    setExtensionContext(ctx);
+  });
+  pi.registerProvider("qoder", {
+    baseUrl: "https://api3.qoder.sh/",
+    api: "qoder-api",
+    models: getCachedModels(),
+    oauth: {
+      name: "Qoder (Browser OAuth / PAT)",
+      login: loginQoder,
+      refreshToken: refreshQoderToken,
+      getApiKey: (cred) => cred.access,
+      modifyModels: (models, cred) => {
+        const cached = getCachedModels();
+        const nonQoder = models.filter((m) => m.provider !== "qoder");
+        const modelsToUse = cached.length > 0 ? cached : staticModels;
+        const modifiedQoder = modelsToUse.map((m) => ({
+          ...m,
+          baseUrl: "https://api3.qoder.sh/"
+        }));
+        return [...nonQoder, ...modifiedQoder];
+      },
+      fetchUsage: fetchQoderUsage
+    },
+    streamSimple: streamQoder
+  });
+}
+export {
+  index_default as default
+};