pi-ccswitch-auto-switch 0.1.1 → 0.1.3

package/README.md

@@ -11,8 +11,10 @@ The extension observes real Pi requests, records sanitized health signals, and
 - Uses Pi's effective model registry; never reads CC Switch databases, Pi auth files, or API keys.
 - Provider-first circuit breakers for authentication, quota, billing, and rate-limit failures.
 - Endpoint circuit breakers for DNS, connection, server, and streaming failures.
+- Endpoint platform isolation: when several models on the same endpoint (same BaseURL/provider) fail within one round, the whole endpoint is isolated so sibling models from the same platform are not tried one by one.
 - Model-only isolation for missing models and incompatible parameters.
 - Prefers a healthy model from another provider before considering a sibling model.
+  - Independent-provider semantics: a copied vendor (e.g. `b-ai-copy`) shares the BaseURL but is a distinct provider with its own endpoint key, so isolating one never blocks the other.
 - 90-second first-response and 120-second streaming-idle watchdogs.
 - Exponential cooldowns, `Retry-After` support, and one persisted half-open probe lease per provider.
 - Persistent, atomic, cross-process health state with error redaction and bounded logs.
@@ -66,15 +68,15 @@ Examples:
 ## Status bar
 
 ```text
-CCS ✓70/71 · ⏳1 · ⛔0
+CCS ✓70/131 · ⏳61 · ⛔0
 ```
 
-- `✓70/71`: 70 healthy models out of 71 unique `provider/model` combinations in Pi's effective scope. Duplicate scoped entries are counted once.
-- `⏳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.
 
-When all unique models are healthy, the compact form is `CCS ✓71`. Use `/ccswitch` or `/ccswitch-test` to see Pi's raw scope entry count, the deduplicated model count, the healthy count, and 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 ✓70/71 · ⏳1 · ⛔0
+CCS ✓70/131 · ⏳61 · ⛔0
 ```
 
-- `✓70/71`：Pi 有效范围内共有 71 个去重后的 `provider/model` 组合，其中 70 个健康；重复的 scope 条目只计一次。
-- `⏳1`：有一条模型、Provider 或端点健康记录仍在冷却。
+- `✓70/131`：Pi 有效范围内共有 131 个去重后的 `provider/model` 组合，其中 70 个健康；重复的 scope 条目只计一次。
+- `⏳61`：有 61 个模型正受模型、Provider 或端点自动冷却影响；一条 Provider 熔断记录可能同时影响许多模型。
 - `⛔0`：没有被手动禁用的模型。
 - 切换中出现 `CCS ↻2/5 provider/model`，表示正在进行最多 5 次尝试中的第 2 次。
 
-全部唯一模型都健康时会压缩显示为 `CCS ✓71`。通过 `/ccswitch` 或 `/ccswitch-test` 可同时查看 Pi 原始 scope 条目数、去重模型数、健康数，以及具体哪个记录正在冷却。
+全部唯一模型都健康时会压缩显示为 `CCS ✓131`。通过 `/ccswitch` 或 `/ccswitch-test` 可同时查看 Pi 原始 scope 条目数、去重模型数、受影响模型数和底层熔断记录数。
 
 ## 故障转移逻辑
 

package/candidates.ts

@@ -6,6 +6,7 @@ export interface CandidateOptions {
   tried: Set<string>
   failureKind?: string
   health: HealthState
+  avoidEndpoints?: Set<string>
 }
 
 export interface CandidateSnapshot {
@@ -14,6 +15,18 @@ export interface CandidateSnapshot {
   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)))
@@ -39,10 +52,30 @@ export function candidateSnapshot(scoped: readonly ScopedModel[], available: Mod
   }
 }
 
+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 => {
     if (options.tried.has(modelKey(model)) || blocked(model, options.health)) return false
+    if (options.avoidEndpoints?.has(endpointKey(model))) return false
     if (options.failureKind === 'context_overflow' && current && (model.contextWindow ?? 0) <= (current.contextWindow ?? 0)) return false
     return true
   })

package/index.ts

@@ -1,12 +1,19 @@
 import type { ExtensionAPI, ExtensionContext, FailureObservation, ModelRef } from './types.ts'
 import { classifyFailure, parseRetryAfter } from './classify.ts'
-import { candidateSnapshot, 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
 const STREAM_IDLE_TIMEOUT = 120_000
 const MAX_ATTEMPTS = 5
 const ROUND_LIMIT = 8 * 60_000
+// 同端点（BaseURL 相同）连续失败达到该次数即隔离该端点，避免同一个平台的多个模型逐个试错耗尽本轮切换
+const ENDPOINT_FAIL_THRESHOLD = 3
+
+interface EndpointFailTracker {
+  failed: Map<string, number>
+  isolated: Set<string>
+}
 
 type Phase = 'idle' | 'monitoring' | 'settled-error' | 'switching' | 'redispatching' | 'verifying' | 'exhausted'
 interface Round {
@@ -24,6 +31,7 @@ interface Round {
   cleanRetry: boolean
   observation?: FailureObservation
   model?: ModelRef
+  endpointFails?: EndpointFailTracker
 }
 
 function key(model: ModelRef | undefined): string | undefined { return model && modelKey(model) }
@@ -49,16 +57,11 @@ export default function (pi: ExtensionAPI) {
   const status = (ctx: ExtensionContext) => {
     const state = health.snapshot
     const { models } = candidateSnapshot(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 counts = summarizeCandidateHealth(models, state)
     const plain = round?.phase === 'switching' ? `CCS ↻${round.attempts}/${MAX_ATTEMPTS} ${round.model ? modelKey(round.model) : ''}` :
-      cooling || disabled ? `CCS ✓${healthy}/${models.length} · ⏳${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)
@@ -83,19 +86,22 @@ export default function (pi: ExtensionAPI) {
     const state = health.snapshot
     const snapshot = candidateSnapshot(ctx.scopedModels, ctx.modelRegistry.getAvailable())
     const candidates = snapshot.models
-    const healthy = candidates.filter(model => !health.isBlocked(model)).length
+    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) {
       const source = snapshot.source === 'scoped' ? `Pi scope ${snapshot.sourceEntries} 条` : `Pi 注册表 ${snapshot.sourceEntries} 条`
-      notify(ctx, `CCSwitch：${source} · 唯一模型 ${candidates.length} · 健康 ${healthy}`, 'info')
+      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} · 唯一模型：${candidates.length} · 健康：${healthy}\n${rows.join('\n') || '没有可用模型'}`, ['刷新', '重新激活当前模型', '禁用当前模型', '重置当前模型历史', '关闭'])
+    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') }
@@ -121,20 +127,30 @@ export default function (pi: ExtensionAPI) {
     if (round.observation.aborted && !round.observation.watchdog) { round.phase = 'idle'; clearWatchdog(); status(ctx); return }
     round.phase = 'switching'
     round.tried.add(modelKey(round.model))
+    // 跟踪同端点失败：BaseURL 相同的模型同属一个端点平台，连续失败到阈值后隔离整个端点，
+    // 避免同一平台下的多个模型逐个试错（它们往往共享同一故障根源）
+    const failTracker = round.endpointFails ??= { failed: new Map(), isolated: new Set() }
+    const ep = endpointKey(round.model)
+    const epFails = (failTracker.failed.get(ep) ?? 0) + 1
+    failTracker.failed.set(ep, epFails)
+    if (epFails >= ENDPOINT_FAIL_THRESHOLD) {
+      failTracker.isolated.add(ep)
+      await health.log(`endpoint ${ep} failed ${epFails} times this round, isolating endpoint`)
+    }
     if (!classification.roundOnly && classification.scope) health.recordFailure(classification.scope, classification.scope === 'model' ? modelKey(round.model) : classification.scope === 'provider' ? round.model.provider : endpointKey(round.model), classification.kind, round.observation.message, classification.retryAfterMs)
     await health.flush()
     await refresh(ctx)
     const candidates = effectiveCandidates(ctx.scopedModels, ctx.modelRegistry.getAvailable())
-    let next = chooseCandidate(candidates, { current: round.model, tried: round.tried, failureKind: classification.kind, health: health.snapshot })
+    let next = chooseCandidate(candidates, { current: round.model, tried: round.tried, failureKind: classification.kind, health: health.snapshot, avoidEndpoints: failTracker.isolated })
     while (next) {
-      if (!await health.claimProvider(next)) { round.tried.add(modelKey(next)); next = chooseCandidate(candidates, { current: round.model, tried: round.tried, failureKind: classification.kind, health: health.snapshot }); continue }
+      if (!await health.claimProvider(next)) { round.tried.add(modelKey(next)); next = chooseCandidate(candidates, { current: round.model, tried: round.tried, failureKind: classification.kind, health: health.snapshot, avoidEndpoints: failTracker.isolated }); continue }
       round.attempts++
       ctx.ui.setWorkingMessage(`模型异常，正在切换到 ${modelKey(next)}…`)
       const set = await pi.setModel(next).catch(() => false)
       if (!set) {
         health.recordFailure('model', modelKey(next), 'model_config', 'Pi refused model selection')
         round.tried.add(modelKey(next)); await health.flush()
-        next = chooseCandidate(candidates, { current: round.model, tried: round.tried, failureKind: classification.kind, health: health.snapshot })
+        next = chooseCandidate(candidates, { current: round.model, tried: round.tried, failureKind: classification.kind, health: health.snapshot, avoidEndpoints: failTracker.isolated })
         continue
       }
       round.model = next
@@ -160,7 +176,7 @@ export default function (pi: ExtensionAPI) {
     if (event.source === 'extension') return { action: 'continue' }
     clearWatchdog()
     lastStatus = {}
-    round = { id: (round?.id ?? 0) + 1, phase: 'monitoring', startedAt: Date.now(), text: event.text, images: event.images, tried: new Set(), attempts: 0, hadTool: false, inTool: false, hadOutput: false, watchdog: false, cleanRetry: false, model: ctx.model }
+    round = { id: (round?.id ?? 0) + 1, phase: 'monitoring', startedAt: Date.now(), text: event.text, images: event.images, tried: new Set(), attempts: 0, hadTool: false, inTool: false, hadOutput: false, watchdog: false, cleanRetry: false, model: ctx.model, endpointFails: undefined }
     status(ctx)
     return { action: 'continue' }
   })
@@ -238,8 +254,8 @@ export default function (pi: ExtensionAPI) {
   pi.registerCommand('ccswitch-test', { description: '检查 CCSwitch 候选模型和健康状态（不切换模型）', handler: async (_args, ctx) => {
     await refresh(ctx)
     const snapshot = candidateSnapshot(ctx.scopedModels, ctx.modelRegistry.getAvailable())
-    const healthy = snapshot.models.filter(model => !health.isBlocked(model)).length
+    const counts = summarizeCandidateHealth(snapshot.models, health.snapshot)
     const source = snapshot.source === 'scoped' ? `Pi scope ${snapshot.sourceEntries} 条` : `Pi 注册表 ${snapshot.sourceEntries} 条`
-    notify(ctx, `CCSwitch 自检：${source} · 唯一模型 ${snapshot.models.length} · 健康 ${healthy}`, snapshot.models.length ? 'info' : 'warning')
+    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.1",
+  "version": "0.1.3",
   "description": "Provider-first automatic model failover extension for Pi and CC Switch",
   "license": "MIT",
   "keywords": [