pi-provider-codebuddy 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1324 @@
+// src/index.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import {
+  getAgentDir as getAgentDir2
+} from "@earendil-works/pi-coding-agent";
+
+// src/product.ts
+var CLI_VERSION = "2.171.0";
+var PLATFORM = "CLI";
+var PROVIDERS = [
+  {
+    id: "codebuddy-cn",
+    label: "CodeBuddy (CN)",
+    endpoint: "https://copilot.tencent.com"
+  },
+  {
+    id: "codebuddy-intl",
+    label: "CodeBuddy (International)",
+    endpoint: "https://www.codebuddy.ai"
+  },
+  // Same endpoint as the Chinese site; iOA is told apart by the `ioa=1` auth param
+  // and the default headers below, never by the domain.
+  {
+    id: "codebuddy-ioa",
+    label: "CodeBuddy iOA",
+    endpoint: "https://copilot.tencent.com",
+    environment: "iOA"
+  },
+  { id: "codebuddy-enterprise", label: "CodeBuddy Enterprise" }
+];
+function providerById(id) {
+  return PROVIDERS.find((provider) => provider.id === id);
+}
+function isCodeBuddyProvider(provider) {
+  return /^codebuddy(-|$)/.test(provider ?? "");
+}
+var IOA_DEFAULT_DOMAIN = "tencent.sso.copilot.tencent.com";
+var IOA_DEFAULT_ENTERPRISE_ID = "etahzsqej0n4";
+var INTERNAL_DOMAINS = [
+  "copilot.tencent.com",
+  "staging-copilot.tencent.com",
+  "www.codebuddy.cn",
+  "staging.codebuddy.cn",
+  "www.workbuddy.cn",
+  "staging.workbuddy.cn"
+];
+var EXTERNAL_DOMAINS = ["www.codebuddy.ai", "staging-codebuddy.tencent.com"];
+var IOA_DOMAINS = [
+  "tencent.sso.copilot.tencent.com",
+  "tencent.sso.copilot-staging.tencent.com",
+  "tencent.sso.codebuddy.cn",
+  "tencent.staging-sso.codebuddy.cn"
+];
+var CLOUD_HOSTED_DOMAINS = [
+  "*.sso.copilot.tencent.com",
+  "*.sso.copilot-staging.tencent.com",
+  "*.copilot.qq.com",
+  "*.copilot-staging.qq.com",
+  "*.sso.codebuddy.cn",
+  "*.staging-sso.codebuddy.cn"
+];
+function wildcardPattern(pattern, capture) {
+  const body = pattern.replace(/\./g, "\\.").replace(/\*/g, capture ? "([^.]*)" : "[^.]*");
+  return new RegExp(`^${body}$`);
+}
+function matchesDomain(patterns, host) {
+  return patterns.some(
+    (pattern) => pattern === host || pattern.includes("*") && wildcardPattern(pattern, false).test(host)
+  );
+}
+function isIOADomain(host) {
+  return matchesDomain(IOA_DOMAINS, host.toLowerCase().replace(/:\d+$/, ""));
+}
+function normalizeEndpoint(input) {
+  const trimmed = input.trim();
+  if (!trimmed) throw new Error("CodeBuddy endpoint is empty");
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  let url;
+  try {
+    url = new URL(withScheme);
+  } catch {
+    throw new Error(`Invalid CodeBuddy endpoint: ${input}`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error(`Unsupported CodeBuddy endpoint protocol: ${url.protocol}`);
+  }
+  return url.origin;
+}
+function hostOf(endpoint) {
+  return new URL(endpoint).hostname;
+}
+function networkEnvironment(domain) {
+  const host = domain.replace(/:\d+$/, "").toLowerCase();
+  if (matchesDomain(INTERNAL_DOMAINS, host)) return "internal";
+  if (matchesDomain(IOA_DOMAINS, host)) return "iOA";
+  if (matchesDomain(CLOUD_HOSTED_DOMAINS, host)) return "cloudhosted";
+  if (matchesDomain(EXTERNAL_DOMAINS, host)) return "external";
+  return "selfhosted";
+}
+function deploymentType(endpoint, environment) {
+  if (matchesDomain(CLOUD_HOSTED_DOMAINS, hostOf(endpoint)))
+    return "Cloud-Hosted";
+  if (environment === "cloudhosted") return "Cloud-Hosted";
+  if (environment === "selfhosted") return "Self-Hosted";
+  return "SaaS";
+}
+function enterpriseIdFromEndpoint(endpoint) {
+  const host = hostOf(endpoint);
+  for (const pattern of CLOUD_HOSTED_DOMAINS) {
+    const match = wildcardPattern(pattern, true).exec(host);
+    if (match?.[1]) return match[1];
+  }
+  return void 0;
+}
+
+// src/http.ts
+var HttpError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+};
+async function requestEnvelope(url, init, signal) {
+  const response = await fetch(url, { ...init, signal });
+  const text = await response.text();
+  const path = new URL(url).pathname;
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    throw new HttpError(
+      `CodeBuddy ${path} returned HTTP ${response.status}: ${text.slice(0, 200)}`,
+      response.status
+    );
+  }
+  if (!response.ok) {
+    throw new HttpError(
+      `CodeBuddy ${path} returned HTTP ${response.status}: ${body.msg ?? text.slice(0, 200)}`,
+      response.status
+    );
+  }
+  return body;
+}
+function sessionDomain(session) {
+  if (session.domain) return session.domain;
+  if (session.environment === "iOA") return IOA_DEFAULT_DOMAIN;
+  return hostOf(session.endpoint);
+}
+function sessionEnterpriseId(session) {
+  return session.enterpriseId || enterpriseIdFromEndpoint(session.endpoint);
+}
+function identityHeaders(session) {
+  const domain = sessionDomain(session);
+  const environment = session.environment ?? networkEnvironment(domain);
+  const headers = {
+    Authorization: `Bearer ${session.accessToken}`,
+    "X-Domain": domain,
+    "X-Product": deploymentType(session.endpoint, networkEnvironment(domain)),
+    "X-IDE-Type": PLATFORM,
+    "X-IDE-Name": PLATFORM,
+    "X-IDE-Version": CLI_VERSION,
+    "User-Agent": `${PLATFORM}/${CLI_VERSION} CodeBuddy/${CLI_VERSION}`
+  };
+  if (session.uid) headers["X-User-Id"] = session.uid;
+  const enterpriseId = sessionEnterpriseId(session);
+  if (enterpriseId) {
+    headers["X-Enterprise-Id"] = enterpriseId;
+    headers["X-Tenant-Id"] = enterpriseId;
+  } else if (environment === "iOA") {
+    headers["X-Enterprise-Id"] = IOA_DEFAULT_ENTERPRISE_ID;
+    headers["X-Tenant-Id"] = IOA_DEFAULT_ENTERPRISE_ID;
+  }
+  return headers;
+}
+async function getData(session, path, signal) {
+  const body = await requestEnvelope(
+    `${session.endpoint}${path}`,
+    { headers: identityHeaders(session) },
+    signal
+  );
+  if (body.code !== 0)
+    throw new Error(
+      `CodeBuddy ${path} failed (code ${body.code}): ${body.msg ?? "unknown error"}`
+    );
+  return body.data;
+}
+function uuidv7Hex() {
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  const ts = BigInt(Date.now());
+  for (let i = 0; i < 6; i++)
+    bytes[i] = Number(ts >> BigInt(8 * (5 - i)) & 0xffn);
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+var sessionsByToken = /* @__PURE__ */ new Map();
+function rememberSession(session) {
+  sessionsByToken.set(session.accessToken, session);
+}
+function lookupSession(accessToken) {
+  if (!accessToken) return void 0;
+  const known = sessionsByToken.get(accessToken);
+  if (known) return known;
+  const recovered = sessionFromJwt(accessToken);
+  if (recovered) sessionsByToken.set(accessToken, recovered);
+  return recovered;
+}
+function sessionFromJwt(accessToken) {
+  try {
+    const claims = JSON.parse(
+      Buffer.from(accessToken.split(".")[1] ?? "", "base64url").toString(
+        "utf8"
+      )
+    );
+    if (!claims.iss) return void 0;
+    const issuer = new URL(claims.iss);
+    return {
+      endpoint: issuer.origin,
+      accessToken,
+      uid: claims.sub,
+      enterpriseId: claims.enterprise_id || void 0,
+      // iOA tokens issued from an SSO domain carry no other marker (see test/http.test.ts).
+      environment: isIOADomain(issuer.hostname) ? "iOA" : void 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/auth.ts
+var LOGIN_TOKEN_PENDING_CODE = 11217;
+var LOGIN_ACCOUNT_PENDING_CODE = 12151;
+var POLL_INTERVAL_MS = 1e3;
+var LOGIN_TIMEOUT_MS = 3e5;
+var EXPIRY_SKEW_MS = 5 * 6e4;
+var UNAUTHENTICATED_HEADERS = {
+  "X-No-Authorization": "true",
+  "X-No-User-Id": "true",
+  "X-No-Enterprise-Id": "true",
+  "X-No-Department-Info": "true"
+};
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new Error("Login cancelled"));
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("Login cancelled"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function promptEnterpriseEndpoint(callbacks) {
+  const answer = await callbacks.onPrompt({
+    message: "Enterprise domain",
+    placeholder: "https://<enterprise>.copilot.qq.com"
+  });
+  return normalizeEndpoint(answer);
+}
+function reloginHint(credentials) {
+  const provider = providerById(credentials.providerId);
+  return `${provider?.label ?? "CodeBuddy"} login has expired; run /login ${credentials.providerId}`;
+}
+var CredentialsInvalidError = class extends Error {
+};
+function toCredentials(providerId, endpoint, token, account, environment, previous) {
+  const now = Date.now();
+  const expiresIn = (token.expiresIn ?? 3600) * 1e3;
+  return {
+    providerId: providerId || previous?.providerId || "codebuddy",
+    refresh: token.refreshToken ?? previous?.refresh ?? "",
+    access: token.accessToken,
+    expires: now + Math.max(expiresIn - EXPIRY_SKEW_MS, expiresIn / 2),
+    refreshExpires: token.refreshExpiresIn ? now + token.refreshExpiresIn * 1e3 : previous?.refreshExpires,
+    endpoint,
+    // The CLI's applyIOADefaultHeaders: the server's value wins, iOA falls back to its SSO domain.
+    domain: token.domain || previous?.domain || (environment === "iOA" ? IOA_DEFAULT_DOMAIN : hostOf(endpoint)),
+    environment: environment ?? previous?.environment,
+    uid: account?.uid ?? previous?.uid,
+    enterpriseId: account?.enterpriseId || previous?.enterpriseId || void 0,
+    nickname: account?.nickname ?? previous?.nickname,
+    enterpriseName: account?.enterpriseName ?? previous?.enterpriseName
+  };
+}
+function sessionFromCredentials(credentials) {
+  return {
+    endpoint: credentials.endpoint,
+    accessToken: credentials.access,
+    domain: credentials.domain,
+    environment: credentials.environment,
+    uid: credentials.uid,
+    enterpriseId: credentials.enterpriseId
+  };
+}
+async function pollToken(endpoint, state, signal) {
+  const deadline = Date.now() + LOGIN_TIMEOUT_MS;
+  const url = `${endpoint}/v2/plugin/auth/token?state=${encodeURIComponent(state)}`;
+  while (Date.now() < deadline) {
+    const body = await requestEnvelope(
+      url,
+      { headers: UNAUTHENTICATED_HEADERS },
+      signal
+    );
+    if (body.data?.accessToken) return body.data;
+    if (body.code !== LOGIN_TOKEN_PENDING_CODE && body.code !== 0) {
+      throw new Error(
+        `CodeBuddy login failed (code ${body.code}): ${body.msg ?? "unknown error"}`
+      );
+    }
+    await sleep(POLL_INTERVAL_MS, signal);
+  }
+  throw new Error("CodeBuddy login timed out after 5 minutes");
+}
+async function pollAccount(endpoint, state, token, environment, signal) {
+  const deadline = Date.now() + LOGIN_TIMEOUT_MS;
+  const url = `${endpoint}/v2/plugin/login/account?state=${encodeURIComponent(state)}`;
+  const headers = {
+    Authorization: `Bearer ${token.accessToken}`,
+    "X-Domain": token.domain || (environment === "iOA" ? IOA_DEFAULT_DOMAIN : hostOf(endpoint)),
+    "X-No-User-Id": "true",
+    "X-No-Enterprise-Id": "true",
+    "X-No-Department-Info": "true"
+  };
+  let authRetried = false;
+  while (Date.now() < deadline) {
+    let body;
+    try {
+      body = await requestEnvelope(url, { headers }, signal);
+    } catch (error) {
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403) && !authRetried) {
+        authRetried = true;
+        await sleep(POLL_INTERVAL_MS, signal);
+        continue;
+      }
+      throw error;
+    }
+    if (body.code === 0 && body.data) return body.data;
+    if (body.code !== LOGIN_ACCOUNT_PENDING_CODE) {
+      throw new Error(
+        `CodeBuddy account lookup failed (code ${body.code}): ${body.msg ?? "unknown error"}`
+      );
+    }
+    await sleep(POLL_INTERVAL_MS, signal);
+  }
+  throw new Error("CodeBuddy account lookup timed out");
+}
+async function loginCodeBuddy(provider, callbacks) {
+  const signal = callbacks.signal;
+  const endpoint = provider.endpoint ?? await promptEnterpriseEndpoint(callbacks);
+  const environment = provider.environment;
+  const stateBody = await requestEnvelope(
+    `${endpoint}/v2/plugin/auth/state?platform=${PLATFORM}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Domain": hostOf(endpoint),
+        ...UNAUTHENTICATED_HEADERS
+      },
+      body: "{}"
+    },
+    signal
+  );
+  const state = stateBody.data?.state;
+  const authUrl = stateBody.data?.authUrl;
+  if (!state || !authUrl) {
+    throw new Error(
+      `CodeBuddy login could not start (code ${stateBody.code}): ${stateBody.msg ?? "missing state"}`
+    );
+  }
+  const url = new URL(authUrl);
+  url.searchParams.set("version", CLI_VERSION);
+  if (environment === "iOA") url.searchParams.set("ioa", "1");
+  callbacks.onAuth({
+    url: url.toString(),
+    instructions: "Complete the CodeBuddy login in your browser."
+  });
+  callbacks.onProgress?.("Waiting for browser login...");
+  const token = await pollToken(endpoint, state, signal);
+  callbacks.onProgress?.("Fetching CodeBuddy account...");
+  const account = await pollAccount(
+    endpoint,
+    state,
+    token,
+    environment,
+    signal
+  );
+  return toCredentials(provider.id, endpoint, token, account, environment);
+}
+async function refreshCodeBuddy(credentials, signal) {
+  if (!credentials.endpoint)
+    throw new CredentialsInvalidError(
+      `CodeBuddy credentials have no endpoint. ${reloginHint(credentials)}`
+    );
+  if (!credentials.refresh)
+    throw new CredentialsInvalidError(
+      `CodeBuddy credentials have no refresh token. ${reloginHint(credentials)}`
+    );
+  let body;
+  try {
+    body = await requestEnvelope(
+      `${credentials.endpoint}/v2/plugin/auth/token/refresh`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${credentials.access}`,
+          "X-Refresh-Token": credentials.refresh,
+          "X-Auth-Refresh-Source": "plugin",
+          "X-Domain": credentials.domain || (credentials.environment === "iOA" ? IOA_DEFAULT_DOMAIN : hostOf(credentials.endpoint))
+        },
+        body: "{}"
+      },
+      signal
+    );
+  } catch (error) {
+    if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+      throw new CredentialsInvalidError(
+        `CodeBuddy rejected the token refresh (${error.status}). ${reloginHint(credentials)}`
+      );
+    }
+    throw error;
+  }
+  const token = body.data?.accessToken ? body.data : body.data?.data;
+  if (!token?.accessToken) {
+    if (body.code === 401 || body.code === 403) {
+      throw new CredentialsInvalidError(
+        `CodeBuddy rejected the token refresh (code ${body.code}). ${reloginHint(credentials)}`
+      );
+    }
+    throw new Error(
+      `CodeBuddy token refresh failed (code ${body.code}): ${body.msg ?? "no token returned"}`
+    );
+  }
+  return toCredentials(
+    credentials.providerId,
+    credentials.endpoint,
+    token,
+    void 0,
+    credentials.environment,
+    credentials
+  );
+}
+
+// src/credits.ts
+import {
+  createAssistantMessageEventStream
+} from "@earendil-works/pi-ai";
+
+// src/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function field(value, ...path) {
+  let current = value;
+  for (const key of path) {
+    if (!isRecord(current)) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function numberField(value, ...path) {
+  const raw = field(value, ...path);
+  const parsed = typeof raw === "string" && raw.trim() !== "" ? Number(raw) : raw;
+  return typeof parsed === "number" && Number.isFinite(parsed) ? parsed : void 0;
+}
+function stringField(value, ...path) {
+  const raw = field(value, ...path);
+  return typeof raw === "string" && raw !== "" ? raw : void 0;
+}
+function arrayField(value, ...path) {
+  const raw = field(value, ...path);
+  return Array.isArray(raw) ? raw : [];
+}
+
+// src/models.ts
+import {
+  chmodSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+import {
+  getAgentDir
+} from "@earendil-works/pi-coding-agent";
+var CODEBUDDY_API = "codebuddy-chat-completions";
+var CACHE_FILE = "codebuddy-models-cache.json";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var VALID_EFFORTS = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var DEFAULT_EFFORTS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var RESPONSES_APIS = /* @__PURE__ */ new Set([
+  "openai-responses",
+  "openai-codex-responses",
+  "azure-openai-responses"
+]);
+var CHAT_TAG = "chat";
+var remoteModelsByEndpointAndId = /* @__PURE__ */ new Map();
+function cachePath() {
+  return join(getAgentDir(), CACHE_FILE);
+}
+function remember(endpoint, models) {
+  for (const model of models)
+    remoteModelsByEndpointAndId.set(`${endpoint}|${model.id}`, model);
+}
+var cacheFile;
+var cacheFileLoaded = false;
+function readCacheFile() {
+  if (cacheFileLoaded) return cacheFile;
+  cacheFileLoaded = true;
+  try {
+    const cache = JSON.parse(
+      readFileSync(cachePath(), "utf8")
+    );
+    if (cache.endpoints && typeof cache.endpoints === "object") {
+      for (const [endpoint, entry] of Object.entries(cache.endpoints)) {
+        if (entry && Array.isArray(entry.models))
+          remember(endpoint, entry.models);
+      }
+      cacheFile = cache;
+    }
+  } catch {
+  }
+  return cacheFile;
+}
+function readModelCache(endpoint) {
+  const cache = readCacheFile();
+  const entry = cache?.endpoints[endpoint];
+  if (!entry) return void 0;
+  remember(endpoint, entry.models);
+  return entry;
+}
+function isModelCacheStale(endpoint) {
+  const entry = readModelCache(endpoint);
+  return !entry || Date.now() - entry.fetchedAt > CACHE_TTL_MS;
+}
+function writeModelCache(endpoint, models) {
+  try {
+    const cache = readCacheFile() ?? { endpoints: {} };
+    cache.endpoints[endpoint] = { fetchedAt: Date.now(), models };
+    const path = cachePath();
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(cache, null, 2), { mode: 384 });
+    chmodSync(tmp, 384);
+    renameSync(tmp, path);
+    cacheFile = cache;
+    cacheFileLoaded = true;
+  } catch {
+  }
+}
+function remoteModel(id, endpoint) {
+  if (remoteModelsByEndpointAndId.size === 0) readCacheFile();
+  return remoteModelsByEndpointAndId.get(`${endpoint}|${id}`);
+}
+function cachedModels(endpoint) {
+  const entry = readModelCache(endpoint);
+  return entry ? entry.models.map((model) => toProviderModel(model, endpoint)) : [];
+}
+async function fetchEnterpriseModels(session, signal) {
+  const enterpriseId = sessionEnterpriseId(session);
+  if (!enterpriseId) return [];
+  try {
+    const models = await getData(
+      session,
+      `/console/enterprises/${encodeURIComponent(enterpriseId)}/config/models`,
+      signal
+    );
+    return Array.isArray(models) ? models : [];
+  } catch {
+    return [];
+  }
+}
+function mergeCatalog(config, enterpriseModels) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const model of config.models ?? [])
+    if (model.id) byId.set(model.id, model);
+  for (const model of enterpriseModels)
+    if (model.id) byId.set(model.id, { ...byId.get(model.id), ...model });
+  const cliModels = config.agents?.find(
+    (agent) => agent.name === "cli"
+  )?.models;
+  const enterpriseChat = enterpriseModels.filter((model) => model.tags?.includes(CHAT_TAG)).map((model) => model.id);
+  const allowed = cliModels ? [
+    ...enterpriseChat.filter((id) => !cliModels.includes(id)).reverse(),
+    ...cliModels
+  ] : void 0;
+  if (!allowed) return [...byId.values()];
+  return allowed.map((id) => byId.get(id)).filter((model) => model !== void 0);
+}
+async function fetchRemoteModels(session, signal) {
+  const [config, enterpriseModels] = await Promise.all([
+    getData(session, "/v3/config", signal),
+    fetchEnterpriseModels(session, signal)
+  ]);
+  const models = mergeCatalog(config ?? {}, enterpriseModels);
+  remember(session.endpoint, models);
+  writeModelCache(session.endpoint, models);
+  return models;
+}
+function isEffort(value) {
+  return VALID_EFFORTS.includes(value);
+}
+function supportedEfforts(model) {
+  const declared = model.reasoning?.supportedEfforts;
+  if (Array.isArray(declared)) return declared.filter(isEffort);
+  const map = model.thinkingLevelMap;
+  if (!map) return [...DEFAULT_EFFORTS];
+  const top = map.max != null ? "max" : map.xhigh != null ? "xhigh" : "high";
+  return VALID_EFFORTS.slice(0, VALID_EFFORTS.indexOf(top) + 1);
+}
+function wireEffort(model, effort) {
+  return model.thinkingLevelMap?.[effort] ?? effort;
+}
+function isResponsesApi(api) {
+  return api !== void 0 && RESPONSES_APIS.has(api);
+}
+function modelBaseUrl(model, endpoint) {
+  if (!model.url) return `${endpoint}/v2`;
+  const suffix = isResponsesApi(model.api) ? "/responses" : "/chat/completions";
+  let base = model.url.trim().replace(/[?#].*$/, "").replace(/\/+$/, "");
+  while (base.endsWith(suffix))
+    base = base.slice(0, -suffix.length).replace(/\/+$/, "");
+  return base;
+}
+function toProviderModel(model, endpoint) {
+  const reasoning = model.supportsReasoning === true;
+  const efforts = reasoning ? supportedEfforts(model) : [];
+  const credits = model.credits?.trim();
+  const defaultEffort = isEffort(model.reasoning?.effort) && efforts.includes(model.reasoning.effort) ? model.reasoning.effort : void 0;
+  const effortMap = Object.fromEntries(
+    efforts.map((effort) => [effort, wireEffort(model, effort)])
+  );
+  const config = {
+    id: model.id,
+    name: credits ? `${model.name ?? model.id} (${credits})` : model.name ?? model.id,
+    api: CODEBUDDY_API,
+    baseUrl: modelBaseUrl(model, endpoint),
+    reasoning: reasoning && efforts.length > 0,
+    input: model.supportsImages ? ["text", "image"] : ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: model.maxInputTokens ?? 128e3,
+    maxTokens: model.maxOutputTokens ?? 16e3,
+    // pi: level → reasoning_effort value; null marks a level unsupported, `off` sends "none" like the CLI.
+    thinkingLevelMap: efforts.length > 0 ? {
+      off: "none",
+      ...Object.fromEntries(
+        VALID_EFFORTS.map((effort) => [
+          effort,
+          effortMap[effort] ?? null
+        ])
+      )
+    } : void 0,
+    // omp: the same ladder for its effort-based thinking control. `requiresEffort: false` stops omp's
+    // lineage rules from clamping "off" to the lowest effort; the server accepts "none".
+    thinking: efforts.length > 0 ? {
+      mode: "effort",
+      efforts,
+      defaultLevel: defaultEffort,
+      effortMap,
+      requiresEffort: false
+    } : void 0,
+    compat: {
+      supportsStore: false,
+      supportsDeveloperRole: false,
+      supportsReasoningEffort: efforts.length > 0,
+      reasoningDisableMode: efforts.length > 0 ? "none-effort" : void 0,
+      supportsUsageInStreaming: true,
+      maxTokensField: "max_tokens"
+    }
+  };
+  return config;
+}
+
+// src/credits.ts
+var CREDIT_USAGE_FIELD = "codebuddyCredit";
+function scanLine(line, meter) {
+  if (!line.startsWith("data:") || !line.includes('"credit"')) return;
+  try {
+    const credit = numberField(JSON.parse(line.slice(5)), "usage", "credit");
+    if (credit !== void 0) meter.credit = credit;
+  } catch {
+  }
+}
+function creditScanner(meter) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const scan = (text, flush) => {
+    buffer += text;
+    const lines = buffer.split(/\r?\n/);
+    buffer = flush ? "" : lines.pop() ?? "";
+    for (const line of lines) scanLine(line, meter);
+  };
+  return new TransformStream({
+    transform(chunk, controller) {
+      scan(decoder.decode(chunk, { stream: true }), false);
+      controller.enqueue(chunk);
+    },
+    flush() {
+      scan(decoder.decode(), true);
+    }
+  });
+}
+function creditFetch(meter, base = fetch) {
+  return async (input, init) => {
+    const response = await base(input, init);
+    if (!response.body) return response;
+    return new Response(response.body.pipeThrough(creditScanner(meter)), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+}
+function attachCredit(inner, meter) {
+  const outer = createAssistantMessageEventStream();
+  const stamp = (message) => {
+    if (meter.credit !== void 0)
+      Object.assign(message.usage, { [CREDIT_USAGE_FIELD]: meter.credit });
+  };
+  const ZERO_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+  void (async () => {
+    let partial;
+    try {
+      for await (const event of inner) {
+        if (event.type === "done") stamp(event.message);
+        else if (event.type === "error") stamp(event.error);
+        else partial = event.partial;
+        outer.push(event);
+      }
+    } catch (error) {
+      const message = {
+        ...partial ?? {
+          role: "assistant",
+          content: [],
+          api: CODEBUDDY_API,
+          provider: "codebuddy",
+          model: "unknown",
+          usage: ZERO_USAGE,
+          timestamp: Date.now()
+        },
+        content: [],
+        usage: partial?.usage ?? ZERO_USAGE,
+        stopReason: "error",
+        errorMessage: error instanceof Error ? error.message : String(error),
+        timestamp: partial?.timestamp ?? Date.now()
+      };
+      outer.push({ type: "error", reason: "error", error: message });
+    } finally {
+      outer.end();
+    }
+  })();
+  return outer;
+}
+function messageCredit(message) {
+  return numberField(message, "usage", CREDIT_USAGE_FIELD);
+}
+function accumulateMessage(credits, sum, message) {
+  if (field(message, "role") !== "assistant" || !isCodeBuddyProvider(field(message, "provider")))
+    return;
+  const credit = messageCredit(message);
+  if (credit === void 0) {
+    credits.unknown++;
+    return;
+  }
+  sum.value += credit;
+  credits.charged++;
+  credits.last = credit;
+}
+function collectSessionCredits(entries) {
+  const credits = { total: 0, charged: 0, unknown: 0 };
+  const sum = { value: 0 };
+  for (const entry of entries) {
+    if (field(entry, "type") !== "message") continue;
+    accumulateMessage(credits, sum, field(entry, "message"));
+  }
+  credits.total = roundCredit(sum.value);
+  return credits;
+}
+function roundCredit(value) {
+  return Math.round(100 * value) / 100;
+}
+function formatSessionCredits(credits) {
+  const unknown = credits.unknown ? ` (${credits.unknown} without charge info)` : "";
+  return `CodeBuddy session: ${credits.total} credits${unknown}`;
+}
+
+// src/quota.ts
+var PACKAGE_STATUS_VALID = 0;
+var PACKAGE_STATUS_USED_UP = 3;
+var CAPACITY_TYPE_SLICE = 4;
+var UNLIMITED = -1;
+var PACKAGE_CODES = [
+  "TCACA_code_001_PqouKr6QWV",
+  // free (trial)
+  "TCACA_code_002_AkiJS3ZHF5",
+  // pro monthly
+  "TCACA_code_003_FAnt7lcmRT",
+  // pro yearly
+  "TCACA_code_006_DbXS0lrypC",
+  // gift pack
+  "TCACA_code_007_nzdH5h4Nl0",
+  // activity pack
+  "TCACA_code_008_cfWoLwvjU4",
+  // free monthly (experience plan)
+  "TCACA_code_009_0XmEQc2xOf",
+  // legacy top-up
+  "TCACA_code_023_4xbGhMrE6q",
+  "TCACA_code_026_BaESVICNoi",
+  "TCACA_code_027_0FCGVA6vSa",
+  "TCACA_code_028_NtpWi0jzXs",
+  // version bonus
+  "TCACA_code_029_6wCGEWquYy",
+  // failure compensation
+  "TCACA_code_030_BjSt89qTvr",
+  // new-user bonus
+  "TCACA_code_035_ArVxJcGDsm",
+  // free subscription
+  "TCACA_code_036_lupO5WgNdG",
+  // 500-credit top-up
+  "TCACA_code_037_WxOD3MpI2o",
+  // version bonus
+  "TCACA_code_038_OhvqZtiPKr",
+  // custom top-up
+  "TCACA_code_039_KRcQj7wUat",
+  // pro trial monthly
+  "TCACA_code_040_mi9rCYg46x",
+  // pro trial yearly
+  "TCACA_code_043_6oIkxT7Z0S",
+  "TCACA_code_043_6olxxT7Z0S",
+  "TCACA_code_044_JRZ9sYCgua",
+  // 200-credit top-up
+  "TCACA_code_045_JuyAXGlovx",
+  // 5000-credit top-up
+  "TCACA_code_046_LfNpbzEa5X"
+  // 10000-credit top-up
+];
+async function postBilling(session, path, body, signal) {
+  const envelope = await requestEnvelope(
+    `${session.endpoint}/billing/meter/${path}`,
+    {
+      method: "POST",
+      headers: {
+        ...identityHeaders(session),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    },
+    signal
+  );
+  if (envelope.code !== 0)
+    throw new Error(
+      `CodeBuddy ${path} failed (code ${envelope.code}): ${envelope.msg ?? "unknown error"}`
+    );
+  return envelope.data;
+}
+function parseEnterpriseUsage(data) {
+  const limitNum = numberField(data, "limitNum");
+  const unlimited = limitNum === UNLIMITED;
+  const hasGift = field(data, "exclusiveGift", "hasGift") === true;
+  const giftUsed = hasGift ? numberField(data, "exclusiveGift", "usedCredits") ?? 0 : 0;
+  const giftTotal = hasGift ? numberField(data, "exclusiveGift", "totalCredits") ?? 0 : 0;
+  return {
+    kind: "enterprise",
+    used: roundCredit((numberField(data, "credit") ?? 0) + giftUsed),
+    limit: unlimited || limitNum === void 0 ? void 0 : roundCredit(limitNum + giftTotal),
+    cycleStart: stringField(data, "cycleStartTime"),
+    cycleEnd: stringField(data, "cycleEndTime"),
+    resetAt: stringField(data, "cycleResetTime") ?? stringField(data, "cycleEndTime")
+  };
+}
+function packageCapacity(account) {
+  const status = numberField(account, "Status");
+  if (status !== PACKAGE_STATUS_VALID && status !== PACKAGE_STATUS_USED_UP)
+    return void 0;
+  const today = numberField(account, "CapacityType") === CAPACITY_TYPE_SLICE ? arrayField(account, "SlicePeriodUsageDetails")[0] : void 0;
+  const total = today ? numberField(today, "SlicePeriodCapacitySizePrecise") : numberField(account, "CycleCapacitySizePrecise");
+  const left = today ? numberField(today, "SlicePeriodCapacityRemainPrecise") : numberField(account, "CycleCapacityRemainPrecise");
+  return total === void 0 || left === void 0 ? void 0 : { total, left };
+}
+function parsePersonalPackages(...responses) {
+  let total = 0;
+  let left = 0;
+  for (const data of responses) {
+    for (const account of arrayField(data, "Accounts")) {
+      const capacity = packageCapacity(account);
+      if (!capacity) continue;
+      total += capacity.total;
+      left += capacity.left;
+    }
+  }
+  return {
+    kind: "personal",
+    used: roundCredit(total - left),
+    limit: roundCredit(total)
+  };
+}
+function localDateTime(date, endOfDay) {
+  const pad = (value) => String(value).padStart(2, "0");
+  const day = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+  return `${day} ${endOfDay ? "23:59:59" : "00:00:00"}`;
+}
+async function fetchAccountQuota(session, signal) {
+  if (sessionEnterpriseId(session)) {
+    return parseEnterpriseUsage(
+      await postBilling(session, "get-enterprise-user-usage", {}, signal)
+    );
+  }
+  const now = /* @__PURE__ */ new Date();
+  const [paid, free] = await Promise.all([
+    postBilling(
+      session,
+      "get-user-resource-paid-packages",
+      {
+        PageNumber: 1,
+        PageSize: 200,
+        Status: [PACKAGE_STATUS_VALID, PACKAGE_STATUS_USED_UP],
+        PackageCodes: PACKAGE_CODES
+      },
+      signal
+    ),
+    postBilling(
+      session,
+      "get-user-resource-free-packages",
+      {
+        PageNumber: 1,
+        PageSize: 200,
+        Status: [PACKAGE_STATUS_VALID],
+        PackageCodes: PACKAGE_CODES,
+        SlicePeriodStartTime: localDateTime(now, false),
+        SlicePeriodEndTime: localDateTime(now, true)
+      },
+      signal
+    )
+  ]);
+  return parsePersonalPackages(paid, free);
+}
+function formatAccountQuota(quota) {
+  const allowance = quota.limit === void 0 ? "unlimited" : `${quota.limit}`;
+  return `CodeBuddy cycle: ${quota.used} / ${allowance} credits`;
+}
+function describeAccountQuota(quota) {
+  const lines = [formatAccountQuota(quota)];
+  if (quota.limit !== void 0 && quota.limit > 0) {
+    lines.push(
+      `Remaining: ${roundCredit(Math.max(0, quota.limit - quota.used))} credits (${(quota.used / quota.limit * 100).toFixed(1)}% used)`
+    );
+  }
+  if (quota.cycleStart && quota.cycleEnd)
+    lines.push(`Cycle: ${quota.cycleStart} \u2013 ${quota.cycleEnd}`);
+  if (quota.resetAt) lines.push(`Resets: ${quota.resetAt}`);
+  return lines;
+}
+var QuotaService = class _QuotaService {
+  states = /* @__PURE__ */ new Map();
+  checkedAt = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  fetchQuota;
+  ttlMs;
+  now;
+  constructor(fetchQuota = fetchAccountQuota, ttlMs = 6e4, now = Date.now) {
+    this.fetchQuota = fetchQuota;
+    this.ttlMs = ttlMs;
+    this.now = now;
+  }
+  /** Token refreshes keep the account; only a different endpoint or user resets the snapshot. */
+  static identity(session) {
+    return `${session.endpoint}|${session.uid ?? ""}|${sessionEnterpriseId(session) ?? ""}`;
+  }
+  peek(identity) {
+    return this.states.get(identity) ?? { status: "unavailable" };
+  }
+  read(session, force = false) {
+    const identity = _QuotaService.identity(session);
+    const state = this.peek(identity);
+    const checkedAt = this.checkedAt.get(identity);
+    const inflight = this.pending.get(identity);
+    if (inflight) return inflight;
+    if (!force && checkedAt !== void 0 && this.now() - checkedAt < this.ttlMs)
+      return Promise.resolve(state);
+    const request = this.fetchQuota(session, AbortSignal.timeout(1e4)).then((quota) => ({ status: "fresh", quota })).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      return state.status === "unavailable" ? { status: "unavailable", error: message } : { status: "stale", quota: state.quota, error: message };
+    }).then((next) => {
+      if (_QuotaService.identity(session) === identity) {
+        this.states.set(identity, next);
+        this.checkedAt.set(identity, this.now());
+        this.pending.delete(identity);
+      }
+      return next;
+    });
+    this.pending.set(identity, request);
+    return request;
+  }
+};
+
+// src/credit-display.ts
+var STATUS_KEY = "codebuddy-credits";
+var AUTH_TIMEOUT_MS = 1e4;
+function quotaText(state) {
+  if (state.status === "unavailable") return void 0;
+  return `${formatAccountQuota(state.quota)}${state.status === "stale" ? " [stale]" : ""}`;
+}
+function registerCreditDisplay(pi, service = new QuotaService()) {
+  let refreshId = 0;
+  let activeIdentity;
+  let credits = { total: 0, charged: 0, unknown: 0 };
+  const sum = { value: 0 };
+  const rebuildCredits = (ctx) => {
+    credits = { total: 0, charged: 0, unknown: 0 };
+    sum.value = 0;
+    for (const entry of ctx.sessionManager.getEntries()) {
+      if (field(entry, "type") !== "message") continue;
+      accumulateMessage(credits, sum, field(entry, "message"));
+    }
+  };
+  const isActive = (ctx) => /^codebuddy(-|$)/.test(ctx.model?.provider ?? "");
+  const publish = (ctx) => {
+    if (!ctx.hasUI) return;
+    credits.total = roundCredit(sum.value);
+    if (!isActive(ctx) && credits.charged + credits.unknown === 0) {
+      ctx.ui.setStatus(STATUS_KEY, void 0);
+      return;
+    }
+    const quota = activeIdentity ? quotaText(service.peek(activeIdentity)) : void 0;
+    ctx.ui.setStatus(
+      STATUS_KEY,
+      [formatSessionCredits(credits), quota].filter(Boolean).join(" \xB7 ")
+    );
+  };
+  const resolveSession = async (ctx) => {
+    if (!isActive(ctx) || !ctx.model?.provider) return void 0;
+    let timer;
+    try {
+      const token = await Promise.race([
+        ctx.modelRegistry.getApiKeyForProvider(ctx.model.provider),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(void 0), AUTH_TIMEOUT_MS);
+        })
+      ]);
+      const session = lookupSession(token);
+      if (session) activeIdentity = QuotaService.identity(session);
+      return session;
+    } catch {
+      return void 0;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const refresh = async (ctx, force = false) => {
+    const id = ++refreshId;
+    publish(ctx);
+    if (!isActive(ctx)) return;
+    const session = await resolveSession(ctx);
+    if (!session || id !== refreshId) return;
+    await service.read(session, force);
+    if (id === refreshId) publish(ctx);
+  };
+  pi.on("session_start", (_event, ctx) => {
+    rebuildCredits(ctx);
+    void refresh(ctx);
+  });
+  pi.on("message_end", (event, ctx) => {
+    accumulateMessage(credits, sum, event.message);
+    publish(ctx);
+  });
+  pi.on("agent_end", (_event, ctx) => void refresh(ctx, true));
+  pi.on("model_select", (_event, ctx) => void refresh(ctx));
+  pi.registerCommand("codebuddy-usage", {
+    description: "Show CodeBuddy credits spent in this session and every logged-in account's billing-cycle quota",
+    handler: async (_args, ctx) => {
+      const credits2 = collectSessionCredits(ctx.sessionManager.getEntries());
+      const lines = [
+        formatSessionCredits(credits2),
+        `Charged requests: ${credits2.charged}${credits2.last !== void 0 ? ` \xB7 last request: ${credits2.last} credits` : ""}`
+      ];
+      const session = await resolveSession(ctx);
+      if (!session) {
+        lines.push("Account quota: not logged in to CodeBuddy.");
+      } else {
+        const provider = providerById(ctx.model?.provider);
+        lines.push(`Account: ${provider?.label ?? ctx.model?.provider}`);
+        const state = await service.read(session, true);
+        if (state.status === "unavailable")
+          lines.push(
+            `Account quota unavailable: ${state.error ?? "unknown error"}`
+          );
+        else {
+          lines.push(...describeAccountQuota(state.quota));
+          if (state.status === "stale")
+            lines.push(
+              `Refresh failed (${state.error}); showing the last snapshot.`
+            );
+        }
+      }
+      for (const site of PROVIDERS) {
+        if (site.id === ctx.model?.provider) continue;
+        try {
+          const token = await ctx.modelRegistry.getApiKeyForProvider(site.id);
+          const other = lookupSession(token);
+          if (!other) continue;
+          const state = service.peek(QuotaService.identity(other));
+          const text = quotaText(state) ?? "quota not read yet";
+          lines.push(`${site.label}: ${text}`);
+        } catch {
+        }
+      }
+      ctx.ui.notify(lines.join("\n"), "info");
+      publish(ctx);
+    }
+  });
+}
+
+// src/stream.ts
+import { streamSimple } from "@earendil-works/pi-ai/compat";
+function streamCodeBuddy(model, context, options) {
+  const accessToken = options?.apiKey;
+  if (!accessToken)
+    throw new Error(
+      "CodeBuddy is not logged in. Run /login and select CodeBuddy."
+    );
+  const session = lookupSession(accessToken) ?? {
+    endpoint: new URL(model.baseUrl).origin,
+    accessToken
+  };
+  const remote = remoteModel(model.id, session.endpoint);
+  const modelApiKey = remote?.url ? remote.apiKey?.trim() : void 0;
+  const requestId = uuidv7Hex();
+  const target = {
+    ...model,
+    api: isResponsesApi(remote?.api) ? "openai-responses" : "openai-completions",
+    baseUrl: remote ? modelBaseUrl(remote, session.endpoint) : `${session.endpoint}/v2`,
+    // A model-level key replaces the CodeBuddy session, as in the CLI.
+    headers: modelApiKey ? { ...model.headers } : { ...model.headers, ...identityHeaders(session) }
+  };
+  const meter = {};
+  const inner = streamSimple(target, context, {
+    ...options,
+    fetch: creditFetch(meter, options?.fetch),
+    apiKey: modelApiKey || accessToken,
+    headers: modelApiKey ? options?.headers : {
+      ...options?.headers,
+      "X-Conversation-ID": options?.sessionId ?? crypto.randomUUID(),
+      "X-Conversation-Request-ID": requestId,
+      "X-Conversation-Message-ID": requestId,
+      "X-Request-ID": requestId,
+      "X-Agent-Intent": "craft"
+    }
+  });
+  return attachCredit(inner, meter);
+}
+
+// src/index.ts
+var STARTUP_FETCH_TIMEOUT_MS = 1e4;
+function rememberCredentials(credentials) {
+  const session = sessionFromCredentials(credentials);
+  rememberSession(session);
+  return session;
+}
+function toProviderModels(models, session) {
+  return models.map((model) => toProviderModel(model, session.endpoint));
+}
+function storedCredentials() {
+  try {
+    const auth = JSON.parse(
+      readFileSync2(join2(getAgentDir2(), "auth.json"), "utf8")
+    );
+    return Object.entries(auth).filter(([id]) => /^codebuddy(-|$)/.test(id)).map(([, value]) => value);
+  } catch {
+    return [];
+  }
+}
+function endpointFor(site) {
+  return site.endpoint ?? storedCredentials().find((credential) => credential.providerId === site.id)?.endpoint;
+}
+async function startupModelsFor(site) {
+  const endpoint = endpointFor(site);
+  if (!endpoint) return [];
+  if (!isModelCacheStale(endpoint)) return cachedModels(endpoint);
+  try {
+    const credential = storedCredentials().find(
+      (candidate) => candidate.type === "oauth" && candidate.endpoint === endpoint
+    );
+    if (!credential || credential.expires <= Date.now())
+      return cachedModels(endpoint);
+    const session = rememberCredentials(credential);
+    return toProviderModels(
+      await fetchRemoteModels(
+        session,
+        AbortSignal.timeout(STARTUP_FETCH_TIMEOUT_MS)
+      ),
+      session
+    );
+  } catch {
+    return cachedModels(endpoint);
+  }
+}
+async function codebuddyExtension(pi) {
+  const buildConfig = (site, models) => {
+    const config = {
+      name: site.label,
+      baseUrl: models[0]?.baseUrl,
+      api: CODEBUDDY_API,
+      streamSimple: streamCodeBuddy,
+      models,
+      oauth: {
+        name: site.label,
+        isSubscription: true,
+        async login(callbacks) {
+          const credentials = await loginCodeBuddy(site, callbacks);
+          const session = rememberCredentials(credentials);
+          try {
+            callbacks.onProgress?.("Fetching CodeBuddy models...");
+            const remote = await fetchRemoteModels(session, callbacks.signal);
+            pi.registerProvider(
+              site.id,
+              buildConfig(site, toProviderModels(remote, session))
+            );
+          } catch (error) {
+            callbacks.onProgress?.(
+              `Logged in, but fetching models failed: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+          return credentials;
+        },
+        async refreshToken(credentials, signal) {
+          const refreshed = await refreshCodeBuddy(
+            credentials,
+            signal
+          );
+          rememberCredentials(refreshed);
+          return refreshed;
+        },
+        getApiKey(credentials) {
+          rememberCredentials(credentials);
+          return credentials.access;
+        }
+      },
+      // pi: invoked with the stored credential when the catalog refreshes.
+      async refreshModels(context) {
+        const credential = context.credential;
+        if (context.allowNetwork && credential?.type === "oauth" && credential.endpoint) {
+          const session = rememberCredentials(
+            credential
+          );
+          return toProviderModels(
+            await fetchRemoteModels(session, context.signal),
+            session
+          );
+        }
+        const endpoint = credential?.type === "oauth" ? credential.endpoint : site.endpoint;
+        return endpoint ? cachedModels(endpoint) : [];
+      },
+      // omp: invoked with the raw stored access token.
+      async fetchDynamicModels(apiKey) {
+        const session = lookupSession(apiKey);
+        if (!session) return cachedModels(site.endpoint ?? "");
+        try {
+          return toProviderModels(await fetchRemoteModels(session), session);
+        } catch {
+          return cachedModels(session.endpoint);
+        }
+      }
+    };
+    return config;
+  };
+  await Promise.all(
+    PROVIDERS.map(async (site) => {
+      pi.registerProvider(
+        site.id,
+        buildConfig(site, await startupModelsFor(site))
+      );
+    })
+  );
+  registerCreditDisplay(pi);
+  pi.on("session_start", async (_event, ctx) => {
+    const registry = ctx.modelRegistry;
+    if (typeof registry.getProviderAuth !== "function") return;
+    for (const site of PROVIDERS) {
+      const endpoint = endpointFor(site);
+      if (!endpoint || !isModelCacheStale(endpoint)) continue;
+      try {
+        await registry.refresh({
+          providers: [site.id],
+          allowNetwork: true,
+          force: true
+        });
+      } catch {
+      }
+    }
+  });
+}
+export {
+  codebuddyExtension as default,
+  endpointFor,
+  startupModelsFor,
+  storedCredentials
+};