pi-ccswitch-auto-switch 0.1.0 → 0.1.2

package/README.md

@@ -66,15 +66,15 @@ Examples:
 ## Status bar
 
 ```text
-CCS ✓130 · ⏳1 · ⛔0
+CCS ✓70/131 · ⏳61 · ⛔0
 ```
 
-- `✓130`: effective models currently eligible for selection.
-- `⏳1`: one model, provider, or endpoint health record is cooling down.
+- `✓70/131`: 70 healthy models out of 131 unique `provider/model` combinations in Pi's effective scope. Duplicate scoped entries are counted once.
+- `⏳61`: 61 models are currently affected by automatic model, provider, or endpoint cooldowns. One provider breaker can account for many affected models.
 - `⛔0`: no manually disabled models.
 - During a switch, `CCS ↻2/5 provider/model` means the second of at most five attempts is being made.
 
-Use `/ccswitch` to inspect the exact record behind a cooldown.
+When all unique models are healthy, the compact form is `CCS ✓131`. Use `/ccswitch` or `/ccswitch-test` to see Pi's raw scope entry count, the deduplicated model count, affected model counts, and the underlying breaker-record count.
 
 ## Failover behavior
 

package/README.zh-CN.md

@@ -58,15 +58,15 @@ pi install npm:pi-ccswitch-auto-switch
 ## 状态栏
 
 ```text
-CCS ✓130 · ⏳1 · ⛔0
+CCS ✓70/131 · ⏳61 · ⛔0
 ```
 
-- `✓130`：当前可参与选择的有效模型数量。
-- `⏳1`：有一条模型、Provider 或端点健康记录仍在冷却。
+- `✓70/131`：Pi 有效范围内共有 131 个去重后的 `provider/model` 组合，其中 70 个健康；重复的 scope 条目只计一次。
+- `⏳61`：有 61 个模型正受模型、Provider 或端点自动冷却影响；一条 Provider 熔断记录可能同时影响许多模型。
 - `⛔0`：没有被手动禁用的模型。
 - 切换中出现 `CCS ↻2/5 provider/model`，表示正在进行最多 5 次尝试中的第 2 次。
 
-通过 `/ccswitch` 查看具体哪个记录正在冷却。
+全部唯一模型都健康时会压缩显示为 `CCS ✓131`。通过 `/ccswitch` 或 `/ccswitch-test` 可同时查看 Pi 原始 scope 条目数、去重模型数、受影响模型数和底层熔断记录数。
 
 ## 故障转移逻辑
 

package/candidates.ts

@@ -8,6 +8,24 @@ export interface CandidateOptions {
   health: HealthState
 }
 
+export interface CandidateSnapshot {
+  models: ModelRef[]
+  source: 'scoped' | 'available'
+  sourceEntries: number
+}
+
+export interface CandidateHealthSummary {
+  total: number
+  healthy: number
+  cooling: number
+  disabled: number
+  breakerRecords: number
+}
+
+function activeCooldown(record: HealthState['models'][string] | undefined, now: number): boolean {
+  return Boolean((record?.cooldownUntil && record.cooldownUntil > now) || (record?.leaseUntil && record.leaseUntil > now))
+}
+
 function blocked(model: ModelRef, health: HealthState, now = Date.now()): boolean {
   const records = [health.models[modelKey(model)], health.providers[model.provider], health.endpoints[endpointKey(model)]]
   return records.some(record => Boolean(record?.disabled || (record?.cooldownUntil && record.cooldownUntil > now) || (record?.leaseUntil && record.leaseUntil > now)))
@@ -24,6 +42,34 @@ export function effectiveCandidates(scoped: readonly ScopedModel[], available: M
   })
 }
 
+export function candidateSnapshot(scoped: readonly ScopedModel[], available: ModelRef[]): CandidateSnapshot {
+  const source = scoped.length > 0 ? 'scoped' : 'available'
+  return {
+    models: effectiveCandidates(scoped, available),
+    source,
+    sourceEntries: source === 'scoped' ? scoped.length : available.length,
+  }
+}
+
+export function summarizeCandidateHealth(models: ModelRef[], health: HealthState, now = Date.now()): CandidateHealthSummary {
+  let healthy = 0
+  let cooling = 0
+  let disabled = 0
+  for (const model of models) {
+    const modelRecord = health.models[modelKey(model)]
+    if (modelRecord?.disabled) {
+      disabled += 1
+      continue
+    }
+    const records = [modelRecord, health.providers[model.provider], health.endpoints[endpointKey(model)]]
+    if (records.some(record => activeCooldown(record, now))) cooling += 1
+    else healthy += 1
+  }
+  const breakerRecords = [...Object.values(health.models), ...Object.values(health.providers), ...Object.values(health.endpoints)]
+    .filter(record => activeCooldown(record, now)).length
+  return { total: models.length, healthy, cooling, disabled, breakerRecords }
+}
+
 export function chooseCandidate(models: ModelRef[], options: CandidateOptions): ModelRef | undefined {
   const current = options.current
   const candidates = models.filter(model => {

package/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, FailureObservation, ModelRef } from './types.ts'
 import { classifyFailure, parseRetryAfter } from './classify.ts'
-import { effectiveCandidates, chooseCandidate } from './candidates.ts'
+import { candidateSnapshot, effectiveCandidates, chooseCandidate, summarizeCandidateHealth } from './candidates.ts'
 import { HealthStore, endpointKey, modelKey } from './health.ts'
 
 const FIRST_RESPONSE_TIMEOUT = 90_000
@@ -48,17 +48,12 @@ export default function (pi: ExtensionAPI) {
   }
   const status = (ctx: ExtensionContext) => {
     const state = health.snapshot
-    const models = effectiveCandidates(ctx.scopedModels, ctx.modelRegistry.getAvailable())
-    const now = Date.now()
-    const disabled = Object.values(state.models).filter(item => item.disabled).length
-    const cooling = [...Object.values(state.models), ...Object.values(state.providers), ...Object.values(state.endpoints)]
-      .filter(item => item.cooldownUntil && item.cooldownUntil > now).length
-    const unhealthy = models.filter(model => health.isBlocked(model)).length
-    const healthy = Math.max(0, models.length - unhealthy)
+    const { models } = candidateSnapshot(ctx.scopedModels, ctx.modelRegistry.getAvailable())
+    const counts = summarizeCandidateHealth(models, state)
     const plain = round?.phase === 'switching' ? `CCS ↻${round.attempts}/${MAX_ATTEMPTS} ${round.model ? modelKey(round.model) : ''}` :
-      cooling || disabled ? `CCS ✓${healthy} · ⏳${cooling} · ⛔${disabled}` : `CCS ✓${models.length}`
+      counts.cooling || counts.disabled ? `CCS ✓${counts.healthy}/${counts.total} · ⏳${counts.cooling} · ⛔${counts.disabled}` : `CCS ✓${counts.total}`
     const theme = ctx.ui.theme
-    ctx.ui.setStatus('ccswitch-ha', theme ? theme.fg(cooling || disabled ? 'warning' : 'success', plain) : plain)
+    ctx.ui.setStatus('ccswitch-ha', theme ? theme.fg(counts.cooling || counts.disabled ? 'warning' : 'success', plain) : plain)
   }
   const notify = (ctx: ExtensionContext, message: string, type: 'info' | 'warning' | 'error' = 'info') => {
     if (ctx.hasUI) ctx.ui.notify(message, type)
@@ -81,14 +76,24 @@ export default function (pi: ExtensionAPI) {
   }
   const showPanel = async (ctx: ExtensionContext) => {
     const state = health.snapshot
-    const candidates = effectiveCandidates(ctx.scopedModels, ctx.modelRegistry.getAvailable())
+    const snapshot = candidateSnapshot(ctx.scopedModels, ctx.modelRegistry.getAvailable())
+    const candidates = snapshot.models
+    const counts = summarizeCandidateHealth(candidates, state)
+    const now = Date.now()
     const rows = candidates.slice(0, 10).map(model => {
-      const record = state.models[modelKey(model)] ?? state.providers[model.provider]
-      const suffix = record?.disabled ? '禁用' : record?.cooldownUntil && record.cooldownUntil > Date.now() ? `冷却 ${Math.ceil((record.cooldownUntil - Date.now()) / 60_000)}m` : '健康'
+      const modelRecord = state.models[modelKey(model)]
+      const records = [modelRecord, state.providers[model.provider], state.endpoints[endpointKey(model)]]
+      const blockedUntil = Math.max(0, ...records.flatMap(record => [record?.cooldownUntil ?? 0, record?.leaseUntil ?? 0]))
+      const suffix = modelRecord?.disabled ? '手动禁用' : blockedUntil > now ? `自动冷却 ${Math.max(1, Math.ceil((blockedUntil - now) / 60_000))}m` : '健康'
       return `${modelKey(model)}  ${suffix}`
     })
-    if (!ctx.ui.select) { notify(ctx, `CCSwitch：${candidates.length} 个候选，${rows.filter(row => row.includes('冷却')).length} 个冷却`, 'info'); return }
-    const action = await ctx.ui.select(`CCSwitch 健康面板\n当前：${key(ctx.model) ?? '无'}\n${rows.join('\n') || '没有可用模型'}`, ['刷新', '重新激活当前模型', '禁用当前模型', '重置当前模型历史', '关闭'])
+    if (!ctx.ui.select) {
+      const source = snapshot.source === 'scoped' ? `Pi scope ${snapshot.sourceEntries} 条` : `Pi 注册表 ${snapshot.sourceEntries} 条`
+      notify(ctx, `CCSwitch：${source} · 唯一模型 ${counts.total} · 健康 ${counts.healthy} · 自动冷却 ${counts.cooling} · 手动禁用 ${counts.disabled}`, 'info')
+      return
+    }
+    const scopeLabel = snapshot.source === 'scoped' ? `Pi scope：${snapshot.sourceEntries} 条` : `Pi 可用注册表：${snapshot.sourceEntries} 条`
+    const action = await ctx.ui.select(`CCSwitch 健康面板\n当前：${key(ctx.model) ?? '无'}\n${scopeLabel} · 唯一模型：${counts.total} · 健康：${counts.healthy} · 自动冷却：${counts.cooling} · 手动禁用：${counts.disabled}\n熔断记录：${counts.breakerRecords}\n${rows.join('\n') || '没有可用模型'}`, ['刷新', '重新激活当前模型', '禁用当前模型', '重置当前模型历史', '关闭'])
     if (action === '刷新') await refresh(ctx)
     if (action === '重新激活当前模型' && ctx.model) { health.reactivate(ctx.model); await health.flush(); status(ctx); notify(ctx, '已重新激活当前模型') }
     if (action === '禁用当前模型' && ctx.model) { health.disable(modelKey(ctx.model), true); await health.flush(); status(ctx); notify(ctx, '已禁用当前模型', 'warning') }
@@ -230,7 +235,9 @@ export default function (pi: ExtensionAPI) {
   }})
   pi.registerCommand('ccswitch-test', { description: '检查 CCSwitch 候选模型和健康状态（不切换模型）', handler: async (_args, ctx) => {
     await refresh(ctx)
-    const count = effectiveCandidates(ctx.scopedModels, ctx.modelRegistry.getAvailable()).length
-    notify(ctx, `CCSwitch 自检完成：${count} 个有效候选模型`, count ? 'info' : 'warning')
+    const snapshot = candidateSnapshot(ctx.scopedModels, ctx.modelRegistry.getAvailable())
+    const counts = summarizeCandidateHealth(snapshot.models, health.snapshot)
+    const source = snapshot.source === 'scoped' ? `Pi scope ${snapshot.sourceEntries} 条` : `Pi 注册表 ${snapshot.sourceEntries} 条`
+    notify(ctx, `CCSwitch 自检：${source} · 唯一模型 ${counts.total} · 健康 ${counts.healthy} · 自动冷却 ${counts.cooling} · 手动禁用 ${counts.disabled} · 熔断记录 ${counts.breakerRecords}`, counts.total ? 'info' : 'warning')
   }})
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ccswitch-auto-switch",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Provider-first automatic model failover extension for Pi and CC Switch",
   "license": "MIT",
   "keywords": [