@genee/omp-opsx-addon 0.1.0

package/lib/reachability-probe.ts

@@ -0,0 +1,459 @@
+/**
+ * Provider 可达性探测模块。
+ *
+ * 职责：
+ * 1. 从候选模型列表中按 provider 分组提取去重端点
+ * 2. 对端点执行 TLS 握手探测（判可达）
+ * 3. 可选第二层 HTTP 探测（probe_http_enabled 开启时）
+ *
+ * 探测策略（遵循 design.md D1-D3）：
+ * - D1: 按 provider 去重端点，同 host 任一可达即 provider 可达（宽容策略）
+ * - D2: 第一层 TLS 握手探测，成功或证书验证阶段错误判可达，超时/连接失败/重置判不可达
+ * - D3: 第二层 HTTP 探测默认关闭，留接口
+ *
+ * 探测异常全部吞没并 warn，不向上抛出。
+ */
+
+import { connect as tlsConnect } from 'node:tls';
+import type { TLSSocket } from 'node:tls';
+import type { Model, Api } from '@oh-my-pi/pi-catalog/types';
+import { resolveCursorAccessToken } from './cursor-auth.js';
+
+// ── 类型 ────────────────────────────────────────────────────────────────
+
+/** 去重后的探测端点。 */
+export interface ProbeEndpoint {
+  host: string;
+  port: number;
+}
+
+/** 单端点探测结果。 */
+export interface ProbeResult {
+  reachable: boolean;
+  /** 探测方法：'tls'、'http' 或 'discovery' */
+  method: 'tls' | 'http' | 'discovery';
+  /** 被探测的主机名 */
+  host: string;
+  /** 失败原因，仅 reachable=false 时有值 */
+  reason?: string;
+  /** 模型级探测的真实可用模型 id 列表（仅 discovery 方法） */
+  availableModelIds?: string[];
+}
+
+/**
+ * TLS 连接工厂签名，测试 seam 可替换。
+ * 默认实现为 node:tls 的 connect。
+ */
+export interface TlsConnectFn {
+  (opts: {
+    host: string;
+    port: number;
+    servername: string;
+    timeout: number;
+  }): TLSSocket;
+}
+
+/** 每个 provider 的去重端点集合。 */
+export type ProviderEndpoints = Map<string, ProbeEndpoint[]>;
+
+// ── 端点提取 ─────────────────────────────────────────────────────────────
+
+/**
+ * 解析 URL 中的 host 与 port，未指定端口默认 443。
+ */
+function parseHostPort(baseUrl: string): ProbeEndpoint | null {
+  try {
+    const u = new URL(baseUrl);
+    const host = u.hostname;
+    if (!host) return null;
+    return { host, port: u.port ? parseInt(u.port, 10) : 443 };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 从模型列表中按 provider 分组提取去重端点。
+ * 同一 provider 的模型共用 baseUrl 端点，只保留一次。
+ */
+export function extractEndpoints(models: Model<Api>[]): ProviderEndpoints {
+  const result: ProviderEndpoints = new Map();
+  for (const m of models) {
+    if (!m.baseUrl) continue;
+    const ep = parseHostPort(m.baseUrl);
+    if (!ep) continue;
+
+    let eps = result.get(m.provider);
+    if (!eps) {
+      eps = [];
+      result.set(m.provider, eps);
+    }
+    // 去重：同一 provider 下同 host:port 只保留一个
+    if (!eps.some((e) => e.host === ep.host && e.port === ep.port)) {
+      eps.push(ep);
+    }
+  }
+  return result;
+}
+
+// ── 证书错误判定 ─────────────────────────────────────────────────────────
+
+/** 错误消息包含这些子串 → 证书验证阶段错误 → 判可达。 */
+const CERT_ERROR_TOKENS = [
+  'CERT_',
+  'UNABLE_TO_VERIFY',
+  'certificate',
+  'self signed',
+  'SELF_SIGNED',
+  'DEPTH_ZERO_SELF_SIGNED',
+  'ERR_SSL_',
+  'SSL_',
+];
+
+/**
+ * 判定 TLS 错误是否为证书验证阶段错误（非网络不可达）。
+ * 规则 design.md D2：握手到达证书验证阶段即判可达。
+ */
+function isCertError(msg: string): boolean {
+  return CERT_ERROR_TOKENS.some((tok) => msg.includes(tok));
+}
+
+// ── 单端点 TLS 探测 ──────────────────────────────────────────────────────
+
+/**
+ * 对单个端点执行 TLS 握手探测。
+ *
+ * 判定规则（design.md D2）：
+ * - TLS 握手成功 → 可达
+ * - 证书验证阶段错误 → 可达（证书问题不等于网络不可达）
+ * - 超时 → 不可达
+ * - 连接拒绝/重置/网络不可达 → 不可达
+ */
+function probeTlsEndpoint(
+  endpoint: ProbeEndpoint,
+  timeoutMs: number,
+  connectFn: TlsConnectFn,
+): Promise<ProbeResult> {
+  return new Promise<ProbeResult>((resolve) => {
+    const socket = connectFn({
+      host: endpoint.host,
+      port: endpoint.port,
+      servername: endpoint.host,
+      timeout: timeoutMs,
+    });
+
+    let settled = false;
+
+    const settle = (reachable: boolean, reason?: string) => {
+      if (settled) return;
+      settled = true;
+      try { socket.destroy(); } catch { /* ignore */ }
+      resolve({ reachable, method: 'tls', host: endpoint.host, reason });
+    };
+
+    socket.on('secureConnect', () => settle(true));
+
+    socket.on('error', (err: NodeJS.ErrnoException) => {
+      const msg = err.message || '';
+      if (isCertError(msg)) {
+        settle(true);
+      } else {
+        settle(false, msg);
+      }
+    });
+
+    socket.on('timeout', () => {
+      settle(false, `timeout after ${timeoutMs}ms`);
+    });
+  });
+}
+
+// ── HTTP 探测（第二层，默认关闭）─────────────────────────────────────────
+
+/** HTTP 探测配置 */
+export interface HttpProbeOptions {
+  /** API key resolver（用于最小 chat completion 请求，可同步或异步） */
+  getApiKey?: (provider: string) => string | undefined | Promise<string | undefined>;
+  /** 超时 ms */
+  timeoutMs: number;
+  /** 最小 chat completion 使用的模型 ID */
+  model?: string;
+  /** fetch 实现（测试 seam，默认全局 fetch） */
+  fetchImpl?: typeof fetch;
+}
+
+/** 区域封锁判定的关键词 */
+const REGION_BLOCK_TOKENS = ['region', 'not available', 'in your area'];
+
+/**
+ * 对 TLS 可达的端点发送最小 HTTP 请求（1 token chat completion），
+ * 检测区域封锁类 403。
+ *
+ * probe_http_enabled 时在第一层 TLS 探测之后调用。
+ * 返回 403 且错误文本包含 region 字样 → 判不可达。
+ * 200/401/404/429 判可达（网络可达，只是鉴权/路径/限流问题）。
+ * 网络异常/超时吞没并判不可达。
+ */
+export async function probeHttp(
+  endpoint: ProbeEndpoint,
+  provider: string,
+  opts: HttpProbeOptions,
+): Promise<ProbeResult> {
+  const fetchFn = opts.fetchImpl ?? fetch;
+  const apiKey = await opts.getApiKey?.(provider);
+  const model = opts.model ?? 'default';
+
+  const base = endpoint.port === 443
+    ? `https://${endpoint.host}`
+    : `https://${endpoint.host}:${endpoint.port}`;
+  const url = `${base}/chat/completions`;
+
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (apiKey) {
+      headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+
+    const response = await fetchFn(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: 'hi' }],
+        max_tokens: 1,
+      }),
+      signal: AbortSignal.timeout(opts.timeoutMs),
+    });
+
+    // 403 + region 关键词 → 区域封锁 → 不可达
+    if (response.status === 403) {
+      try {
+        const text = await response.text();
+        const lower = text.toLowerCase();
+        if (REGION_BLOCK_TOKENS.some((tok) => lower.includes(tok))) {
+          return {
+            reachable: false,
+            method: 'http',
+            host: endpoint.host,
+            reason: `403 region blocked: ${text.slice(0, 200)}`,
+          };
+        }
+      } catch {
+        // 无法读取响应体 → 至少 network 是通的 → 可达
+      }
+    }
+
+    // 200/401/404/429 → 网络可达（鉴权失败/模型不存在/限流 = 网络正常）
+    return {
+      reachable: true,
+      method: 'http',
+      host: endpoint.host,
+    };
+  } catch (e: unknown) {
+    // 网络异常/超时 → 不可达；吞没异常不向上抛
+    const err = e as Error & { name?: string };
+    if (err.name === 'AbortError' || err.name === 'TimeoutError') {
+      return {
+        reachable: false,
+        method: 'http',
+        host: endpoint.host,
+        reason: `timeout after ${opts.timeoutMs}ms`,
+      };
+    }
+    return {
+      reachable: false,
+      method: 'http',
+      host: endpoint.host,
+      reason: err.message ?? String(e),
+    };
+  }
+}
+
+// ── 模型级可用性探测（动态发现过滤）──────────────────────────────────────
+
+/** 模型级探测配置 */
+export interface AvailableModelsProbeOptions {
+  /** 超时 ms，默认 3000 */
+  timeoutMs?: number;
+  /** fetch 实现（测试 seam，默认全局 fetch） */
+  fetchImpl?: typeof fetch;
+  /** cursor access token 解析器（默认用 cursor-auth 的 resolveCursorAccessToken） */
+  resolveCursorToken?: () => Promise<{ accessToken: string } | null>;
+  /** opencode-go auth cookie（默认读 OPENCODE_GO_AUTH_COOKIE） */
+  opencodeCookie?: string;
+  /** opencode-go workspace id（默认读 OPENCODE_GO_WORKSPACE_ID） */
+  opencodeWorkspaceId?: string;
+}
+
+/** 模型级探测结果。availableIds 为 null 表示无动态发现接口或探测失败。 */
+export interface AvailableModelsResult {
+  provider: string;
+  /** 真实可用的模型 id 集合；null = 未知（不应用过滤） */
+  availableIds: string[] | null;
+  /** 探测方法 */
+  method: 'discovery';
+  host: string;
+}
+
+const CURSOR_GET_USABLE_MODELS_URL = 'https://api2.cursor.sh/agent.v1.AgentService/GetUsableModels';
+
+/**
+ * 探测 cursor 的真实可用模型（GetUsableModels）。
+ * 返回可用 modelId 列表；失败返回 null（不阻断）。
+ */
+async function probeCursorModels(opts: AvailableModelsProbeOptions): Promise<string[] | null> {
+  try {
+    const resolveToken = opts.resolveCursorToken ?? (async () => {
+      const { accessToken } = (await resolveCursorAccessToken()) ?? {};
+      return accessToken ? { accessToken } : null;
+    });
+    const auth = await resolveToken();
+    if (!auth?.accessToken) return null;
+
+    const fetchFn = opts.fetchImpl ?? fetch;
+    const res = await fetchFn(CURSOR_GET_USABLE_MODELS_URL, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${auth.accessToken}`,
+        'x-cursor-client-version': '0.1.0',
+      },
+      body: JSON.stringify({}),
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 3000),
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { models?: Array<{ modelId?: string }> };
+    const ids = (data.models ?? []).map((m) => m.modelId).filter((x): x is string => !!x);
+    return ids.length > 0 ? ids : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 探测 opencode-go 的真实可用模型（GET /v1/models，OpenAI 兼容）。
+ * 返回可用模型 id 列表；失败返回 null。
+ */
+async function probeOpencodeModels(opts: AvailableModelsProbeOptions): Promise<string[] | null> {
+  try {
+    const cookie = opts.opencodeCookie ?? process.env.OPENCODE_GO_AUTH_COOKIE?.trim() ?? '';
+    const wsId = opts.opencodeWorkspaceId ?? process.env.OPENCODE_GO_WORKSPACE_ID?.trim() ?? '';
+    if (!cookie || !wsId) return null;
+
+    const fetchFn = opts.fetchImpl ?? fetch;
+    const res = await fetchFn('https://opencode.ai/zen/go/v1/models', {
+      headers: { authorization: `Bearer ${cookie}` },
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 3000),
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { data?: Array<{ id?: string }> };
+    const ids = (data.data ?? []).map((m) => m.id).filter((x): x is string => !!x);
+    return ids.length > 0 ? ids : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 支持动态发现接口的 provider → 探测函数。 */
+const AVAILABLE_MODELS_PROBES: Record<string, (opts: AvailableModelsProbeOptions) => Promise<string[] | null>> = {
+  cursor: probeCursorModels,
+  'opencode-go': probeOpencodeModels,
+};
+
+/**
+ * 对 provider 执行模型级可用性探测。
+ * 无动态发现接口的 provider 返回 { availableIds: null }（不应用过滤）。
+ * 异常全部吞没并返回 null，绝不抛出。
+ */
+export async function probeAvailableModels(
+  provider: string,
+  opts: AvailableModelsProbeOptions = {},
+): Promise<AvailableModelsResult> {
+  const probe = AVAILABLE_MODELS_PROBES[provider];
+  const host = provider === 'cursor' ? 'api2.cursor.sh' : 'opencode.ai';
+  if (!probe) {
+    return { provider, availableIds: null, method: 'discovery', host };
+  }
+  const ids = await probe(opts);
+  return { provider, availableIds: ids, method: 'discovery', host };
+}
+
+// ── 批量探测 ─────────────────────────────────────────────────────────────
+
+export interface ProbeProvidersOptions {
+  /** 单端点超时 ms，默认 3000 */
+  timeoutMs?: number;
+  /** TLS 连接工厂（测试 seam） */
+  connectionFactory?: TlsConnectFn;
+}
+
+/**
+ * 对全部 provider 的端点并发执行 TLS 探测。
+ *
+ * 返回按 provider 分组的探测结果。
+ * provider 判可达规则：其下任一端点可达即判可达（宽容策略，design.md D1）。
+ * 探测异常的端点记录 warn 并继续。
+ */
+export async function probeProviders(
+  providerEndpoints: ProviderEndpoints,
+  opts: ProbeProvidersOptions = {},
+): Promise<Map<string, ProbeResult>> {
+  const timeoutMs = opts.timeoutMs ?? 3000;
+  const connectFn = opts.connectionFactory ?? tlsConnect;
+
+  // 对每个 provider 的全部端点并发探测
+  const probes: Promise<[string, ProbeResult]>[] = [];
+
+  for (const [provider, endpoints] of providerEndpoints) {
+    for (const ep of endpoints) {
+      probes.push(
+        probeTlsEndpoint(ep, timeoutMs, connectFn).then(
+          (r) => [provider, r] as [string, ProbeResult],
+        ),
+      );
+    }
+  }
+
+  const settled = await Promise.allSettled(probes);
+
+  // 按 provider 聚合：任一可达即 provider 可达
+  const providerReachability = new Map<string, boolean>();
+  const providerReasons: string[] = [];
+
+  for (const s of settled) {
+    if (s.status === 'rejected') {
+      console.warn(`[omp-opsx-addon] probe error: ${s.reason}`);
+      continue;
+    }
+    const [provider, result] = s.value;
+    if (!providerReachability.has(provider)) {
+      providerReachability.set(provider, result.reachable);
+    } else if (result.reachable) {
+      providerReachability.set(provider, true);
+    }
+    if (!result.reachable) {
+      providerReasons.push(`${provider}/${result.host}: ${result.reason ?? 'unreachable'}`);
+    }
+  }
+
+  if (providerReasons.length > 0) {
+    console.warn(`[omp-opsx-addon] unreachable endpoints:\n  ${providerReasons.join('\n  ')}`);
+  }
+
+  // 构建返回结果
+  const results = new Map<string, ProbeResult>();
+  for (const [provider, reachable] of providerReachability) {
+    const eps = providerEndpoints.get(provider) ?? [];
+    const mainHost = eps[0]?.host ?? 'unknown';
+    results.set(provider, {
+      reachable,
+      method: 'tls',
+      host: mainHost,
+      reason: reachable ? undefined : 'no reachable endpoint',
+    });
+  }
+
+  return results;
+}

package/lib/reachability-refresh.ts

@@ -0,0 +1,84 @@
+import type { Model, Api } from '@oh-my-pi/pi-catalog/types';
+import type { ResolvedOpsxConfig } from './unified-config.js';
+import { extractEndpoints, probeAvailableModels, probeProviders } from './reachability-probe.js';
+import {
+    getAvailableModelIds,
+    getFreshlyProbedProviders,
+    getUnreachableProviders,
+    mergeProbeResults,
+    type CacheProbeResult,
+} from './reachability-cache.js';
+
+const DISCOVERY_PROVIDERS = ['cursor', 'opencode-go'] as const;
+
+export function loadAvailableByProvider(ttlMs: number): Map<string, string[] | null> {
+    const map = new Map<string, string[] | null>();
+    for (const p of DISCOVERY_PROVIDERS) {
+        map.set(p, getAvailableModelIds(p, ttlMs));
+    }
+    return map;
+}
+
+/**
+ * Refresh TLS + model-discovery caches. Cursor GetUsableModels is probed when
+ * the TTL cache has no list, so regional Claude/GPT never enter first pick.
+ */
+export async function refreshReachability(
+    models: Model<Api>[] | null | undefined,
+    config: Pick<ResolvedOpsxConfig, 'probe_enabled' | 'probe_timeout_ms' | 'probe_ttl_ms' | 'excluded_providers'>,
+): Promise<{ unreachable: Set<string>; availableByProvider: Map<string, string[] | null> }> {
+    const ttl = config.probe_ttl_ms;
+    const excluded = new Set(config.excluded_providers);
+    const unreachable = getUnreachableProviders(ttl);
+    for (const p of excluded) unreachable.add(p);
+
+    if (!config.probe_enabled || !models || models.length === 0) {
+        return { unreachable, availableByProvider: loadAvailableByProvider(ttl) };
+    }
+
+    const endpoints = extractEndpoints(models);
+    for (const p of excluded) endpoints.delete(p);
+    const fresh = getFreshlyProbedProviders(ttl);
+    for (const p of [...endpoints.keys()]) {
+        if (fresh.has(p)) endpoints.delete(p);
+    }
+    if (endpoints.size > 0) {
+        const tls = await probeProviders(endpoints, { timeoutMs: config.probe_timeout_ms });
+        const mapped = new Map<string, CacheProbeResult>();
+        for (const [provider, result] of tls) {
+            mapped.set(provider, {
+                reachable: result.reachable,
+                method: result.method,
+                host: result.host,
+                reason: result.reason,
+            });
+            // Cursor / OpenCode Go stay in the pool even if a 3s TLS probe
+            // of the public host fails — quota fetch and discovery are the
+            // real signals. TLS exclusion is for official Anthropic/OpenAI etc.
+            if (!result.reachable && !(DISCOVERY_PROVIDERS as readonly string[]).includes(provider)) {
+                unreachable.add(provider);
+            }
+        }
+        mergeProbeResults(mapped);
+    }
+
+    const discovery = new Map<string, CacheProbeResult>();
+    await Promise.all(
+        DISCOVERY_PROVIDERS.map(async (provider) => {
+            if (excluded.has(provider)) return;
+            if (getAvailableModelIds(provider, ttl)) return;
+            const r = await probeAvailableModels(provider, { timeoutMs: config.probe_timeout_ms });
+            if (!r.availableIds) return;
+            discovery.set(provider, {
+                reachable: true,
+                method: 'discovery',
+                host: r.host,
+                availableModelIds: r.availableIds,
+            });
+        }),
+    );
+    if (discovery.size > 0) mergeProbeResults(discovery);
+
+    for (const p of getUnreachableProviders(ttl)) unreachable.add(p);
+    return { unreachable, availableByProvider: loadAvailableByProvider(ttl) };
+}

package/lib/selection-filters.ts

@@ -0,0 +1,100 @@
+import type { Model, Api } from '@oh-my-pi/pi-catalog/types';
+import { matchesSelector, matchesTokenPrefix } from './family-filter.js';
+
+/** Case-insensitive model-id membership for GetUsableModels / /v1/models lists. */
+export function idInAvailableList(modelId: string, available: readonly string[]): boolean {
+    const t = modelId.toLowerCase();
+    for (const raw of available) {
+        const a = raw.toLowerCase();
+        if (a === t) return true;
+        if (a.endsWith(`/${t}`) || t.endsWith(`/${a}`)) return true;
+    }
+    return false;
+}
+
+export function filterSelectableModels<T extends { provider: string; id: string }>(
+    models: T[],
+    opts: {
+        blockedSelectors?: Set<string>;
+        unreachableProviders?: Set<string>;
+        excludedProviders?: readonly string[];
+        /** provider → discovered ids; missing/null means unknown (do not filter that provider). */
+        availableByProvider?: Map<string, string[] | null>;
+        /** Keep only models matching any of these selectors (three-level grammar OR). */
+        selectors?: readonly string[];
+        /**
+         * Drop models matching any of these selectors. ALWAYS evaluated with the
+         * bare-word (token-prefix) semantics regardless of the selector shape: a
+         * glob input is tokenized like a bare word (`*` and other non-alphanumerics
+         * split it, `*` is dropped) and never dispatched through the glob grammar.
+         * The only caller is the `--china` CHINA_EXCLUDE_FAMILIES gateway.
+         */
+        excludeSelectors?: readonly string[];
+    },
+): T[] {
+    const blocked = opts.blockedSelectors ?? new Set();
+    const unreachable = opts.unreachableProviders ?? new Set();
+    const excluded = new Set(opts.excludedProviders ?? []);
+    const available = opts.availableByProvider;
+    const selectors = opts.selectors;
+    const excludeSelectors = opts.excludeSelectors;
+
+    const discoveryWipes = new Set<string>();
+    if (available) {
+        const counts = new Map<string, { total: number; kept: number }>();
+        for (const m of models) {
+            if (excluded.has(m.provider) || unreachable.has(m.provider)) continue;
+            const list = available.get(m.provider);
+            if (!list || list.length === 0) continue;
+            const st = counts.get(m.provider) ?? { total: 0, kept: 0 };
+            st.total++;
+            if (idInAvailableList(m.id, list)) st.kept++;
+            counts.set(m.provider, st);
+        }
+        for (const [p, st] of counts) {
+            if (st.total > 0 && st.kept === 0) discoveryWipes.add(p);
+        }
+    }
+
+    return models.filter((m) => {
+        if (excluded.has(m.provider) || unreachable.has(m.provider)) return false;
+        if (blocked.has(`${m.provider}/${m.id}`)) return false;
+        const list = available?.get(m.provider);
+        if (list && list.length > 0 && !discoveryWipes.has(m.provider) && !idInAvailableList(m.id, list)) {
+            return false;
+        }
+        // Selector constraint, orthogonal to the provider-level filters above.
+        if (selectors && selectors.length > 0 && !selectors.some((f) => matchesSelector(m.provider, m.id, f))) {
+            return false;
+        }
+        if (excludeSelectors && excludeSelectors.some((f) => matchesTokenPrefix(m.provider, m.id, f))) {
+            return false;
+        }
+        return true;
+    });
+}
+
+export function collectAvailableByProvider(
+    providers: readonly string[],
+    getIds: (provider: string) => string[] | null,
+): Map<string, string[] | null> {
+    const map = new Map<string, string[] | null>();
+    for (const p of providers) {
+        map.set(p, getIds(p));
+    }
+    return map;
+}
+
+export function reachabilityFingerprint(opts: {
+    unreachable: Iterable<string>;
+    availableByProvider: Map<string, string[] | null>;
+    blocked: Iterable<string>;
+}): string {
+    const u = [...opts.unreachable].sort().join(',');
+    const b = [...opts.blocked].sort().join(',');
+    const a = [...opts.availableByProvider.entries()]
+        .sort(([x], [y]) => x.localeCompare(y))
+        .map(([p, ids]) => `${p}=${ids ? ids.slice().sort().join('+') : '?'}`)
+        .join('|');
+    return `u:${u};b:${b};a:${a}`;
+}

package/lib/selection-lifecycle.ts

@@ -0,0 +1,17 @@
+import type { Model, Api } from '@oh-my-pi/pi-catalog/types';
+import { candidateQuota } from './model-selector.js';
+import type { ProviderHealth } from './usage-resolver.js';
+
+export function shouldReselectPrimary(opts: {
+    explicitModel: boolean;
+    current: { provider: string; id: string; name?: string } | null;
+    health: Map<string, ProviderHealth> | null | undefined;
+    nextPick: Model<Api> | null;
+}): boolean {
+    if (opts.explicitModel) return false;
+    if (!opts.current) return false;
+    const quota = candidateQuota(opts.current, opts.health?.get(opts.current.provider));
+    if (!quota.exhausted) return false;
+    if (!opts.nextPick) return false;
+    return opts.nextPick.provider !== opts.current.provider || opts.nextPick.id !== opts.current.id;
+}