@wayner6/pi-usage 0.1.1 → 0.1.3

package/README.md

@@ -1,89 +1,97 @@
 # Pi Usage
 
-**Real-time provider balances, quota windows, and rate limits for [Pi](https://github.com/earendil-works/pi-mono) and [pi-web](https://github.com/agegr/pi-web).**
+[中文文档](./README_zh.md)
 
-[简体中文文档](./README_zh.md)
+Pi Usage is a [Pi](https://github.com/earendil-works/pi-mono) and [pi-web](https://github.com/agegr/pi-web) plugin that shows the balance or quota of the provider behind the active model.
 
----
+## What it shows
 
-## Supported Providers & Authentication Types
+- A compact status line for the active model, such as `Codex · 5h 92% · 7d 85%`.
+- Remaining balance, rate-limit windows, and reset times when the provider exposes them.
+- Details for every configured provider through `/usage`.
 
-| Provider / Target | Auth Type | Monitored Quota / Balance Data |
-| :--- | :--- | :--- |
-| **OpenAI Codex** | **OAuth** (ChatGPT Plus / Pro) | Official 5-hour and 7-day sliding quota windows with reset countdowns |
-| **xAI / Grok** | **OAuth** | Identity verification and active spending/credit limit status probe |
-| **Anthropic Claude** | **OAuth** / **API Key** | Claude Pro/Max OAuth subscription detection or official API Key rate limits via headers |
-| **DeepSeek Direct** | **API Key** | Exact account monetary balance (granted + topped-up in CNY/USD) |
-| **GLM / 智谱 BigModel** | **API Key** | Coding Plan multi-tier sliding windows (5h, 7d, MCP); notice displayed if using standard Pay-as-you-go key (official API only supports quota display for Coding Plan) |
-| **CLIProxyAPI Proxies** | **API Key / Bridge** | Upstream quota windows and reset intervals via server-side [`pi-bridge`](https://github.com/abix5/pi-cliproxyapi-bridge) |
+The display follows the active model. It does not turn request failures into a zero balance.
 
----
+## Supported providers
 
-## Key Features
+| Provider | Authentication | Available information |
+| --- | --- | --- |
+| OpenAI Codex | ChatGPT Plus/Pro OAuth | 5-hour and 7-day quota windows |
+| xAI / Grok | OAuth | Account verification and spending-limit status |
+| Anthropic Claude | Claude OAuth or API key | Subscription status or API rate-limit headers |
+| DeepSeek | API key | Account balance |
+| GLM / Zhipu BigModel | API key | Coding Plan quota windows; standard pay-as-you-go keys cannot be queried through the official API |
+| CLIProxyAPI | `pi-bridge` | Upstream quota windows and reset times |
 
-- **Real-Time Quota & Multi-Window Tracking**: Automatically monitors balances, subscription states, and multiple sliding windows (e.g. `Codex 5h 92% · 7d 85%`) tailored to your currently active model.
-- **Privacy & Security First**: Zero browser cookies, telemetry, or external proxies—reuses your local Pi credentials securely with strict same-origin protection.
+Pi Usage uses Pi's existing provider authentication. CLIProxyAPI is queried through server-side [`pi-bridge`](https://github.com/abix5/pi-cliproxyapi-bridge); its Management Key is never read or stored by this plugin.
 
----
+## Install
 
-## Installation
+Choose one installation source.
 
-### Method 1: Install in Pi (CLI / TUI)
+### npm
 
-Run the following command directly in your terminal:
+In Pi's terminal:
 
 ```bash
 pi install npm:@wayner6/pi-usage
 ```
 
-### Method 2: Install in pi-web (Web Interface)
+In pi-web: open **Settings** → **Plugins** → **Add Plugin**, enter the following in **Source**, choose `global`, then select **Install**:
 
-1. Open **Settings** (设置) at the bottom left -> **Plugins** (插件).
-2. Click **+ Add Plugin** (添加插件).
-3. In the **Source** input box, enter:
 ```text
 npm:@wayner6/pi-usage
 ```
-4. Choose `global` scope, then click **Install** (安装).
 
----
+### GitHub
 
-## Usage & Refresh Behavior
+In Pi's terminal:
 
-### Refresh Mechanism
-1. **Automatic Refresh on Dialogue**:
-   - In both `pi` and `pi-web`, **starting a conversation (sending any prompt) automatically refreshes and streams the latest balance/quota** for the active model.
-2. **Model Switching in pi-web**:
-   - When switching models while the agent is idle, the footer quota updates **automatically on your next prompt**.
-   - To refresh immediately without sending a message, click **"Reload Session"** (重载会话) in the menu or sidebar.
-3. **Background Updates**:
-   - Polls and updates countdowns periodically in the background (default: every 120s).
+```bash
+pi install github:wayner6/pi-usage
+```
+
+In pi-web: open **Settings** → **Plugins** → **Add Plugin**, enter the following in **Source**, choose `global`, then select **Install**:
+
+```text
+git:https://github.com/wayner6/pi-usage
+```
 
-### Available Commands
+After installing or updating the plugin, reload the session if it is already open.
 
-Type `/usage` or `/quota` in the chat input:
+## Use
 
-| Command | Description |
-| :--- | :--- |
-| `/usage` | Show aggregated balance and quota details for all configured providers |
-| `/usage current` | Show usage details specifically for the currently active model |
-| `/usage refresh` | Force an immediate network refresh for the current provider |
-| `/usage doctor` | Diagnose adapter states, provider authentication, and bridge connectivity |
-| `/usage settings` | View or adjust configuration (status bar, widget, intervals) |
+Send a normal message to refresh the quota for the active model. The status line then updates automatically.
 
-### Configuration Options
+In pi-web, an idle model switch is applied when the next message is sent. To refresh it immediately, use **Reload Session**.
+
+Use these commands in the chat input:
+
+| Command | Result |
+| --- | --- |
+| `/usage` or `/quota` | Show all available provider balances and quotas |
+| `/usage current` | Show the active model's provider only |
+| `/usage refresh` | Refresh the active provider now |
+| `/usage doctor` | Show authentication, adapter, and bridge diagnostics |
+| `/usage settings` | Show current plugin settings |
+
+## Settings
+
+Settings are optional. Use `/usage settings` followed by one of these commands:
 
-Adjust preferences directly in chat via `/usage settings`:
 ```text
-/usage settings status on|off       # Toggle the compact footer status line (Default: on)
-/usage settings widget on|off       # Toggle the detailed persistent widget (Default: off)
-/usage settings interval <seconds>  # Set background polling interval (Default: 120s)
-/usage settings timeout <seconds>   # Set request timeout (Default: 10s)
+/usage settings status on|off       # status line; on by default
+/usage settings widget on|off       # detailed widget; off by default
+/usage settings interval <seconds>  # refresh interval; 120 by default
+/usage settings timeout <seconds>   # request timeout; 10 by default
 ```
-Configuration is automatically saved to `~/.pi/agent/pi-usage/config.json`.
 
----
+Settings are stored locally at `~/.pi/agent/pi-usage/config.json`.
+
+## Privacy
+
+The plugin does not use browser cookies, telemetry, cloud synchronization, or third-party credential forwarding. Requests to provider APIs stay on the provider's official origin.
 
 ## License
 
-MIT License. See [LICENSE](./LICENSE) for details.
+[MIT](./LICENSE)

package/package.json

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

package/src/core/types.ts

@@ -50,6 +50,7 @@ export interface ProviderTarget {
   provider?: Provider<Api>;
   baseUrl?: string;
   auth?: AuthResult;
+  configuredModelIds?: string[];
 }
 
 export interface FetchContext {

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

@@ -1,5 +1,8 @@
 import type { Metric, UsageAdapter, UsageSnapshot } from "../../../core/types.ts";
 import { bridgeUrl, safeError, sameOriginFetch } from "../../../core/security.ts";
+import { isAccountRelevantToModels } from "../matching.ts";
+
+const NATIVE_PROVIDER_IDS = new Set(["deepseek", "openai-codex", "xai", "anthropic", "glm", "zai", "zai-coding-cn"]);
 
 type BridgeGroup = { id?: string; label?: string; remainingFraction?: number; resetTime?: string; models?: Array<{ id?: string; displayName?: string; remainingFraction?: number; resetTime?: string }> };
 type BridgeAccount = { provider?: string; account?: string; authIndex?: string; label?: string; status?: string; disabled?: boolean; unavailable?: boolean; supported?: boolean; error?: string; groups?: BridgeGroup[] };
@@ -18,17 +21,30 @@ export const cliProxyBridgeAdapter: UsageAdapter = {
   id: "cliproxy-pi-bridge",
   label: "CLIProxyAPI / pi-bridge",
   canHandle(target) {
-    // 1. If explicit baseUrl exists and is not official deepseek/openai, it's a potential bridge target
+    const pid = target.providerId.toLowerCase();
+    // Never hijack standard native providers unless explicitly configured as a bridge proxy
+    if (NATIVE_PROVIDER_IDS.has(pid)) return false;
+
+    // If explicit baseUrl exists, make sure it's not pointing to official provider APIs
     if (target.baseUrl) {
       try {
         const url = new URL(target.baseUrl);
-        if (url.origin.includes("deepseek.com")) return false;
+        if (
+          url.origin.includes("deepseek.com") ||
+          url.origin.includes("openai.com") ||
+          url.origin.includes("chatgpt.com") ||
+          url.origin.includes("anthropic.com") ||
+          url.origin.includes("x.ai") ||
+          url.origin.includes("bigmodel.cn")
+        ) {
+          return false;
+        }
       } catch {
         return false;
       }
     }
-    const pid = target.providerId.toLowerCase();
-    // 2. Accept if providerId hints at proxy/bridge or if any custom baseUrl is present
+
+    // Accept if providerId hints at proxy/bridge or if any custom non-native baseUrl is present
     return pid.includes("cpa") || pid.includes("cliproxy") || pid.includes("bridge") || pid.includes("proxy") || Boolean(target.baseUrl);
   },
   async fetch({ target, signal, force, fetchFn }): Promise<UsageSnapshot> {
@@ -48,7 +64,7 @@ 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)}` };
-      const accounts = (data.accounts ?? []).map((account, index) => ({
+      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}`,
@@ -59,6 +75,12 @@ export const cliProxyBridgeAdapter: UsageAdapter = {
         rawGroups: account.groups,
         ...(account.error ? { error: account.error } : {}),
       }));
+
+      // 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));
+      }
+
       return {
         adapterId: this.id,
         sourceProviderId: target.providerId,

package/src/modules/provider/controller.ts

@@ -22,16 +22,30 @@ export class ProviderUsageController {
 
   setConfig(config: UsageConfig): void { this.config = config; }
 
-  async target(ctx: ExtensionContext, providerId: string, model = ctx.model): Promise<ProviderTarget> {
+  async target(ctx: ExtensionContext, providerId: string, model?: Model<Api>): Promise<ProviderTarget> {
     const provider = ctx.modelRegistry.getProvider(providerId);
     const auth = await ctx.modelRegistry.getProviderAuth(providerId);
-    const baseUrl = auth?.auth.baseUrl ?? model?.baseUrl ?? provider?.baseUrl;
+
+    // Only associate the active model if it actually belongs to this provider!
+    const activeModel = model ?? ctx.model;
+    const matchedModel = activeModel?.provider?.toLowerCase() === providerId.toLowerCase() ? activeModel : undefined;
+
+    // Base URL resolution: NEVER inherit baseUrl from a foreign provider's model!
+    const baseUrl = auth?.auth.baseUrl ?? matchedModel?.baseUrl ?? provider?.baseUrl;
+
+    // Collect all models configured in Pi under this specific provider
+    const allModels = ctx.modelRegistry.getAll();
+    const configuredModelIds = allModels
+      .filter((m) => m.provider?.toLowerCase() === providerId.toLowerCase())
+      .map((m) => m.id);
+
     return {
       providerId,
-      ...(model?.provider === providerId ? { model } : {}),
+      ...(matchedModel ? { model: matchedModel } : {}),
       ...(provider ? { provider } : {}),
       ...(auth ? { auth } : {}),
       ...(baseUrl ? { baseUrl } : {}),
+      ...(configuredModelIds.length ? { configuredModelIds } : {}),
     };
   }
 

package/src/modules/provider/matching.ts

@@ -226,3 +226,67 @@ export function matchModelGroup(
   const res = matchModelAcrossAccounts([{ rawGroups: groups }], modelId);
   return res?.quota;
 }
+
+/**
+ * Determines whether a proxy account (e.g. from pi-bridge) is relevant to the models
+ * actually configured by the user for this provider in Pi.
+ * If configuredModelIds is empty or omitted, all accounts are considered relevant.
+ */
+export function isAccountRelevantToModels(
+  account: { provider?: string; rawGroups?: unknown },
+  configuredModelIds?: string[],
+): boolean {
+  if (!configuredModelIds || configuredModelIds.length === 0) return true;
+
+  const targetTokens = new Set(configuredModelIds.flatMap(tokenizeModelId));
+  const groups = Array.isArray(account.rawGroups) ? (account.rawGroups as RawBridgeGroup[]) : [];
+  const provTokens = tokenizeModelId(account.provider ?? "");
+
+  // 1. Direct provider match or overlap with configured model tokens
+  // E.g. account.provider === "codex" vs models having "codex", or "antigravity" vs "gemini"/"claude"
+  const provNormalized = (account.provider ?? "").toLowerCase();
+  for (const mid of configuredModelIds) {
+    const mLower = mid.toLowerCase();
+    if (provNormalized && (mLower.includes(provNormalized) || provNormalized.includes(mLower))) {
+      return true;
+    }
+  }
+
+  // Check token intersection with account provider
+  if (provTokens.some((t) => targetTokens.has(t))) return true;
+
+  // 2. Check groups and their inner models
+  const modelKeywords = [
+    "claude", "gemini", "codex", "gpt", "openai", "deepseek", "kimi", "moonshot", "grok", "xai",
+    "thinking", "flash", "pro", "opus", "sonnet", "haiku", "turbo", "mini", "reasoning", "antigravity",
+  ];
+  for (const group of groups) {
+    const gTokens = tokenizeModelId(`${group.id ?? ""} ${group.label ?? ""}`);
+    const gOverlap = gTokens.filter((t) => targetTokens.has(t));
+    if (gOverlap.some((t) => modelKeywords.includes(t)) || gOverlap.length >= 2) return true;
+
+    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));
+        if (overlap.length >= 2 || overlap.some((t) => modelKeywords.includes(t))) {
+          return true;
+        }
+      }
+    }
+  }
+
+  // 3. Provider abbreviation match (e.g. "ag-" models vs "antigravity" provider)
+  if (provNormalized === "antigravity" && configuredModelIds.some((id) => id.toLowerCase().startsWith("ag-"))) {
+    return true;
+  }
+
+  return false;
+}
+