@genee/omp-opsx-addon 0.1.0 → 0.2.0

package/index.ts

@@ -101,8 +101,7 @@ function handleSubagentEvent(payload: unknown, primarySessionId: string): void {
         // This prevents cross-stream contamination while keeping global totals intact
         const subagentStreamKey = `${primarySessionId}:subagent:${p.id}`;
 
-        // Record usage with subagent-specific stream key (NO setSessionId call)
-        sessionUsageRecorder.record(provider, usage, subagentStreamKey);
+        sessionUsageRecorder.record(canonicalizeProvider(provider), usage, subagentStreamKey);
     } catch (err) {
         // Silently fail to avoid breaking the plugin
         console.error('Failed to handle subagent event:', err);
@@ -121,6 +120,7 @@ import { scoreModelWithProvider } from './lib/model-tiers.js';
 import { DIRECT_FETCHERS } from './lib/direct-fetchers.js';
 import { createUsageWidget } from './lib/usage-widget.js';
 import { renderUsageReports, type ConsumptionTrack } from './lib/usage-render.js';
+import { markExhausted, markAvailable, getExhaustedProviders } from './lib/provider-status.js';
 import {
     startSharedPoller,
     getUnconfirmedProviders,
@@ -692,11 +692,30 @@ export default (pi: ExtensionAPI) => {
                 const reports = state?.reports ?? [];
                 let loggedIn: string[] = [];
                 let authAvailable = false;
+                // Three-way dedup union of the "logged in" universe:
+                // 1. providers derived from modelRegistry.getAvailable() — models
+                //    whose provider has auth and is not disabled (covers models.yml
+                //    config-override apiKeys that authStorage.list() never sees);
+                // 2. authStorage.list() — SQLite credential keys (incl. non-catalog
+                //    providers getAvailable() doesn't surface);
+                // 3. locally-detectable direct-fetcher credentials.
+                // All ids canonicalized (lowercase) before dedup so one provider
+                // never surfaces as two columns / tracks.
+                try {
+                    if (typeof ctx.modelRegistry?.getAvailable === 'function') {
+                        const available = ctx.modelRegistry.getAvailable();
+                        authAvailable = true;
+                        loggedIn = [...new Set(available.map((m) => canonicalizeProvider(m.provider)).filter(Boolean))];
+                    }
+                } catch {
+                    /* modelRegistry unavailable → fall back to auth.list() + detectable */
+                }
                 try {
                     if (auth?.list) {
                         authAvailable = true;
                         const list = auth.list();
-                        loggedIn = Array.isArray(list) ? list : [];
+                        const ids = Array.isArray(list) ? list : [];
+                        loggedIn = [...new Set([...loggedIn, ...ids.map(canonicalizeProvider)])];
                     }
                 } catch {
                     /* treat authStorage as unavailable */
@@ -759,13 +778,13 @@ export default (pi: ExtensionAPI) => {
                     consumptionTracks.set(p, { samples: getConsumptionSamples(p) });
                 }
                 if (ctx.hasUI) {
-                    ctx.ui.setWidget(key, createUsageWidget(reports, placeholderIds, loadingProviders, consumptionTracks, usageEstimates), {
+                    ctx.ui.setWidget(key, createUsageWidget(reports, placeholderIds, loadingProviders, consumptionTracks, usageEstimates, getExhaustedProviders()), {
                         placement: 'belowEditor',
                     });
                 } else {
                     if (ctx.ui) {
                         const cols = (process.stdout.columns ?? 120) - 3;
-                        const lines = renderUsageReports(reports, cols, undefined, placeholderIds, loadingProviders, consumptionTracks, usageEstimates);
+                        const lines = renderUsageReports(reports, cols, undefined, placeholderIds, loadingProviders, consumptionTracks, usageEstimates, getExhaustedProviders());
                         ctx.ui.setWidget(key, lines.length > 0 ? lines : undefined, { placement: 'belowEditor' });
                     }
                 }
@@ -868,7 +887,7 @@ export default (pi: ExtensionAPI) => {
             const ev = event.assistantMessageEvent;
             if ('partial' in ev) {
                 const usage = assistantUsageOf(ev.partial);
-                if (usage) sessionUsageRecorder.record(usage.provider, usage.usage);
+                if (usage) sessionUsageRecorder.record(canonicalizeProvider(usage.provider), usage.usage);
             }
         } catch {
             /* usage recording is best-effort; stay silent */
@@ -879,7 +898,7 @@ export default (pi: ExtensionAPI) => {
     pi.on('message_end', async (event) => {
         try {
             const usage = assistantUsageOf(event.message);
-            if (usage) sessionUsageRecorder.record(usage.provider, usage.usage);
+            if (usage) sessionUsageRecorder.record(canonicalizeProvider(usage.provider), usage.usage);
         } catch {
             /* usage recording is best-effort; stay silent */
         }
@@ -973,6 +992,10 @@ export default (pi: ExtensionAPI) => {
         const getApiKey = ctx.modelRegistry?.getApiKeyForProvider
             ? (provider: string) => ctx.modelRegistry.getApiKeyForProvider(provider)
             : undefined;
+        // 429/403 is the only observable exhaustion evidence for providers
+        // without a usage fetcher — record it in the process-local binary status
+        // so the placeholder column reads 耗尽 (see lib/provider-status.ts).
+        markExhausted(canonical);
         // Force-refresh just this provider (bypassing the 10s floor) so the
         // diagnosis reflects current quota.
         if (auth) await pokeProvider(auth, DIRECT_FETCHERS, getApiKey, { providers: [canonical], force: true });
@@ -989,6 +1012,10 @@ export default (pi: ExtensionAPI) => {
                 await diagnoseProviderError(ctx, `HTTP ${event.status}`, '429');
             } else if (event.status === 403) {
                 await diagnoseProviderError(ctx, `HTTP ${event.status}`, '403');
+            } else if (event.status >= 200 && event.status < 300) {
+                // Strict 2xx restores the provider's binary status. 5xx / other
+                // 4xx are NOT recovery evidence and must not clear exhaustion.
+                if (ctx.model) markAvailable(canonicalizeProvider(ctx.model.provider));
             }
         } catch (e) {
             warn(`[omp-opsx-addon] after_provider_response error: ${e}`);

package/lib/provider-status.ts

@@ -0,0 +1,55 @@
+/**
+ * Process-local binary status for providers WITHOUT a usage report.
+ *
+ * A provider that has no usage fetcher has no authoritative quota source; the
+ * only observable exhaustion evidence is a 429/403 signal on the provider
+ * response or tool-execution paths. This module keeps that signal as a
+ * process-local `Map` (mirroring the `regionBlockedModels` in-process precedent
+ * in index.ts): absence of an entry means "可用", an explicit `markExhausted`
+ * flips it to "耗尽", and a subsequent strict-2xx provider response restores
+ * "可用". Nothing is persisted and nothing crosses processes — a 429 observed
+ * in one process is not broadcast to another, which is an accepted trade-off
+ * for a best-effort local hint.
+ *
+ * Keys are canonicalized (lowercase) so `ArkCodingPlan` and `arkcodingplan`
+ * share one entry.
+ */
+
+import { canonicalizeProvider } from './usage-resolver.js';
+
+interface ProviderStatus {
+    exhausted: boolean;
+    observedAt: number;
+}
+
+const state = new Map<string, ProviderStatus>();
+
+/** Mark a provider exhausted (429/403 observed). */
+export function markExhausted(provider: string): void {
+    const canonical = canonicalizeProvider(provider);
+    state.set(canonical, { exhausted: true, observedAt: Date.now() });
+}
+
+/** Clear the exhausted marker (strict 2xx response observed). */
+export function markAvailable(provider: string): void {
+    state.delete(canonicalizeProvider(provider));
+}
+
+/** True iff the provider has an explicit exhaustion marker (default: available). */
+export function isExhausted(provider: string): boolean {
+    return state.get(canonicalizeProvider(provider))?.exhausted ?? false;
+}
+
+/** Canonical ids of all currently-exhausted providers. */
+export function getExhaustedProviders(): ReadonlySet<string> {
+    const out = new Set<string>();
+    for (const [id, s] of state) {
+        if (s.exhausted) out.add(id);
+    }
+    return out;
+}
+
+/** Test seam: clear all process-local state. */
+export function _resetForTest(): void {
+    state.clear();
+}

package/lib/usage-render.ts

@@ -289,18 +289,33 @@ export const buildColumn = (r: UsageReport, painter: Painter = ansiPainter, load
 };
 
 /**
- * Render a logged-in provider that has no report yet as a header + a single
- * placeholder row (`—`). Placeholder identity is always carried by an explicit id
- * (see `renderUsageReports` `placeholderIds`); it is NEVER inferred from an empty
- * `limits` array, so a real fetch that returns no windows is not mistaken for a
- * logged-in-but-unfetched provider.
+ * Render a real report whose `limits` array is empty — a fetch succeeded but
+ * returned no usable windows. This is NOT a logged-in-but-unfetched provider:
+ * it keeps the existing `—` marker (never the binary 可用/耗尽 body) so its
+ * rendering is byte-identical to the pre-binary-status behavior.
  */
-export const buildPlaceholderColumn = (provider: string, painter: Painter = ansiPainter, loading = false): string[] => {
+export const buildEmptyReportColumn = (provider: string, painter: Painter = ansiPainter, loading = false): string[] => {
     const { label, color } = providerLabel(provider);
-    // Loading placeholder: body shows ⟳ (fetch in flight) instead of the idle —.
     return [painter.header(loading ? `${label}⟳` : label, color), painter.balance(loading ? "⟳" : "—")];
 }
 
+/**
+ * Render a logged-in provider that has no report yet as a header + a single
+ * binary-status row (`可用` / `耗尽` / `⟳`). Placeholder identity is always
+ * carried by an explicit id (see `renderUsageReports` `placeholderIds`); it is
+ * NEVER inferred from an empty `limits` array, so a real fetch that returns no
+ * windows is not mistaken for a logged-in-but-unfetched provider. `exhausted`
+ * reflects the process-local 429/403 signal (see `lib/provider-status.ts`).
+ */
+export const buildPlaceholderColumn = (provider: string, painter: Painter = ansiPainter, loading = false, exhausted = false): string[] => {
+    const { label, color } = providerLabel(provider);
+    const body = loading ? "⟳" : exhausted ? "耗尽" : "可用";
+    return [
+        painter.header(loading ? `${label}⟳` : label, color),
+        exhausted ? painter.exhausted(body) : painter.balance(body),
+    ];
+}
+
 // ── flex-wrap table layout ───────────────────────────────────────────
 
 const SEP_VISUAL = 3;
@@ -314,6 +329,7 @@ export function renderUsageReports(
     loadingProviders?: ReadonlySet<string>,
     consumptionTracks?: Map<string, ConsumptionTrack>,
     usageEstimates?: Map<string, string>,
+    exhaustedProviders?: ReadonlySet<string>,
 ): string[] {
     // Placeholder providers are logged-in but unfetched this round. Their ids are
     // explicit (never inferred from `limits.length === 0`); dedupe against reports
@@ -329,7 +345,7 @@ export function renderUsageReports(
     interface ProviderColumn { provider: string; col: string[] }
     const cols: ProviderColumn[] = (reports ?? []).map((r) => {
         const col = r.limits.length === 0
-            ? buildPlaceholderColumn(r.provider, painter, loading.has(r.provider))
+            ? buildEmptyReportColumn(r.provider, painter, loading.has(r.provider))
             : buildColumn(r, painter, loading.has(r.provider));
         if (!col) return { provider: r.provider, col: [] };
         // Second-level estimate override replaces the usage line (balance style).
@@ -338,7 +354,7 @@ export function renderUsageReports(
         return { provider: r.provider, col };
     });
     for (const id of placeholders) {
-        cols.push({ provider: id, col: buildPlaceholderColumn(id, painter, loading.has(id)) });
+        cols.push({ provider: id, col: buildPlaceholderColumn(id, painter, loading.has(id), exhaustedProviders?.has(id)) });
     }
     const valid = cols.filter((c) => c.col.length > 0);
     if (valid.length === 0) return [];

package/lib/usage-resolver.ts

@@ -41,9 +41,16 @@ export interface DirectFetcher {
  */
 const PROVIDER_ALIAS: Record<string, string> = {};
 
-/** Normalize a provider id to its canonical form (no-op if already canonical). */
+/**
+ * Normalize a provider id to its canonical form: lowercase first, then alias
+ * mapping. models.yml config keys are mixed-case (`ArkCodingPlan`), DB
+ * credentials and message events are lowercase (`arkcodingplan`), and the
+ * harness compares ids case-insensitively — lowercase unifies all three so a
+ * provider never surfaces as two columns or two waveform tracks.
+ */
 export function canonicalizeProvider(id: string): string {
-    return PROVIDER_ALIAS[id] ?? id;
+    const k = id.toLowerCase();
+    return PROVIDER_ALIAS[k] ?? k;
 }
 
 /** Providers whose direct fetcher reports locally-detectable credentials (no network). */

package/lib/usage-widget.ts

@@ -55,6 +55,7 @@ export class UsageTable implements Component {
     readonly #loadingProviders?: ReadonlySet<string>;
     readonly #consumptionTracks?: Map<string, ConsumptionTrack>;
     readonly #usageEstimates?: Map<string, string>;
+    readonly #exhaustedProviders?: ReadonlySet<string>;
 
     constructor(
         reports: UsageReport[],
@@ -63,6 +64,7 @@ export class UsageTable implements Component {
         loadingProviders?: ReadonlySet<string>,
         consumptionTracks?: Map<string, ConsumptionTrack>,
         usageEstimates?: Map<string, string>,
+        exhaustedProviders?: ReadonlySet<string>,
     ) {
         this.#reports = reports;
         this.#painter = painter;
@@ -70,6 +72,7 @@ export class UsageTable implements Component {
         this.#loadingProviders = loadingProviders;
         this.#consumptionTracks = consumptionTracks;
         this.#usageEstimates = usageEstimates;
+        this.#exhaustedProviders = exhaustedProviders;
     }
 
     render(width: number): readonly string[] {
@@ -83,6 +86,7 @@ export class UsageTable implements Component {
             this.#loadingProviders,
             this.#consumptionTracks,
             this.#usageEstimates,
+            this.#exhaustedProviders,
         );
     }
 
@@ -107,6 +111,7 @@ export function createUsageWidget(
     loadingProviders?: ReadonlySet<string>,
     consumptionTracks?: Map<string, ConsumptionTrack>,
     usageEstimates?: Map<string, string>,
+    exhaustedProviders?: ReadonlySet<string>,
 ): ExtensionUiComponentFactory {
-    return (_tui, theme) => new UsageTable(reports, themePainter(theme), placeholderIds, loadingProviders, consumptionTracks, usageEstimates);
+    return (_tui, theme) => new UsageTable(reports, themePainter(theme), placeholderIds, loadingProviders, consumptionTracks, usageEstimates, exhaustedProviders);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genee/omp-opsx-addon",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "Pi Extension: OpenSpec workflow orchestration - coder/reviewer/planner agents, session title & progress",
   "main": "./index.ts",
@@ -25,10 +25,14 @@
     "opsx"
   ],
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.ts"
+    ]
   },
   "omp": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.ts"
+    ]
   },
   "license": "MIT",
   "peerDependencies": {