@wayner6/pi-usage 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wayner6/pi-usage",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "publishConfig": {
     "access": "public"
   },

package/src/modules/provider/adapters/cliproxy-pi-bridge.ts

@@ -1,6 +1,6 @@
 import type { Metric, UsageAdapter, UsageSnapshot } from "../../../core/types.ts";
 import { bridgeUrl, safeError, sameOriginFetch } from "../../../core/security.ts";
-import { isAccountRelevantToModels } from "../matching.ts";
+import { isAccountRelevantToModels, isGroupRelevantToModels, deduplicateSharedQuotaGroups } from "../matching.ts";
 
 const NATIVE_PROVIDER_IDS = new Set(["deepseek", "openai-codex", "xai", "anthropic", "glm", "zai", "zai-coding-cn"]);
 
@@ -64,22 +64,35 @@ export const cliProxyBridgeAdapter: UsageAdapter = {
       if (!response.ok) throw new Error(`pi-bridge returned HTTP ${response.status}`);
       const data = await response.json() as BridgeUsage;
       if (data.schemaVersion !== 1) return { adapterId: this.id, sourceProviderId: target.providerId, displayName: target.providerId, state: "incompatible", fetchedAt, accounts: [], error: `Unsupported pi-bridge schemaVersion ${String(data.schemaVersion)}` };
-      let accounts = (data.accounts ?? []).map((account, index) => ({
-        id: account.authIndex ?? `${account.provider ?? "provider"}-${index}`,
-        provider: account.provider ?? "unknown",
-        label: account.label || account.account || account.provider || `Account ${index + 1}`,
-        ...(account.status ? { status: account.status } : {}),
-        ...(account.disabled !== undefined ? { disabled: account.disabled } : {}),
-        ...(account.unavailable !== undefined ? { unavailable: account.unavailable } : {}),
-        metrics: metrics(account.groups ?? []),
-        rawGroups: account.groups,
-        ...(account.error ? { error: account.error } : {}),
-      }));
+      let accounts = (data.accounts ?? [])
+        .map((account, index) => {
+          let rawGroups = account.groups ?? [];
 
-      // Filter accounts based on user-configured models for this provider in Pi
-      if (target.configuredModelIds && target.configuredModelIds.length > 0) {
-        accounts = accounts.filter((account) => isAccountRelevantToModels(account, target.configuredModelIds));
-      }
+          // 1. Filter groups within this account if user configured specific models
+          if (target.configuredModelIds && target.configuredModelIds.length > 0) {
+            rawGroups = rawGroups.filter((g) => isGroupRelevantToModels(g, target.configuredModelIds));
+          }
+
+          // 2. Deduplicate shared quota pools (groups with identical remaining fraction and reset time)
+          const deduplicatedGroups = deduplicateSharedQuotaGroups(rawGroups);
+
+          return {
+            id: account.authIndex ?? `${account.provider ?? "provider"}-${index}`,
+            provider: account.provider ?? "unknown",
+            label: account.label || account.account || account.provider || `Account ${index + 1}`,
+            ...(account.status ? { status: account.status } : {}),
+            ...(account.disabled !== undefined ? { disabled: account.disabled } : {}),
+            ...(account.unavailable !== undefined ? { unavailable: account.unavailable } : {}),
+            metrics: metrics(deduplicatedGroups),
+            rawGroups: deduplicatedGroups,
+            ...(account.error ? { error: account.error } : {}),
+          };
+        })
+        // 3. Filter out accounts that have no relevant groups or aren't relevant to user models
+        .filter((account) => {
+          if (!target.configuredModelIds || target.configuredModelIds.length === 0) return true;
+          return isAccountRelevantToModels(account, target.configuredModelIds) && account.metrics.length > 0;
+        });
 
       return {
         adapterId: this.id,

package/src/modules/provider/controller.ts

@@ -75,17 +75,45 @@ export class ProviderUsageController {
   }
 
   async refreshAll(ctx: ExtensionContext, force = false): Promise<UsageSnapshot[]> {
-    const providerIds = new Set(ctx.modelRegistry.getAvailable().map((model) => model.provider));
-    for (const id of ctx.modelRegistry.getRegisteredProviderIds()) providerIds.add(id);
-    if (ctx.modelRegistry.getProviderAuthStatus("deepseek").configured) providerIds.add("deepseek");
-    if (ctx.modelRegistry.getProviderAuthStatus("openai-codex").configured) providerIds.add("openai-codex");
-    if (ctx.modelRegistry.getProviderAuthStatus("xai").configured) providerIds.add("xai");
-    if (ctx.modelRegistry.getProviderAuthStatus("anthropic").configured) providerIds.add("anthropic");
-    if (ctx.modelRegistry.getProviderAuthStatus("zai-coding-cn").configured) providerIds.add("zai-coding-cn");
-    if (ctx.modelRegistry.getProviderAuthStatus("zai").configured) providerIds.add("zai");
-    if (ctx.modelRegistry.getProviderAuthStatus("glm").configured) providerIds.add("glm");
-    for (const id of Object.keys(this.config.providerOverrides)) providerIds.add(id);
-    if (ctx.model) providerIds.add(ctx.model.provider);
+    const providerIds = new Set<string>();
+
+    // 1. Providers that have available models registered
+    for (const model of ctx.modelRegistry.getAvailable()) {
+      if (model.provider) providerIds.add(model.provider);
+    }
+
+    // 2. Providers explicitly registered or configured in auth
+    for (const id of ctx.modelRegistry.getRegisteredProviderIds()) {
+      // Only include if provider is actively configured with credentials
+      if (ctx.modelRegistry.getProviderAuthStatus(id).configured) {
+        providerIds.add(id);
+      }
+    }
+
+    // 3. Known standard providers with configured auth
+    const knownProviders = [
+      "deepseek",
+      "openai-codex",
+      "xai",
+      "anthropic",
+      "zai-coding-cn",
+      "zai",
+      "glm",
+    ];
+    for (const id of knownProviders) {
+      if (ctx.modelRegistry.getProviderAuthStatus(id).configured) {
+        providerIds.add(id);
+      }
+    }
+
+    // 4. Config overrides & active model provider
+    for (const id of Object.keys(this.config.providerOverrides)) {
+      providerIds.add(id);
+    }
+    if (ctx.model?.provider) {
+      providerIds.add(ctx.model.provider);
+    }
+
     const targets = await Promise.all([...providerIds].map((id) => this.target(ctx, id)));
     const snapshots = await Promise.all(targets.map((target) => this.fetchTarget(target, force)));
     return snapshots.filter((snapshot) => snapshot.state !== "unsupported");

package/src/modules/provider/matching.ts

@@ -290,3 +290,170 @@ export function isAccountRelevantToModels(
   return false;
 }
 
+/**
+ * Determines whether a specific group in a proxy account is relevant to
+ * the user's configured models.
+ */
+export function isGroupRelevantToModels(
+  group: RawBridgeGroup,
+  configuredModelIds?: string[],
+): boolean {
+  if (!configuredModelIds || configuredModelIds.length === 0) return true;
+
+  const targetTokens = new Set(configuredModelIds.flatMap(tokenizeModelId));
+  const modelKeywords = [
+    "claude", "gemini", "codex", "gpt", "openai", "deepseek", "kimi", "moonshot", "grok", "xai",
+    "thinking", "flash", "pro", "opus", "sonnet", "haiku", "turbo", "mini", "reasoning",
+  ];
+
+  // Distinct tier tokens that shouldn't cross-match (e.g. 'pro' vs 'flash')
+  const tierTokens = ["pro", "flash", "thinking", "opus", "sonnet", "haiku"];
+
+  // 1. Check models explicitly listed inside the group
+  for (const m of group.models ?? []) {
+    const mid = (m.id ?? "").trim().toLowerCase();
+    if (!mid) continue;
+
+    for (const targetId of configuredModelIds) {
+      const tid = targetId.trim().toLowerCase();
+      if (mid === tid || tid.includes(mid) || mid.includes(tid)) return true;
+
+      const mTokens = tokenizeModelId(mid);
+      const overlap = mTokens.filter((t) => targetTokens.has(t));
+
+      // Guard: If group model has 'pro' but target only has 'flash', skip unless other strong overlap
+      const mHasPro = mTokens.includes("pro");
+      const tHasPro = tokenizeModelId(tid).includes("pro");
+      if (mHasPro !== tHasPro && (mTokens.includes("flash") || tokenizeModelId(tid).includes("flash"))) {
+        continue;
+      }
+
+      if (overlap.length >= 2 || overlap.some((t) => modelKeywords.includes(t) && !tierTokens.includes(t))) {
+        return true;
+      }
+    }
+  }
+
+  // 2. Check group label and id
+  const gTokens = tokenizeModelId(`${group.id ?? ""} ${group.label ?? ""}`);
+
+  // Distinct tier check: if group says 'pro' but user configured models don't have 'pro', reject
+  for (const tier of tierTokens) {
+    if (gTokens.includes(tier)) {
+      if (targetTokens.has(tier)) return true;
+      // Group has this tier keyword, but user configured models don't
+      return false;
+    }
+  }
+
+  // General model token overlap
+  const gOverlap = gTokens.filter((t) => targetTokens.has(t));
+  return gOverlap.length >= 2 || gOverlap.some((t) => modelKeywords.includes(t));
+}
+
+/**
+ * Resolves a friendly, high-level group label based on the models contained
+ * inside this quota group.
+ * E.g., if a group contains 'gemini-2.5-pro' and 'gemini-3.1-pro', label it "Gemini".
+ * If it contains 'claude-opus-4-6-thinking', 'claude-sonnet-4-6', and 'gpt-oss-120b-medium',
+ * label it "Claude / GPT".
+ */
+export function resolveGroupFamilyLabel(group: RawBridgeGroup): string {
+  const models = group.models ?? [];
+  const families = new Set<string>();
+
+  for (const m of models) {
+    const text = `${m.id ?? ""} ${m.displayName ?? ""}`.toLowerCase();
+    if (text.includes("gemini")) families.add("Gemini");
+    else if (text.includes("claude")) families.add("Claude");
+    else if (text.includes("gpt") || text.includes("openai")) families.add("GPT");
+    else if (text.includes("codex")) families.add("Codex");
+    else if (text.includes("deepseek")) families.add("DeepSeek");
+    else if (text.includes("kimi") || text.includes("moonshot")) families.add("Kimi");
+    else if (text.includes("grok") || text.includes("xai")) families.add("Grok");
+    else if (text.includes("glm") || text.includes("zhipu")) families.add("GLM");
+  }
+
+  // Also check the group id and label if models didn't provide family clues
+  const gText = `${group.id ?? ""} ${group.label ?? ""}`.toLowerCase();
+  if (gText.includes("gemini")) families.add("Gemini");
+  if (gText.includes("claude")) families.add("Claude");
+  if (gText.includes("gpt")) families.add("GPT");
+  if (gText.includes("codex")) families.add("Codex");
+  if (gText.includes("pro") || gText.includes("flash")) {
+    if (!families.has("Claude") && !families.has("GPT") && !families.has("Codex")) {
+      families.add("Gemini");
+    }
+  }
+  if (gText.includes("thinking") || gText.includes("other")) {
+    if (!families.has("Gemini")) {
+      families.add("Claude");
+    }
+  }
+
+  if (families.size > 0) {
+    const order = ["Gemini", "Claude", "GPT", "Codex", "DeepSeek", "Kimi", "Grok", "GLM"];
+    const sorted = order.filter((f) => families.has(f));
+    return sorted.join(" / ");
+  }
+
+  return group.label || group.id || "Quota";
+}
+
+/**
+ * Deduplicates groups in the same account that share the exact same quota pool
+ * (identical remaining fraction and identical reset time),
+ * and computes clean, friendly family labels (e.g. "Gemini", "Claude / GPT").
+ */
+export function deduplicateSharedQuotaGroups(groups: RawBridgeGroup[]): RawBridgeGroup[] {
+  const result: RawBridgeGroup[] = [];
+  const visited = new Set<number>();
+
+  for (let i = 0; i < groups.length; i++) {
+    if (visited.has(i)) continue;
+    const current = groups[i]!;
+    const matchingIndices: number[] = [i];
+
+    for (let j = i + 1; j < groups.length; j++) {
+      if (visited.has(j)) continue;
+      const other = groups[j]!;
+
+      // Compare remainingFraction and resetTime
+      if (
+        typeof current.remainingFraction === "number" &&
+        typeof other.remainingFraction === "number" &&
+        Math.abs(current.remainingFraction - other.remainingFraction) < 0.0001 &&
+        current.resetTime === other.resetTime
+      ) {
+        matchingIndices.push(j);
+      }
+    }
+
+    if (matchingIndices.length === 1) {
+      result.push({
+        ...current,
+        label: resolveGroupFamilyLabel(current),
+      });
+      visited.add(i);
+    } else {
+      const matchedGroups = matchingIndices.map((idx) => groups[idx]!);
+      for (const idx of matchingIndices) visited.add(idx);
+
+      const allModels = matchedGroups.flatMap((g) => g.models ?? []);
+      const mergedGroup: RawBridgeGroup = {
+        ...current,
+        id: matchedGroups.map((g) => g.id).filter(Boolean).join("+"),
+        models: allModels,
+      };
+
+      result.push({
+        ...mergedGroup,
+        label: resolveGroupFamilyLabel(mergedGroup),
+      });
+    }
+  }
+
+  return result;
+}
+
+