pi-ccswitch-auto-switch 0.1.6 → 0.2.0

package/README.md

@@ -13,7 +13,8 @@ The extension observes real Pi requests, records sanitized health signals, and
 - 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.
+- Learns model-family content-policy constraints from real failures (`glm-4.5` and `GLM-4.6`, for example, are both `glm`) and avoids the entire family during current and future content-policy failover chains. Evidence expires after 30 days.
+- Applies hard health, failure-domain, policy-family, input-modality, and context filters before ranking candidates by provider diversity, model equivalence, capability compatibility, and historical reliability.
   - Independent-provider semantics: a copied vendor (e.g. `my-provider-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.
@@ -54,7 +55,7 @@ CC Switch should be configured normally. This extension deliberately does not wr
 | `/ccswitch refresh` | Refresh Pi's model registry and the status display. |
 | `/ccswitch reactivate <provider/model\|all>` | Clear a breaker and let the next real request verify recovery, while preserving history. |
 | `/ccswitch disable <provider/model>` | Manually exclude a model from failover. |
-| `/ccswitch reset <provider/model\|all>` | Delete selected health history after confirmation. |
+| `/ccswitch reset <provider/model\|all>` | Delete selected health history after confirmation; `all` also clears learned content-policy constraints. |
 | `/ccswitch-test` | Inspect candidate discovery without changing models. |
 
 Examples:
@@ -90,15 +91,16 @@ The state machine waits for Pi's native retry cycle to settle before switching.
 | --- | --- | --- |
 | `401`, `403`, quota, billing | Provider | 30 minutes |
 | `429` | Provider | `Retry-After` when present; otherwise 5 minutes |
-| DNS, network, `5xx`, interrupted stream | Endpoint | 2 minutes |
+| DNS, network, `408`, `5xx`, interrupted stream | Endpoint | 2 minutes |
 | `404`, invalid model, incompatible parameters | Model | 15 minutes |
-| Content filtering or context overflow | Current round only | None |
+| Content-policy or sensitive-content rejection | Current model + learned model-family constraint | 2-minute model cooldown; 30-day family evidence |
+| Context overflow | Current round only | None |
 
-Cooldowns grow exponentially within bounded limits. Context-overflow retries only consider models with a larger context window. User cancellations are not recorded as failures; watchdog cancellations are recorded as timeouts.
+Cooldowns grow exponentially within bounded limits. Learned policy-constrained families are excluded only after a content-policy rejection; they remain eligible during ordinary rate-limit, network, and model-configuration failovers. Context-overflow retries only consider models with a larger context window, and image requests do not move to a model that explicitly supports text only. Unknown errors are isolated to the current model and still fail over normally. A user cancellation is the only aborted turn that does not trigger failover; watchdog cancellations are recorded as timeouts.
 
 ## Data and privacy
 
-Health state is stored in Pi's agent directory as `ccswitch-auto-switch-state.json`. The extension stores counters, timestamps, cooldowns, and redacted/truncated error summaries. It does not access credentials, authorization headers, CC Switch's database, or Pi's `auth.json`.
+Health state is stored in Pi's agent directory as `ccswitch-auto-switch-state.json`. The extension stores counters, timestamps, cooldowns, learned model-family policy constraints, and redacted/truncated error summaries. It does not access credentials, authorization headers, CC Switch's database, or Pi's `auth.json`.
 
 ## Development
 
@@ -108,7 +110,7 @@ npm run typecheck
 npm test
 ```
 
-Tests use Node's built-in test runner and cover failure classification, provider-first selection, cooldowns, state persistence, and Windows-compatible paths.
+Tests use Node's built-in test runner and cover the failure matrix, family-level policy avoidance, provider-first selection, input compatibility, cooldowns, state persistence, and Windows-compatible paths.
 
 ## License
 

package/README.zh-CN.md

@@ -12,7 +12,8 @@
 - 对认证、额度、账单和限流实施 Provider 优先熔断。
 - 对 DNS、连接、服务端和流中断实施端点熔断。
 - 模型不存在或参数不兼容时仅隔离该模型。
-- 优先选择不同 Provider 的健康模型；同 Provider 的模型排在后面。
+- 内容审查失败会学习模型系列约束（例如 `glm-4.5`、`GLM-4.6` 同属 `glm`），本轮及后续内容审查故障转移会避开整个受限系列；证据 30 天后自动过期。
+- 候选模型先经过健康、故障域、审查系列、输入模态和上下文窗口硬过滤，再按跨 Provider、模型等价性、能力兼容和历史稳定性排序。
 - 首响应 90 秒、流式停滞 120 秒看门狗。
 - 指数退避、`Retry-After` 支持和跨进程 half-open 单探针租约。
 - 原子持久化状态、错误脱敏和有上限的日志。
@@ -52,7 +53,7 @@ pi install npm:pi-ccswitch-auto-switch
 | `/ccswitch refresh` | 刷新 Pi 模型注册表和状态栏。 |
 | `/ccswitch reactivate <provider/model\|all>` | 解除熔断，下一次真实请求验证恢复情况；保留历史。 |
 | `/ccswitch disable <provider/model>` | 手动排除模型。 |
-| `/ccswitch reset <provider/model\|all>` | 确认后删除相应健康历史。 |
+| `/ccswitch reset <provider/model\|all>` | 确认后删除相应健康历史；`all` 同时清除已学习的审查约束。 |
 | `/ccswitch-test` | 仅检查候选发现，不切换模型。 |
 
 ## 状态栏
@@ -80,15 +81,16 @@ CCS ✓70/131 · ⏳61 · ⛔0 · 🔄3 · provider/model-id
 | --- | --- | --- |
 | `401`、`403`、额度或账单问题 | Provider | 30 分钟 |
 | `429` | Provider | 优先使用 `Retry-After`，否则 5 分钟 |
-| DNS、网络、`5xx`、流中断 | 端点 | 2 分钟 |
+| DNS、网络、`408`、`5xx`、流中断 | 端点 | 2 分钟 |
 | `404`、模型不存在、参数不兼容 | 模型 | 15 分钟 |
-| 内容过滤、上下文溢出 | 仅本轮 | 无 |
+| 内容审查/敏感拦截 | 当前模型 + 模型系列约束 | 模型冷却 2 分钟；系列避让证据 30 天 |
+| 上下文溢出 | 仅本轮 | 无 |
 
-冷却时间会指数增长但有上限。上下文溢出时只会选择上下文窗口更大的模型。用户主动取消不计失败；看门狗取消会记录为超时。
+冷却时间会指数增长但有上限。发生内容审查时，插件只在审查故障转移链中避开已标记系列，普通限流、网络或模型配置故障仍可选择这些模型。上下文溢出时只会选择上下文窗口更大的模型；带图片的请求不会切到明确仅支持文本的模型。无法归类的异常按单模型故障处理并正常切换。用户主动取消是唯一不会触发故障转移的异常终止；看门狗取消会记录为超时。
 
 ## 数据与隐私
 
-健康状态保存在 Pi agent 目录的 `ccswitch-auto-switch-state.json`。其中只有计数、时间、冷却信息和脱敏/截断的错误摘要；插件不会访问凭据、Authorization 请求头、CC Switch 数据库或 Pi 的 `auth.json`。
+健康状态保存在 Pi agent 目录的 `ccswitch-auto-switch-state.json`。其中只有计数、时间、冷却信息、模型系列审查约束和脱敏/截断的错误摘要；插件不会访问凭据、Authorization 请求头、CC Switch 数据库或 Pi 的 `auth.json`。
 
 ## 开发
 
@@ -98,7 +100,7 @@ npm run typecheck
 npm test
 ```
 
-测试使用 Node 内置测试运行器，覆盖失败分类、Provider 优先选择、冷却、状态持久化以及 Windows 路径。
+测试使用 Node 内置测试运行器，覆盖失败分类矩阵、系列级审查避让、Provider 优先选择、输入兼容、冷却、状态持久化以及 Windows 路径。
 
 ## 许可证
 

package/candidates.ts

@@ -1,12 +1,16 @@
-import type { ModelRef, ScopedModel } from './types.ts'
+import type { FailureClass, ModelRef, ScopedModel } from './types.ts'
 import { endpointKey, modelKey, type HealthState } from './health.ts'
 
 export interface CandidateOptions {
   current?: ModelRef
   tried: Set<string>
-  failureKind?: string
+  failureKind?: FailureClass
   health: HealthState
   avoidEndpoints?: Set<string>
+  /** 模型系列已被证实存在内容审查约束时，本轮不再选择该系列。 */
+  avoidFamilies?: ReadonlySet<string>
+  /** 本轮输入真正需要的模态；显式声明不支持的候选会被排除。 */
+  requiredInputs?: readonly string[]
 }
 
 export interface CandidateSnapshot {
@@ -76,22 +80,64 @@ export function chooseCandidate(models: ModelRef[], options: CandidateOptions):
   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.avoidFamilies?.has(modelFamily(model))) return false
+    if (!supportsRequiredInputs(model, options.requiredInputs)) return false
     if (options.failureKind === 'context_overflow' && current && (model.contextWindow ?? 0) <= (current.contextWindow ?? 0)) return false
     return true
   })
-  return candidates.sort((a, b) => score(a, current) - score(b, current))[0]
+  return candidates.sort((a, b) => score(a, current, options.health) - score(b, current, options.health))[0]
 }
 
-function score(candidate: ModelRef, current?: ModelRef): number {
+/**
+ * 返回跨 Provider 稳定的模型系列标识。内容审查通常是模型系列的能力约束，而不是某个 API Key
+ * 或单一部署的瞬时故障，因此已知系列使用显式规则；未知模型则保守地按版本号前的 id 归组。
+ */
+export function modelFamily(model: Pick<ModelRef, 'id' | 'name'>): string {
+  const identity = `${model.id} ${model.name ?? ''}`.toLowerCase()
+  const knownFamilies: Array<[string, RegExp]> = [
+    ['glm', /(?:^|[^a-z0-9])(?:chat)?glm(?:$|[^a-z])/],
+    ['qwen', /(?:^|[^a-z0-9])qwen(?:$|[^a-z])/],
+    ['deepseek', /(?:^|[^a-z0-9])deepseek(?:$|[^a-z])/],
+    ['kimi', /(?:^|[^a-z0-9])(?:kimi|moonshot)(?:$|[^a-z])/],
+    ['gpt', /(?:^|[^a-z0-9])gpt(?:$|[^a-z])/],
+    ['claude', /(?:^|[^a-z0-9])claude(?:$|[^a-z])/],
+    ['gemini', /(?:^|[^a-z0-9])gemini(?:$|[^a-z])/],
+    ['llama', /(?:^|[^a-z0-9])llama(?:$|[^a-z])/],
+    ['mistral', /(?:^|[^a-z0-9])mistral(?:$|[^a-z])/],
+    ['minimax', /(?:^|[^a-z0-9])minimax(?:$|[^a-z])/],
+    ['ernie', /(?:^|[^a-z0-9])ernie(?:$|[^a-z])/],
+    ['doubao', /(?:^|[^a-z0-9])doubao(?:$|[^a-z])/],
+    ['hunyuan', /(?:^|[^a-z0-9])hunyuan(?:$|[^a-z])/],
+  ]
+  for (const [family, pattern] of knownFamilies) if (pattern.test(identity)) return family
+
+  const leaf = model.id.toLowerCase().split('/').pop() ?? model.id.toLowerCase()
+  return leaf
+    .replace(/(?:[-_.]v)?\d+(?:[.-]\d+)*(?:[-_.].*)?$/, '')
+    .replace(/[-_.:]+$/, '') || leaf
+}
+
+function supportsRequiredInputs(candidate: ModelRef, required: readonly string[] | undefined): boolean {
+  if (!required?.length || !candidate.input?.length) return true
+  return required.every(input => candidate.input!.includes(input))
+}
+
+function score(candidate: ModelRef, current: ModelRef | undefined, health: HealthState): number {
   if (!current) return 0
+  // 排序优先级：故障域多样性 > 原模型等价性 > 输入/推理/上下文兼容性 > 历史稳定性。
+  // 硬约束（冷却、审查系列、输入模态、上下文溢出）已在上方 filter 中处理。
   const sameProvider = candidate.provider === current.provider ? 1000 : 0
   const differentId = candidate.id === current.id ? 0 : 100
   const inputMismatch = sameInputs(candidate, current) ? 0 : 20
   const reasoningMismatch = candidate.reasoning === current.reasoning ? 0 : 10
   const contextPenalty = (candidate.contextWindow ?? 0) < (current.contextWindow ?? 0) ? 5 : 0
-  return sameProvider + differentId + inputMismatch + reasoningMismatch + contextPenalty
+  const records = [health.models[modelKey(candidate)], health.providers[candidate.provider], health.endpoints[endpointKey(candidate)]]
+  const historicalPenalty = Math.min(80, records.reduce((sum, record) => sum + Math.log2((record?.totalFailures ?? 0) + 1) * 4, 0))
+  return sameProvider + differentId + inputMismatch + reasoningMismatch + contextPenalty + historicalPenalty
 }
 
 function sameInputs(a: ModelRef, b: ModelRef): boolean {
-  return (a.input ?? []).join(',') === (b.input ?? []).join(',')
+  const left = a.input ?? []
+  const right = b.input ?? []
+  return left.length === right.length && left.every(input => right.includes(input))
 }

package/classify.ts

@@ -7,24 +7,30 @@ export interface Classification {
   retryAfterMs?: number
 }
 
-const content = /content[ _-]?filter|sensitive|guardrail|policy[_ ]?violation|content[_ ]?blocked/i
+const content = /content[ _-]?(?:filter|policy|blocked|moderation)|sensitive|guardrail|policy[_ -]?violation|responsibleai|safety[_ -]?(?:policy|filter|violation)|security[_ -]?policy|moderation[_ -]?(?:blocked|failed)|blocked by.{0,20}(?:policy|safety|moderation)|data[_ -]?inspection[_ -]?failed|内容(?:审查|审核|安全|违规|被拦截)|安全审核|安全(?:策略|风控).{0,12}(?:阻断|拦截|拒绝)|审核(?:未通过|不通过|失败)|敏感(?:内容|词|信息)?|政治敏感|涉政|不合规|违反.{0,12}(?:安全|政策|规定)/i
 const quota = /quota|billing|insufficient.?balance|out of budget|usage.?limit|credit.?balance|monthly.?limit/i
 const context = /context.?window|context.?length|too many tokens|prompt is too long|input is too long|token limit/i
-const transport = /dns|enotfound|eai_again|socket|connection|network|fetch failed|timed? ?out|timeout|stream ended|terminated|websocket/i
+const transport = /dns|enotfound|eai_again|econn(?:reset|refused|aborted)|epipe|socket|connection|network|fetch failed|tls|certificate|timed? ?out|timeout|stream ended|terminated|websocket|und_err/i
+const overloaded = /overload|server busy|service unavailable|temporarily unavailable|capacity|upstream|bad gateway/i
 
 export function classifyFailure(observation: FailureObservation): Classification {
   const text = `${observation.rawStopReason ?? ''} ${observation.message ?? ''}`
   const status = observation.status
   if (observation.aborted && !observation.watchdog) return { kind: 'unknown', roundOnly: true }
   if (observation.watchdog) return { kind: 'timeout', scope: 'endpoint', roundOnly: false }
-  if (content.test(text)) return { kind: 'content_policy', roundOnly: true }
+  // 内容审查/敏感拦截属于该模型的失败：按 model 级记录并与冷却（2min×2ⁿ 上限 30min），
+  // chooseCandidate 会排除后自动切换到其他模型，而不是同一内容原样重试到本轮上限。
+  if (content.test(text)) return { kind: 'content_policy', scope: 'model', roundOnly: false }
   if (context.test(text)) return { kind: 'context_overflow', roundOnly: true }
+  if (status === 413) return { kind: 'context_overflow', roundOnly: true }
   if (status === 429) return { kind: 'rate_limit', scope: 'provider', roundOnly: false, retryAfterMs: observation.retryAfterMs }
+  if (status === 402) return { kind: 'quota', scope: 'provider', roundOnly: false }
   if (status === 401 || status === 403) return { kind: 'auth', scope: 'provider', roundOnly: false }
   if (quota.test(text)) return { kind: 'quota', scope: 'provider', roundOnly: false }
+  if (status === 408) return { kind: 'timeout', scope: 'endpoint', roundOnly: false }
   if (status !== undefined && status >= 500) return { kind: 'endpoint', scope: 'endpoint', roundOnly: false }
+  if (transport.test(text) || overloaded.test(text)) return { kind: 'endpoint', scope: 'endpoint', roundOnly: false }
   if (status === 400 || status === 404 || status === 422) return { kind: 'model_config', scope: 'model', roundOnly: false }
-  if (transport.test(text)) return { kind: 'endpoint', scope: 'endpoint', roundOnly: false }
   return { kind: 'unknown', scope: 'model', roundOnly: false }
 }
 

package/health.ts

@@ -24,12 +24,25 @@ export interface HealthRecord {
   leaseUntil?: number
 }
 
+export interface ContentPolicyConstraint {
+  observations: number
+  lastObservedAt: number
+  avoidUntil: number
+  lastModel: string
+  lastError?: string
+}
+
 export interface HealthState {
   schemaVersion: 2
   updatedAt: number
   models: Record<string, HealthRecord>
   providers: Record<string, HealthRecord>
   endpoints: Record<string, HealthRecord>
+  /**
+   * 已从真实失败中学到的模型系列内容审查约束。它不会影响普通故障选模，只在本轮已经
+   * 发生 content_policy 失败时用于避开同类系列。
+   */
+  contentPolicyFamilies?: Record<string, ContentPolicyConstraint>
   /** 累计成功切换次数（跨 session 持久化，用于衡量扩展有效程度） */
   switches?: number
   /** 最近成功切换日志（有限条，环形保留） */
@@ -64,7 +77,7 @@ function safeEndpoint(value: string): string {
 }
 
 function blank(): HealthState {
-  return { schemaVersion: 2, updatedAt: Date.now(), models: {}, providers: {}, endpoints: {}, switches: 0, switchLog: [] }
+  return { schemaVersion: 2, updatedAt: Date.now(), models: {}, providers: {}, endpoints: {}, contentPolicyFamilies: {}, switches: 0, switchLog: [] }
 }
 
 function redact(text: string | undefined): string | undefined {
@@ -91,6 +104,7 @@ export class HealthStore {
   private state: HealthState = blank()
   private dirty = false
   private replaceOnFlush = false
+  private resetModels = new Set<string>()
 
   constructor(dir = agentDir()) { this.dir = dir }
   get file(): string { return join(this.dir, STATE_FILE) }
@@ -143,6 +157,24 @@ export class HealthStore {
     this.touch()
   }
 
+  /**
+   * 内容审查约束比限流/网络故障稳定得多，但仍设置 30 天证据有效期，避免模型策略升级后
+   * 永久污染路由。再次观察到同系列审查会增加证据计数并刷新有效期。
+   */
+  recordContentPolicyConstraint(family: string, model: ModelRef, message?: string): void {
+    const constraints = this.state.contentPolicyFamilies ??= {}
+    const previous = constraints[family]
+    const now = Date.now()
+    constraints[family] = {
+      observations: (previous?.observations ?? 0) + 1,
+      lastObservedAt: now,
+      avoidUntil: now + 30 * 24 * 60 * 60_000,
+      lastModel: modelKey(model),
+      lastError: redact(message),
+    }
+    this.touch()
+  }
+
   recordSuccess(model: ModelRef): void {
     this.close('model', modelKey(model))
     this.close('provider', model.provider)
@@ -192,9 +224,14 @@ export class HealthStore {
   }
 
   reset(target: string | 'all'): void {
-    if (target === 'all') this.state = blank()
-    else delete this.state.models[target]
-    this.replaceOnFlush = true
+    if (target === 'all') {
+      this.state = blank()
+      this.replaceOnFlush = true
+      this.resetModels.clear()
+    } else {
+      delete this.state.models[target]
+      this.resetModels.add(target)
+    }
     this.touch()
   }
 
@@ -221,7 +258,8 @@ export class HealthStore {
   async flush(): Promise<void> {
     if (!this.dirty) return
     await this.withLock(async () => {
-      this.state = mergeState(await this.readDisk(), this.state)
+      if (!this.replaceOnFlush) this.state = mergeState(await this.readDisk(), this.state)
+      for (const key of this.resetModels) delete this.state.models[key]
       await this.commit()
     }).catch(() => {})
   }
@@ -259,6 +297,7 @@ export class HealthStore {
     await rename(temp, this.file)
     this.dirty = false
     this.replaceOnFlush = false
+    this.resetModels.clear()
   }
   private bucket(scope: HealthScope): Record<string, HealthRecord> {
     return scope === 'model' ? this.state.models : scope === 'provider' ? this.state.providers : this.state.endpoints
@@ -314,5 +353,20 @@ function mergeState(a: HealthState, b: HealthState): HealthState {
     .sort((x, y) => y.at - x.at)
     .filter((entry, index, all) => index === 0 || all[index - 1].at !== entry.at || all[index - 1].from !== entry.from || all[index - 1].to !== entry.to)
     .slice(0, 20)
-  return { schemaVersion: 2, updatedAt: Math.max(a.updatedAt ?? 0, b.updatedAt ?? 0), models: mergeBucket(a.models ?? {}, b.models ?? {}), providers: mergeBucket(a.providers ?? {}, b.providers ?? {}), endpoints: mergeBucket(a.endpoints ?? {}, b.endpoints ?? {}), switches, switchLog: log }
+  const contentPolicyFamilies: Record<string, ContentPolicyConstraint> = {}
+  for (const family of new Set([...Object.keys(a.contentPolicyFamilies ?? {}), ...Object.keys(b.contentPolicyFamilies ?? {})])) {
+    const left = a.contentPolicyFamilies?.[family]
+    const right = b.contentPolicyFamilies?.[family]
+    if (!left) contentPolicyFamilies[family] = right!
+    else if (!right) contentPolicyFamilies[family] = left
+    else {
+      const newest = right.lastObservedAt >= left.lastObservedAt ? right : left
+      contentPolicyFamilies[family] = {
+        ...newest,
+        observations: Math.max(left.observations, right.observations),
+        avoidUntil: Math.max(left.avoidUntil, right.avoidUntil),
+      }
+    }
+  }
+  return { schemaVersion: 2, updatedAt: Math.max(a.updatedAt ?? 0, b.updatedAt ?? 0), models: mergeBucket(a.models ?? {}, b.models ?? {}), providers: mergeBucket(a.providers ?? {}, b.providers ?? {}), endpoints: mergeBucket(a.endpoints ?? {}, b.endpoints ?? {}), contentPolicyFamilies, switches, switchLog: log }
 }

package/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI, ExtensionContext, FailureObservation, ModelRef } from './types.ts'
 import { classifyFailure, parseRetryAfter } from './classify.ts'
-import { candidateSnapshot, effectiveCandidates, chooseCandidate, summarizeCandidateHealth } from './candidates.ts'
-import { HealthStore, endpointKey, modelKey } from './health.ts'
+import { candidateSnapshot, effectiveCandidates, chooseCandidate, modelFamily, summarizeCandidateHealth } from './candidates.ts'
+import { HealthStore, endpointKey, modelKey, type HealthState } from './health.ts'
 
 const FIRST_RESPONSE_TIMEOUT = 90_000
 const STREAM_IDLE_TIMEOUT = 120_000
@@ -32,10 +32,26 @@ interface Round {
   observation?: FailureObservation
   model?: ModelRef
   endpointFails?: EndpointFailTracker
+  /** 本轮内容审查故障转移中必须避开的模型系列（包含持久化学到的约束）。 */
+  avoidFamilies?: Set<string>
+  /** 本轮内最后一次成功切换的时间；用于刷新 ROUND_LIMIT 窗口，避免供应商内部重试耗时导致误判“达到上限” */
+  lastSwitchAt?: number
 }
 
 function key(model: ModelRef | undefined): string | undefined { return model && modelKey(model) }
 function canRetry(ctx: ExtensionContext): boolean { return ctx.mode === 'tui' || ctx.mode === 'rpc' }
+function activePolicyFamilies(state: HealthState, now = Date.now()): Set<string> {
+  return new Set(Object.entries(state.contentPolicyFamilies ?? {})
+    .filter(([, record]) => record.avoidUntil > now)
+    .map(([family]) => family))
+}
+
+function resolveModel(ctx: ExtensionContext, provider: string, id: string, previous?: ModelRef): ModelRef {
+  // 优先使用注册表/scope 中的完整元数据，避免 turn_end 消息只有 provider/id 时丢失 BaseURL、
+  // 上下文窗口和输入模态；previous/ctx.model 作为注册表未命中时的后备。
+  const refs = [...ctx.scopedModels.map(item => item.model), ...ctx.modelRegistry.getAvailable(), previous, ctx.model]
+  return refs.find(model => model?.provider === provider && model.id === id) ?? { provider, id }
+}
 
 export default function (pi: ExtensionAPI) {
   const health = new HealthStore()
@@ -49,10 +65,9 @@ export default function (pi: ExtensionAPI) {
   const armWatchdog = (ctx: ExtensionContext, ms: number, roundId: number) => {
     clearWatchdog()
     timer = setTimeout(() => {
-      if (!round || round.id !== roundId || (!ctx.isIdle() && !round.inTool)) {
-        round && (round.watchdog = true)
-        ctx.abort()
-      }
+      if (!round || round.id !== roundId || ctx.isIdle() || round.inTool) return
+      round.watchdog = true
+      ctx.abort()
     }, ms)
     timer.unref?.()
   }
@@ -69,9 +84,11 @@ export default function (pi: ExtensionAPI) {
     const activeModel = round?.model ?? ctx.model
     // 恒显完整状态：健康/总数 · 冷却 · 禁用 · 本session切换 · 当前模型（均为 0 时也显示，便于确认扩展在监控中）
     const plain = round?.phase === 'switching' ? `CCS ↻${round.attempts}/${MAX_ATTEMPTS} ${modelTag(round.model)}` :
+      round?.phase === 'exhausted' ? `CCS ⏸切换停止 ${modelTag(round.model ?? ctx.model)}` :
       `CCS ✓${counts.healthy}/${counts.total} · ⏳${counts.cooling} · ⛔${counts.disabled}${switchSuffix()} · ${modelTag(activeModel)}`
     const theme = ctx.ui.theme
-    ctx.ui.setStatus('ccswitch-ha', theme ? theme.fg(counts.cooling || counts.disabled ? 'warning' : 'success', plain) : plain)
+    const tone = round?.phase === 'exhausted' ? 'error' : counts.cooling || counts.disabled ? 'warning' : 'success'
+    ctx.ui.setStatus('ccswitch-ha', theme ? theme.fg(tone, plain) : plain)
   }
   // 本次 session 成功切换计数：始终显示 🔄N（N=0 也显示，用于确认扩展在监控中）；累计切换数在面板/自检中可见
   const switchSuffix = () => ` · 🔄${sessionSwitches}`
@@ -86,7 +103,7 @@ export default function (pi: ExtensionAPI) {
       '/ccswitch refresh — 刷新 Pi 模型注册表和状态',
       '/ccswitch reactivate <provider/model|all> — 解除熔断，保留历史',
       '/ccswitch disable <provider/model> — 手动禁用模型',
-      '/ccswitch reset <provider/model|all> — 清除健康历史（需确认）',
+      '/ccswitch reset <provider/model|all> — 清除健康历史；all 也会清除已学习的审查约束（需确认）',
       '/ccswitch-test — 自检候选模型，不实际切换',
     ].join('\n'), 'info')
   }
@@ -100,16 +117,19 @@ export default function (pi: ExtensionAPI) {
     const candidates = snapshot.models
     const counts = summarizeCandidateHealth(candidates, state)
     const now = Date.now()
+    const policyFamilies = activePolicyFamilies(state, now)
     const rows = candidates.slice(0, 10).map(model => {
       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` : '健康'
+      const policySuffix = policyFamilies.has(modelFamily(model)) ? ' · 内容审查约束' : ''
+      const baseSuffix = modelRecord?.disabled ? '手动禁用' : blockedUntil > now ? `自动冷却 ${Math.max(1, Math.ceil((blockedUntil - now) / 60_000))}m` : '健康'
+      const suffix = `${baseSuffix}${policySuffix}`
       return `${modelKey(model)}  ${suffix}`
     })
     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} · 本session切换 ${sessionSwitches} · 累计切换 ${state.switches ?? 0}`, 'info')
+      notify(ctx, `CCSwitch：${source} · 唯一模型 ${counts.total} · 健康 ${counts.healthy} · 自动冷却 ${counts.cooling} · 手动禁用 ${counts.disabled} · 审查约束系列 ${policyFamilies.size} · 本session切换 ${sessionSwitches} · 累计切换 ${state.switches ?? 0}`, 'info')
       return
     }
     const scopeLabel = snapshot.source === 'scoped' ? `Pi scope：${snapshot.sourceEntries} 条` : `Pi 可用注册表：${snapshot.sourceEntries} 条`
@@ -119,7 +139,8 @@ export default function (pi: ExtensionAPI) {
       return `  ${time} ${entry.from} 🔄 ${entry.to}`
     })
     const switchPanel = recentSwitches.length ? `\n最近切换：\n${recentSwitches.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${switchSummary}${switchPanel}\n${rows.join('\n') || '没有可用模型'}`, ['刷新', '重新激活当前模型', '禁用当前模型', '重置当前模型历史', '关闭'])
+    const policySummary = policyFamilies.size ? [...policyFamilies].join(', ') : '无'
+    const action = await ctx.ui.select(`CCSwitch 健康面板\n当前：${key(ctx.model) ?? '无'}\n${scopeLabel} · 唯一模型：${counts.total} · 健康：${counts.healthy} · 自动冷却：${counts.cooling} · 手动禁用：${counts.disabled}\n熔断记录：${counts.breakerRecords} · 审查约束系列：${policySummary}\n${switchSummary}${switchPanel}\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') }
@@ -140,7 +161,9 @@ export default function (pi: ExtensionAPI) {
   }
   const failover = async (ctx: ExtensionContext) => {
     if (!round || !round.observation || !round.model || !canRetry(ctx)) return
-    if (round.attempts >= MAX_ATTEMPTS || Date.now() - round.startedAt >= ROUND_LIMIT) return exhaust(ctx, '达到本轮切换上限')
+    // 窗口从上一次成功切换（或本轮开始）起算：供应商内部重试耗时不应消耗整轮限额
+    const windowStart = Math.max(round.startedAt, round.lastSwitchAt ?? 0)
+    if (round.attempts >= MAX_ATTEMPTS || Date.now() - windowStart >= ROUND_LIMIT) return exhaust(ctx, '达到本轮切换上限')
     const classification = classifyFailure(round.observation)
     if (round.observation.aborted && !round.observation.watchdog) { round.phase = 'idle'; clearWatchdog(); status(ctx); return }
     round.phase = 'switching'
@@ -155,27 +178,44 @@ export default function (pi: ExtensionAPI) {
       failTracker.isolated.add(ep)
       await health.log(`endpoint ${ep} failed ${epFails} times this round, isolating endpoint`)
     }
+    if (classification.kind === 'content_policy') {
+      health.recordContentPolicyConstraint(modelFamily(round.model), round.model, round.observation.message)
+      round.avoidFamilies ??= new Set()
+      for (const family of activePolicyFamilies(health.snapshot)) round.avoidFamilies.add(family)
+    }
     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, avoidEndpoints: failTracker.isolated })
+    const candidateOptions = () => ({
+      current: round!.model,
+      tried: round!.tried,
+      failureKind: classification.kind,
+      health: health.snapshot,
+      avoidEndpoints: failTracker.isolated,
+      avoidFamilies: round!.avoidFamilies,
+      requiredInputs: round!.images?.length ? ['text', 'image'] : ['text'],
+    })
+    let next = chooseCandidate(candidates, candidateOptions())
     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, avoidEndpoints: failTracker.isolated }); continue }
+      if (!await health.claimProvider(next)) { round.tried.add(modelKey(next)); next = chooseCandidate(candidates, candidateOptions()); continue }
       round.attempts++
       ctx.ui.setWorkingMessage(`模型异常，正在切换到 ${modelKey(next)}…`)
+      const previousModel = round.model
       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, avoidEndpoints: failTracker.isolated })
+        next = chooseCandidate(candidates, candidateOptions())
         continue
       }
       round.model = next
       round.phase = 'redispatching'
+      // 刷新本轮切换时间窗：成功切换后重新起算 ROUND_LIMIT，避免长重试轮被误判为“达到上限”
+      round.lastSwitchAt = Date.now()
       // 本次 session 成功切换计数 + 持久化累计/日志（衡量扩展有效程度）
       sessionSwitches += 1
-      const fromKey = key(round.model ?? ctx.model)
+      const fromKey = key(previousModel ?? ctx.model)
       health.recordSwitch(fromKey ?? '', modelKey(next), classification.kind)
       await health.flush()
       notify(ctx, `CCSwitch：已切换至 ${modelKey(next)}（${round.attempts}/${MAX_ATTEMPTS}）`, 'info')
@@ -205,7 +245,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, endpointFails: undefined }
+    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, avoidFamilies: undefined }
     status(ctx)
     return { action: 'continue' }
   })
@@ -232,7 +272,7 @@ export default function (pi: ExtensionAPI) {
     const message = event.message
     if (message?.role !== 'assistant' || !round) return
     clearWatchdog()
-    round.model = { provider: message.provider, id: message.model }
+    round.model = resolveModel(ctx, message.provider, message.model, round.model)
     round.hadOutput ||= Boolean(message.content?.length)
     if (message.stopReason === 'error' || message.stopReason === 'aborted') {
       round.phase = 'settled-error'
@@ -248,6 +288,7 @@ export default function (pi: ExtensionAPI) {
     if (!ctx.isIdle()) return
     if (!canRetry(ctx) && round.observation && round.model) {
       const classification = classifyFailure(round.observation)
+      if (classification.kind === 'content_policy') health.recordContentPolicyConstraint(modelFamily(round.model), round.model, round.observation.message)
       if (!classification.roundOnly && classification.scope) {
         const domain = classification.scope === 'model' ? modelKey(round.model) : classification.scope === 'provider' ? round.model.provider : endpointKey(round.model)
         health.recordFailure(classification.scope, domain, classification.kind, round.observation.message, classification.retryAfterMs)
@@ -285,7 +326,8 @@ export default function (pi: ExtensionAPI) {
     const snapshot = candidateSnapshot(ctx.scopedModels, ctx.modelRegistry.getAvailable())
     const counts = summarizeCandidateHealth(snapshot.models, health.snapshot)
     const state = health.snapshot
+    const policyFamilies = activePolicyFamilies(state)
     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} · 本session切换 ${sessionSwitches} · 累计切换 ${state.switches ?? 0}`, counts.total ? 'info' : 'warning')
+    notify(ctx, `CCSwitch 自检：${source} · 唯一模型 ${counts.total} · 健康 ${counts.healthy} · 自动冷却 ${counts.cooling} · 手动禁用 ${counts.disabled} · 熔断记录 ${counts.breakerRecords} · 审查约束系列 ${policyFamilies.size} · 本session切换 ${sessionSwitches} · 累计切换 ${state.switches ?? 0}`, counts.total ? 'info' : 'warning')
   }})
 }

package/package.json

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