@genee/omp-opsx-addon 0.1.0

package/lib/direct-fetchers.ts

@@ -0,0 +1,155 @@
+/**
+ * Direct usage fetchers — merged from omp-plan-usage.
+ * Each fetcher queries a provider's API for remaining quota when OMP's
+ * built-in AuthStorage.fetchUsageReports doesn't cover it.
+ *
+ * API keys are resolved at call time via `getApiKey(provider)`, which is
+ * wired to `ctx.modelRegistry.getApiKeyForProvider` by the plugin entry.
+ * OpenCode Go usage now comes from OMP built-in fetchUsageReports;
+ * this module only covers providers without a working built-in reporter.
+ */
+
+import type { UsageReport } from '@oh-my-pi/pi-ai';
+import type { DirectFetcher, BoundApiKeyResolver } from './usage-resolver.js';
+
+
+async function deepSeekBalance(signal?: AbortSignal, getApiKey?: BoundApiKeyResolver): Promise<UsageReport | null> {
+    const key = await getApiKey?.();
+    if (!key) return null;
+    try {
+        const res = await fetch('https://api.deepseek.com/user/balance', {
+            headers: { Authorization: `Bearer ${key}` },
+            signal,
+        });
+        if (!res.ok) return null;
+        const data = (await res.json()) as {
+            is_available: boolean;
+            balance_infos: Array<{ currency: string; total_balance: string; topped_up_balance: string }>;
+        };
+        const total = data.balance_infos.reduce((s, b) => s + Number(b.total_balance), 0);
+        const unit = (data.balance_infos[0]?.currency ?? 'CNY') as UsageReport['limits'][0]['amount']['unit'];
+        return {
+            provider: 'deepseek',
+            fetchedAt: Date.now(),
+            limits: [
+                {
+                    id: 'deepseek:balance',
+                    label: 'DeepSeek 余额',
+                    scope: { provider: 'deepseek' },
+                    amount: { remaining: total, unit } as unknown as UsageReport['limits'][0]['amount'],
+                    status: 'ok',
+                },
+            ],
+        };
+    } catch {
+        return null;
+    }
+}
+
+async function minimaxUsage(signal?: AbortSignal, getApiKey?: BoundApiKeyResolver): Promise<UsageReport | null> {
+    const key = await getApiKey?.();
+    if (!key) return null;
+    try {
+        const res = await fetch('https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains', {
+            headers: { Authorization: `Bearer ${key}` },
+            signal,
+        });
+        if (!res.ok) return null;
+        const data = (await res.json()) as {
+            model_remains: Array<{
+                model_name: string;
+                current_interval_remaining_percent: number;
+                current_interval_status: number;
+                current_weekly_remaining_percent: number;
+                current_weekly_status: number;
+            }>;
+        };
+        const g = data.model_remains?.find((m) => m.model_name === 'general');
+        if (!g) return null;
+        const p5 = Math.round(g.current_interval_remaining_percent) / 100;
+        const pw = Math.round(g.current_weekly_remaining_percent) / 100;
+        return {
+            provider: 'minimax-code-cn',
+            fetchedAt: Date.now(),
+            limits: [
+                {
+                    id: 'minimax-code-cn:5h',
+                    label: 'MiniMax 5h',
+                    scope: { provider: 'minimax-code-cn', windowId: '5h' },
+                    window: { id: '5h', label: '5小时' },
+                    amount: { usedFraction: 1 - p5, remainingFraction: p5, unit: 'percent' },
+                    status: g.current_interval_status !== 1 ? 'exhausted' : 'ok',
+                },
+                {
+                    id: 'minimax-code-cn:1w',
+                    label: 'MiniMax 周',
+                    scope: { provider: 'minimax-code-cn', windowId: '1w' },
+                    window: { id: '1w', label: '每周' },
+                    amount: { usedFraction: 1 - pw, remainingFraction: pw, unit: 'percent' },
+                    status: g.current_weekly_status !== 1 ? 'exhausted' : 'ok',
+                },
+            ],
+        };
+    } catch {
+        return null;
+    }
+}
+
+// ── Zhipu Coding Plan usage ──────────────────────────────────────────
+
+/** Unit codes → window metadata. Unit 5 (1mo) excluded — it reports MCP usage, not Coding Plan quota. */
+const ZHIPU_UNIT_TO_WINDOW: Record<number, { id: string; label: string }> = {
+    3: { id: '5h', label: '5小时' },
+    6: { id: '1w', label: '每周' },
+};
+
+interface ZhipuLimitEntry {
+    type: string;
+    unit: number;
+    number: number;
+    percentage: number;
+    nextResetTime: number;
+    usage?: number;
+    remaining?: number;
+    currentValue?: number;
+}
+
+async function zhipuCodingPlanUsage(signal?: AbortSignal, getApiKey?: BoundApiKeyResolver): Promise<UsageReport | null> {
+    const key = await getApiKey?.();
+    if (!key) return null;
+    try {
+        const res = await fetch('https://open.bigmodel.cn/api/monitor/usage/quota/limit', {
+            headers: { Authorization: `Bearer ${key}` },
+            signal,
+        });
+        if (!res.ok) return null;
+        const data = (await res.json()) as { code: number; data?: { limits?: ZhipuLimitEntry[] } };
+        if (data.code !== 200 || !data.data?.limits?.length) return null;
+
+        const now = Date.now();
+        const limits = data.data.limits
+            .filter((l) => ZHIPU_UNIT_TO_WINDOW[l.unit])
+            .map((l) => {
+                const w = ZHIPU_UNIT_TO_WINDOW[l.unit];
+                const usedFraction = Math.min(l.percentage / 100, 1);
+                return {
+                    id: `zhipu-coding-plan:${w.id}`,
+                    label: `智谱 ${w.label}`,
+                    scope: { provider: 'zhipu-coding-plan' as const, windowId: w.id },
+                    window: { id: w.id, label: w.label, resetsAt: l.nextResetTime },
+                    amount: { usedFraction, remainingFraction: 1 - usedFraction, unit: 'percent' as const },
+                    status: (l.percentage >= 100 ? 'exhausted' : 'ok') as UsageReport['limits'][0]['status'],
+                };
+            });
+        if (limits.length === 0) return null;
+        return { provider: 'zhipu-coding-plan', fetchedAt: now, limits };
+    } catch {
+        return null;
+    }
+}
+
+export const DIRECT_FETCHERS: DirectFetcher[] = [
+    { provider: 'deepseek', fetch: deepSeekBalance },
+    { provider: 'minimax-code-cn', fetch: minimaxUsage },
+    { provider: 'zhipu-coding-plan', fetch: zhipuCodingPlanUsage },
+];

package/lib/edit-variant-pin.ts

@@ -0,0 +1,156 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type { ExtensionAPI } from '@oh-my-pi/pi-coding-agent';
+
+/**
+ * Runtime edit-variant pin fallback for omp >= 18.0.11.
+ *
+ * The host hard-maps deepseek-v4-flash to the sloppy §/» marker grammar (it
+ * misreads hashline ranges), but the model repeatedly breaks sloppy control
+ * lines too — retry loops burn tokens and abort agents. Point it at the
+ * plain old_string/new_string "replace" variant instead.
+ *
+ * Up to 17.x this extension did that via
+ * `settings.override("edit.modelVariants", …)`. omp 18.0.11 dropped
+ * `edit.modelVariants` from the settings schema, so `override()` throws
+ * inside `get()`: the path-segment table has no entry for it and `getByPath`
+ * iterates `undefined`. The host still honors the key when it arrives through
+ * the global config file — `#getEditVariantEntries` reads the merged view
+ * directly and `resolveEditMode` prefers the per-model variant over
+ * `edit.mode` — so persisting once is functionally equivalent to the runtime
+ * pin.
+ *
+ * Idempotent and conservative: any pre-existing `modelVariants` key (user
+ * configured, or a previous run) leaves the file untouched. The write is
+ * atomic (temp file + rename) and never parses or re-serializes the user's
+ * file, so comments and formatting survive.
+ */
+
+export type EditVariantPinOutcome = 'written' | 'already-configured' | 'no-config-file';
+
+const CONFIG_NAMES = ['config.yml', 'config.yaml'];
+
+/** First existing global config file under `agentDir`, or undefined. */
+export function resolveGlobalConfigPath(agentDir: string): string | undefined {
+    for (const name of CONFIG_NAMES) {
+        const candidate = path.join(agentDir, name);
+        if (fs.existsSync(candidate)) return candidate;
+    }
+    return undefined;
+}
+
+/**
+ * Insert `pin` under `edit.modelVariants` in `configPath`.
+ * Throws on I/O errors; otherwise returns the outcome.
+ *
+ * `pin` keys/values must be YAML-safe plain tokens (letters, digits, `.`, `_`,
+ * `-`) — the extension only ever passes `{ 'deepseek-v4-flash': 'replace' }`.
+ */
+export function persistEditVariantPin(
+    configPath: string,
+    pin: Record<string, string>,
+): EditVariantPinOutcome {
+    const entries = Object.entries(pin).filter(([, variant]) => variant);
+    if (entries.length === 0) return 'already-configured';
+
+    let raw: string;
+    try {
+        raw = fs.readFileSync(configPath, 'utf8');
+    } catch (err) {
+        if ((err as NodeJS.ErrnoException).code === 'ENOENT') return 'no-config-file';
+        throw err;
+    }
+
+    // Idempotence guard: a `modelVariants` key anywhere in the file means the
+    // user (or an earlier run) already owns this setting. Leave it alone.
+    if (/^[ \t]*modelVariants\s*:/m.test(raw)) return 'already-configured';
+
+    const block =
+        `  modelVariants:\n` +
+        entries.map(([pattern, variant]) => `    ${pattern}: ${variant}`).join('\n');
+
+    let next: string;
+    const editLine = /^edit:\s*(#.*)?$/m.exec(raw);
+    if (editLine) {
+        // Insert as the first child of the existing top-level `edit:` block.
+        // `editLine[0]` spans to end of line, so the slice keeps the rest of
+        // the block (including its newline) intact.
+        const insertAt = editLine.index + editLine[0].length;
+        next = raw.slice(0, insertAt) + '\n' + block + raw.slice(insertAt);
+    } else {
+        // No edit block: append one, starting on a fresh line.
+        const needsGap = raw.length > 0 && !raw.endsWith('\n');
+        next = (needsGap ? raw + '\n' : raw) + 'edit:\n' + block + '\n';
+    }
+
+    const tmpPath = `${configPath}.tmp-${process.pid}`;
+    try {
+        const mode = fs.statSync(configPath).mode;
+        fs.writeFileSync(tmpPath, next, 'utf8');
+        fs.chmodSync(tmpPath, mode);
+        fs.renameSync(tmpPath, configPath);
+    } catch (err) {
+        try {
+            fs.unlinkSync(tmpPath);
+        } catch {
+            /* tmp may not exist */
+        }
+        throw err;
+    }
+    return 'written';
+}
+
+/**
+ * Pin the edit variant for the target models.
+ *
+ * Preferred path: in-memory `settings.override` (omp < 18.0.11). When that
+ * throws (18.0.11 removed the schema path), persist into the global
+ * config.yml once — idempotent, effective from the next session.
+ */
+export function applyEditVariantPin(pi: ExtensionAPI, pin: Record<string, string>): void {
+    // `pi.pi` is the whole SDK module namespace; its `settings` field has no
+    // declared runtime instance type on the extension-facing surface, so
+    // narrow to the two methods we call (the same shape the host's Settings
+    // class exposes publicly).
+    const settings = pi.pi?.settings as unknown as
+        | { override(path: string, value: unknown): void; getAgentDir?: () => string }
+        | undefined;
+    if (!settings) {
+        console.warn('[omp-opsx-addon] pi.pi.settings unavailable; edit variant pin skipped');
+        return;
+    }
+
+    try {
+        settings.override('edit.modelVariants', pin);
+        return;
+    } catch {
+        /* settings schema no longer knows this path — persist instead */
+    }
+
+    try {
+        let agentDir: string;
+        try {
+            agentDir = settings.getAgentDir?.() ?? '';
+        } catch {
+            agentDir = '';
+        }
+        if (!agentDir) agentDir = path.join(os.homedir(), '.omp', 'agent');
+
+        const configPath = resolveGlobalConfigPath(agentDir);
+        if (!configPath) {
+            console.warn(
+                `[omp-opsx-addon] edit variant pin failed: no global config.yml found under ${agentDir}`,
+            );
+            return;
+        }
+        const outcome = persistEditVariantPin(configPath, pin);
+        if (outcome === 'written') {
+            console.warn(
+                `[omp-opsx-addon] edit variant pin persisted to ${configPath} (effective from the next session)`,
+            );
+        }
+    } catch (err) {
+        console.warn('[omp-opsx-addon] edit variant pin failed:', err);
+    }
+}

package/lib/error-scan.ts

@@ -0,0 +1,97 @@
+/**
+ * Pure, unit-testable error-scan helpers for the 429/403 diagnostic path.
+ *
+ * `hasRateLimitError` / `hasRegionError` detect the two fault classes from an
+ * HTTP response or a tool result's text; `exclusionReasonStats` explains why a
+ * selector candidate set came up empty; `buildErrorDiagnosis` assembles the
+ * user-facing guidance message when a provider faults. The plugin never
+ * auto-switches on a fault — it refreshes the provider usage and suggests
+ * manual steps, so the helper surface is purely read-only.
+ *
+ * Policy decisions (see the fix contract):
+ * - 403 is a *provider-level* regional restriction — the diagnostic suggests
+ *   switching provider, and no model is silently blocked.
+ * - Bare `'region'` is NOT a 403 signal ("regional pricing", `config.region`,
+ *   "in your region" inside a benign message, etc.).
+ */
+import type { ProviderHealth } from './usage-resolver.js';
+
+/** True when the text signals an HTTP 429 / rate-limit condition. */
+export function hasRateLimitError(text: string): boolean {
+    const t = text.toLowerCase();
+    return /\b429\b/.test(t) ||
+        t.includes('rate limit') ||
+        t.includes('too many requests');
+}
+
+/** True when the text signals an HTTP 403 / region-blocked condition. */
+export function hasRegionError(text: string): boolean {
+    const t = text.toLowerCase();
+    return /\b403\b/.test(t) ||
+        t.includes('not available in your region') ||
+        t.includes('access denied') ||
+        t.includes('forbidden');
+}
+
+/**
+ * Reasons why a candidate set ends up empty, for the `/pick-model` error
+ * message. Counts how many candidate models are shadowed by a 403 region
+ * block (with up to `maxBlockedExamples` examples) and how many distinct
+ * providers among the candidates are marked unreachable.
+ */
+export function exclusionReasonStats(
+    models: readonly { provider: string; id: string }[],
+    regionBlockedModels: ReadonlySet<string>,
+    unreachableProviders: ReadonlySet<string>,
+    maxBlockedExamples = 5,
+): { blockedCount: number; blockedExamples: string[]; unreachableProviderCount: number } {
+    let blockedCount = 0;
+    const blockedExamples: string[] = [];
+    const unreachableProv = new Set<string>();
+    for (const m of models) {
+        const selector = `${m.provider}/${m.id}`;
+        if (regionBlockedModels.has(selector)) {
+            blockedCount++;
+            if (blockedExamples.length < maxBlockedExamples) blockedExamples.push(selector);
+        }
+        if (unreachableProviders.has(m.provider)) unreachableProv.add(m.provider);
+    }
+    return { blockedCount, blockedExamples, unreachableProviderCount: unreachableProv.size };
+}
+/**
+ * Assemble the user-facing guidance message emitted after a 429/403 fault.
+ * The plugin no longer auto-switches: it refreshes the provider usage and tells
+ * the user how to proceed manually. Suggestion enumeration is process-local (the
+ * live health map), never persisted. Unknown health degrades to the "state
+ * unknown" wording and a generic fallback suggestion.
+ */
+export function buildErrorDiagnosis(
+    errorType: '429' | '403',
+    source: string,
+    provider: string,
+    health: Map<string, ProviderHealth> | null,
+): string {
+    const lines: string[] = [];
+    lines.push(`⚠️ 检测到 ${errorType} 错误（来源: ${source}）。插件已停止自动切换模型，请手动选择。`);
+    if (health?.get(provider)?.exhausted) {
+        lines.push(`诊断: ${provider} 额度已耗尽，当前不可用`);
+        const candidates = health
+            ? [...health.keys()].filter((p) => p !== provider && !(health.get(p)?.exhausted))
+            : [];
+        const top = candidates.slice(0, 2);
+        lines.push(
+            top.length > 0
+                ? `建议: /pick-model refresh 重选，或 ${top.map((p) => `/pick-model ${p}`).join('、')} 换用其他 provider`
+                : '建议: /pick-model refresh 重选，或换用其他 provider',
+        );
+    } else {
+        lines.push(`诊断: ${provider} 额度正常（或状态未知），错误可能为瞬时/单模型问题`);
+        lines.push(
+            `建议: /pick-model ${provider} 切换同 provider 其他模型（如 /pick-model ${provider}/*），或 /pick-model refresh 重选`,
+        );
+    }
+    if (errorType === '403') {
+        lines.push('该模型可能受区域限制，建议更换 provider');
+    }
+    return lines.join('\n');
+}

package/lib/family-filter.ts

@@ -0,0 +1,174 @@
+/**
+ * Selector-based model filtering for `/pick-model <selector> [--china]`.
+ *
+ * A selector is matched with a three-level grammar (see `matchesSelector`):
+ * a bare word matches by token prefix (the loose "family" intent), a
+ * single-segment glob matches a full string, and a two-segment `provider/id`
+ * glob requires both sides. `--china` always uses the bare-word (token-prefix)
+ * semantics regardless of selector shape.
+ */
+
+/** Lowercase and split on any run of non-alphanumeric characters into tokens. */
+export function normalizeTokens(s: string): string[] {
+    return s
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 0);
+}
+
+/**
+ * True when `word` is a token-prefix of `provider` or `id` (either side
+ * matching is enough). This is the bare-word (level-1) semantics: `glm` hits
+ * the id token of `zhipu-coding-plan/glm-5.3`, and `openai` hits the provider
+ * token of `openai/o4-mini` even though its id has no `gpt` token. A glob
+ * string passed here is tokenized the same way (non-alphanumerics split it,
+ * `*` is dropped), never dispatched through the glob grammar.
+ */
+export function matchesTokenPrefix(provider: string, id: string, word: string): boolean {
+    const wTokens = normalizeTokens(word);
+    const providerTokens = normalizeTokens(provider);
+    const idTokens = normalizeTokens(id);
+    return wTokens.some((w) =>
+        providerTokens.some((t) => t.startsWith(w)) || idTokens.some((t) => t.startsWith(w)),
+    );
+}
+
+/**
+ * Glob → full-string anchored regex. Only `*` is a wildcard (→ `.*`); every
+ * other character (including `?`, `.`, `-`) is a literal. Local reimplementation
+ * of `model-selector.ts` globToRegex with `?` kept literal (no wildcard need in
+ * provider/id selectors) — do not import across modules.
+ */
+function globToFullStringRegex(segment: string): RegExp {
+    const escaped = segment
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\?/g, '\\?')
+        .replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+
+/**
+ * True when `selector` matches `provider/id` under the three-level grammar
+ * (all matching is case-insensitive):
+ *
+ * 1. Bare word (no `*`, no `/`): token-prefix OR of provider/id (legacy family).
+ * 2. Single-segment glob (no `/`, has `*`): full-string anchored glob, provider
+ *    full-string OR id full-string.
+ * 3. Two-segment (contains `/`, split on first): each side is a level-2 glob on
+ *    the provider/id full string, AND; an empty side is equivalent to `*`.
+ */
+export function matchesSelector(provider: string, id: string, selector: string): boolean {
+    const sel = selector.toLowerCase();
+    const hasStar = sel.includes('*');
+    const hasSlash = sel.includes('/');
+
+    if (!hasStar && !hasSlash) {
+        return matchesTokenPrefix(provider, id, sel);
+    }
+    if (!hasSlash) {
+        const re = globToFullStringRegex(sel);
+        return re.test(provider.toLowerCase()) || re.test(id.toLowerCase());
+    }
+    const slash = sel.indexOf('/');
+    const pSeg = sel.slice(0, slash);
+    const iSeg = sel.slice(slash + 1);
+    const pRe = pSeg === '' ? /^.*$/ : globToFullStringRegex(pSeg);
+    const iRe = iSeg === '' ? /^.*$/ : globToFullStringRegex(iSeg);
+    return pRe.test(provider.toLowerCase()) && iRe.test(id.toLowerCase());
+}
+
+/**
+ * Families excluded by `--china`. Provider or id token hit ⇒ drop. `openai` /
+ * `anthropic` are listed separately from `gpt`/`claude` so o-series models
+ * (e.g. `openai/o4-mini`) and non-claude-prefixed anthropic models are dropped
+ * via their provider token, not just the id prefix. `--china` always evaluates
+ * these with the bare-word (token-prefix) semantics, never the glob grammar.
+ */
+export const CHINA_EXCLUDE_FAMILIES = ['gpt', 'claude', 'openai', 'anthropic'];
+
+/**
+ * Enumerate the family words present in a model pool (for the error-path help
+ * list). Includes each provider and the leading id token so every returned name
+ * is a valid family (i.e. it prefix-matches at least one available model).
+ */
+export function listFamilies(models: readonly { provider: string; id: string }[]): string[] {
+    const families = new Set<string>();
+    for (const m of models) {
+        families.add(m.provider.toLowerCase());
+        const idTokens = normalizeTokens(m.id);
+        if (idTokens.length > 0) families.add(idTokens[0]);
+    }
+    return [...families].sort();
+}
+
+/**
+ * Count models per provider (lowercased). Used by the error path to report the
+ * provider dimension — the information a bare selector alone cannot convey —
+ * displayed in descending model count. Only providers still in the pool are
+ * counted; order is undefined (the caller sorts for display).
+ */
+export function listProviders(models: readonly { provider: string; id: string }[]): Map<string, number> {
+    const counts = new Map<string, number>();
+    for (const m of models) {
+        const p = m.provider.toLowerCase();
+        counts.set(p, (counts.get(p) ?? 0) + 1);
+    }
+    return counts;
+}
+
+const RESERVED_SUBCOMMANDS: Record<string, AutoModelParseResult> = {
+    choices: { kind: 'choices' },
+    u: { kind: 'update' },
+    update: { kind: 'update' },
+    r: { kind: 'refresh' },
+    refresh: { kind: 'refresh' },
+    reset: { kind: 'reset' },
+};
+
+export type AutoModelParseResult =
+    | { kind: 'choices' }
+    | { kind: 'update' }
+    | { kind: 'refresh' }
+    | { kind: 'reset' }
+    | { kind: 'selector'; selectors: string[] | null; china: boolean }
+    | { kind: 'error'; message: string };
+
+/**
+ * Parse `/pick-model` arguments.
+ *
+ * - Reserved subcommands (choices/u/update/r/refresh/reset) take priority ONLY when the
+ *   whole input is a single token; mixing them with a selector or flag is a
+ *   usage error rather than a silent ignore of the extra tokens.
+ * - `--china` is position-independent; selectors are OR-combined.
+ * - Selectors are only lowercased (the `*`/`/` structure is preserved, no token
+ *   splitting) and split on whitespace — a selector containing `/` is kept whole.
+ * - Any unknown `-`/`--` flag is a usage error.
+ */
+export function parseAutoModelArgs(args: string): AutoModelParseResult {
+    const tokens = args
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((t) => t.length > 0);
+    if (tokens.length === 0) return { kind: 'choices' };
+
+    if (tokens.length === 1 && Object.hasOwn(RESERVED_SUBCOMMANDS, tokens[0])) {
+        return RESERVED_SUBCOMMANDS[tokens[0]];
+    }
+
+    const selectors: string[] = [];
+    let china = false;
+    for (const tok of tokens) {
+        if (tok === '--china') {
+            china = true;
+        } else if (tok.startsWith('-')) {
+            return { kind: 'error', message: `未知参数: ${tok}` };
+        } else if (Object.hasOwn(RESERVED_SUBCOMMANDS, tok)) {
+            return { kind: 'error', message: `保留字 "${tok}" 不能与 selector/flag 混用` };
+        } else {
+            selectors.push(tok);
+        }
+    }
+
+    return { kind: 'selector', selectors: selectors.length > 0 ? [...new Set(selectors)] : null, china };
+}