pi-hide-providers 0.1.7 → 0.1.9

package/README.md

@@ -26,9 +26,9 @@ Pi has `enabledModels` in `settings.json` as an allowlist, but maintaining it ma
 `pi-hide-providers` gives you a blocklist that **completely removes** models from all lists — not an allowlist, not a scoped subset:
 
 - Define hide rules in a config file (`~/.pi/agent/hide-providers.json` or `.pi/hide-providers.json`)
-- On session start, the extension monkey-patches `modelRegistry.getAvailable()`, `getAll()`, and `find()` to filter out hidden models
+- On session start, the extension patches pi’s underlying `ModelRuntime` accessors (with a `ModelRegistry` fallback for older pi versions) to filter out hidden models
 - The `/model` selector, `Ctrl+P` cycling, `--list-models`, and session restoration all see only visible models
-- `/hide-models reset` unpatches the registry — all models return immediately
+- `/hide-models reset` removes the runtime/registry patch — all models return immediately
 - Changes via `/hide-models add` and `/hide-models remove` take effect immediately (no reload needed)
 - Interactive `/hide-models` TUI lists visible models first in user-toggle order, then hidden models in their original registry order, and keeps the cursor at the same index after each toggle — matching pi core's `/scoped-models` UX
 - `/hide-models` subcommands for adding, removing, and inspecting rules
@@ -118,33 +118,33 @@ pi -e ./hide-providers.ts
 ```
 Session starts
   → Extension reads hide-providers.json
-  → Monkey-patches modelRegistry:
-      getAvailable() → original result filtered by isHidden()
-      getAll()       → original result filtered by isHidden()
-      find(p, m)    → returns undefined if isHidden(p, m)
+  → Patches ModelRuntime (current pi) or ModelRegistry (older pi):
+      available model reads → original result filtered by isHidden()
+      all model reads       → original result filtered by isHidden()
+      model lookup(p, m)    → returns undefined if isHidden(p, m)
   → All downstream consumers see only visible models:
       /model selector, Ctrl+P, --list-models, session restoration
 
 /hide-models add or /hide-models remove:
   → Config updated on disk
   → currentRules updated in memory
-  → Patched methods read latest rules via closure
+  → Patched runtime/registry methods read latest rules via closure
   → Changes take effect immediately (no reload)
 
 /hide-models reset:
-  → Unpatches registry (restores original methods)
+  → Restores the original model accessors
   → All models return immediately
 ```
 
 The SDK doesn't provide a mechanism to remove models from the registry — `registerProvider({ models: [] })` is treated as "no models to register" (override-only), not "remove all models." Monkey-patching the accessor methods is the only way to completely remove models from all lists without touching `settings.json`.
 
-The patches survive `modelRegistry.refresh()` because they wrap the original methods. On reload, the extension detects the registry is already patched and just updates the rules source.
+The patches survive model catalog refreshes because they wrap the runtime accessors rather than a model snapshot. On reload, the extension detects an existing patch and updates its rules source.
 
 ## Comparison with Alternatives
 
 | Approach | Pros | Cons |
 |----------|------|------|
-| **pi-hide-providers** (this) | Blocklist — completely removes models from all lists; no `settings.json` writes; changes take effect immediately; survives `refresh()` | Monkey-patches `modelRegistry` methods (not an official SDK mechanism) |
+| **pi-hide-providers** (this) | Blocklist — completely removes models from all lists; no `settings.json` writes; changes take effect immediately; survives catalog refresh | Monkey-patches internal model accessors (not an official SDK mechanism) |
 | `enabledModels` in `settings.json` (manual) | Built-in, no extension needed | Allowlist — must list every model you want individually; no blocklist support; clobbers settings with hundreds of entries |
 | `--models` CLI flag | Per-session scoping | Must pass every time; no persistence |
 | `pi.unregisterProvider()` | Restores built-in models after override | Only works for providers registered via `pi.registerProvider()`; can't hide entire providers (empty models array is a no-op) |

package/hide-providers.ts

@@ -11,18 +11,25 @@ import {
   deduplicateRules,
 } from "./src/index.js";
 import { HideProviderSelectorComponent, type HideProviderSelectorResult } from "./src/provider-selector.js";
+import {
+  getUnfilteredModels,
+  isRegistryPatched,
+  patchRegistry,
+  type PatchedRegistry,
+  unpatchRegistry,
+} from "./src/model-filter.js";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 
 /**
  * pi-hide-providers — hide providers and models from pi's model selector.
  *
- * Strategy: monkey-patches modelRegistry accessor methods (getAvailable, getAll, find)
- * to filter out models matched by hide rules.
+ * Strategy: monkey-patches the ModelRuntime accessors used by current pi, with
+ * a ModelRegistry fallback for older releases, to filter models matched by hide rules.
  *
- * This is the only mechanism that completely removes models from ALL lists:
+ * This completely removes models from ALL lists:
  * the /model selector, Ctrl+P cycling, --list-models CLI, and session restoration.
- * It survives modelRegistry.refresh() because our patches wrap the originals.
+ * It survives catalog refreshes because the patches wrap accessors, not snapshots.
  * No settings.json is touched — no 250+ entry explosion, no allowlist semantics.
  */
 
@@ -69,85 +76,6 @@ function writeConfig(cwd: string, config: HideProvidersConfig): string {
   return path;
 }
 
-// Monkey-patching helpers
-
-const PATCH_KEY = "__hide_providers_patched";
-
-interface PatchedRegistry {
-  [PATCH_KEY]: boolean;
-  getAvailable(): unknown[];
-  getAll(): unknown[];
-  find(provider: string, modelId: string): unknown | undefined;
-  __hide_providers_get_rules: () => HideRule[];
-  __hide_providers_orig_getAvailable: () => unknown[];
-  __hide_providers_orig_getAll: () => unknown[];
-  __hide_providers_orig_find: (provider: string, modelId: string) => unknown | undefined;
-}
-
-// Patch a model registry to filter out hidden models.
-// If already patched (e.g. after reload), just updates the rules source.
-function patchRegistry(
-  registry: PatchedRegistry,
-  getRules: () => HideRule[],
-): void {
-  if (registry[PATCH_KEY]) {
-    registry.__hide_providers_get_rules = getRules;
-    return;
-  }
-
-  registry[PATCH_KEY] = true;
-  registry.__hide_providers_get_rules = getRules;
-
-  // Save originals
-  registry.__hide_providers_orig_getAvailable = registry.getAvailable.bind(registry);
-  registry.__hide_providers_orig_getAll = registry.getAll.bind(registry);
-  registry.__hide_providers_orig_find = registry.find.bind(registry);
-
-  // Patch getAvailable — used by model selector, Ctrl+P cycle, resolveModelScope
-  registry.getAvailable = function (this: PatchedRegistry) {
-    const rules = this.__hide_providers_get_rules();
-    const all = this.__hide_providers_orig_getAvailable();
-    return all.filter(
-      (m: any) => !isHidden(rules, m.provider, m.id),
-    );
-  };
-
-  // Patch getAll — used by --list-models and CLI model resolution
-  registry.getAll = function (this: PatchedRegistry) {
-    const rules = this.__hide_providers_get_rules();
-    const all = this.__hide_providers_orig_getAll();
-    return all.filter(
-      (m: any) => !isHidden(rules, m.provider, m.id),
-    );
-  };
-
-  // Patch find — used by session restoration. Hides hidden models from being restored.
-  registry.find = function (
-    this: PatchedRegistry,
-    provider: string,
-    modelId: string,
-  ) {
-    const rules = this.__hide_providers_get_rules();
-    if (isHidden(rules, provider, modelId)) return undefined;
-    return this.__hide_providers_orig_find(provider, modelId);
-  };
-}
-
-// Restore original methods on a patched registry.
-function unpatchRegistry(registry: PatchedRegistry): void {
-  if (!registry[PATCH_KEY]) return;
-
-  registry.getAvailable = registry.__hide_providers_orig_getAvailable;
-  registry.getAll = registry.__hide_providers_orig_getAll;
-  registry.find = registry.__hide_providers_orig_find;
-
-  delete (registry as any)[PATCH_KEY];
-  delete (registry as any).__hide_providers_get_rules;
-  delete (registry as any).__hide_providers_orig_getAvailable;
-  delete (registry as any).__hide_providers_orig_getAll;
-  delete (registry as any).__hide_providers_orig_find;
-}
-
 // Extension
 
 export default function (pi: ExtensionAPI) {
@@ -157,8 +85,11 @@ export default function (pi: ExtensionAPI) {
     const config = readConfig(ctx.cwd);
     currentRules = config.hide;
 
+    const registry = ctx.modelRegistry as unknown as PatchedRegistry;
     if (currentRules.length > 0) {
-      patchRegistry(ctx.modelRegistry as unknown as PatchedRegistry, () => currentRules);
+      patchRegistry(registry, () => currentRules);
+    } else {
+      unpatchRegistry(registry);
     }
   });
 
@@ -232,6 +163,7 @@ async function handleHideCommand(
     const updated = deduplicateRules([...currentRules, rule]);
     const configPath = writeConfig(ctx.cwd, { hide: updated });
     setRules(updated);
+    patchRegistry(ctx.modelRegistry as unknown as PatchedRegistry, () => updated);
     ctx.ui.notify(
       `Added: ${formatRule(rule)} (config: ${configPath}). Changes take effect immediately.`,
       "info",
@@ -269,6 +201,9 @@ async function handleHideCommand(
 
     writeConfig(ctx.cwd, { hide: updated });
     setRules(updated);
+    const registry = ctx.modelRegistry as unknown as PatchedRegistry;
+    if (updated.length > 0) patchRegistry(registry, () => updated);
+    else unpatchRegistry(registry);
     ctx.ui.notify(
       `Removed: ${key}. Changes take effect immediately.`,
       "info",
@@ -299,17 +234,17 @@ async function handleHideCommand(
     return;
   }
 
-  // /hide-models reset — unpatch registry (takes effect immediately)
+  // /hide-models reset — remove model filters (takes effect immediately)
   if (subcommand === "reset") {
     const registry = ctx.modelRegistry as unknown as PatchedRegistry;
-    if (!registry[PATCH_KEY]) {
-      ctx.ui.notify("Registry is not patched. Nothing to reset.", "info");
+    if (!isRegistryPatched(registry)) {
+      ctx.ui.notify("Model accessors are not patched. Nothing to reset.", "info");
       return;
     }
 
     unpatchRegistry(registry);
     ctx.ui.notify(
-      "Reset: registry unpatched — all models restored immediately.",
+      "Reset: model filters removed — all models restored immediately.",
       "info",
     );
     return;
@@ -326,7 +261,7 @@ async function handleHideCommand(
         "  /hide-models add <rule>   Add a hide rule (e.g. ollama, openrouter/cheap-model)",
         "  /hide-models remove <rule> Remove a hide rule",
         "  /hide-models apply        Show current hide state",
-        "  /hide-models reset        Unpatch registry — restore all models",
+        "  /hide-models reset        Remove model filters — restore all models",
         "  /hide-models help         This message",
         "",
         "Rule formats:",
@@ -334,8 +269,8 @@ async function handleHideCommand(
         '  "provider/*"         Hide entire provider (explicit)',
         '  "provider/model-id"  Hide specific model',
         "",
-        "Mechanism: monkey-patches modelRegistry.getAvailable(),",
-        "  getAll(), and find() to filter out hidden models.",
+        "Mechanism: patches ModelRuntime model accessors (or ModelRegistry",
+        "  on older pi versions) to filter out hidden models.",
         "  Takes effect immediately. No settings.json modifications.",
         "  Survives refresh().",
       ].join("\n"),
@@ -358,7 +293,7 @@ async function showHideSelector(
 ): Promise<void> {
   // Get all models from the unpatched registry (so we see everything)
   const registry = ctx.modelRegistry as unknown as PatchedRegistry;
-  const allModels = registry.__hide_providers_orig_getAll?.() ?? ctx.modelRegistry.getAll();
+  const allModels = getUnfilteredModels(registry);
 
   const models = (allModels as any[]).map((m: any) => ({
     provider: m.provider as string,
@@ -366,6 +301,48 @@ async function showHideSelector(
     name: (m.name ?? m.id) as string,
   }));
 
+  if (ctx.mode !== "tui") {
+    if (!ctx.hasUI) {
+      ctx.ui.notify("/hide-models requires a UI (TUI or GUI).", "error");
+      return;
+    }
+    if (models.length === 0) {
+      ctx.ui.notify("No models found.", "warning");
+      return;
+    }
+    const items = models.map((m) => {
+      const hidden = isHidden(currentRules, m.provider, m.id);
+      return `${m.name} (${formatRule({ provider: m.provider, model: m.id })}): ${hidden ? "hidden" : "visible"}`;
+    });
+    const pick = await ctx.ui.select("Hide models \u2014 pick a model to toggle", items);
+    if (pick === undefined) return;
+    const idx = items.indexOf(pick);
+    if (idx < 0) return;
+    const m = models[idx];
+    if (!m) return;
+    const matches = (r: HideRule) => r.provider === m.provider && r.model === m.id;
+    const hasExact = currentRules.some(matches);
+    const newRules = hasExact
+      ? currentRules.filter((r) => !matches(r))
+      : deduplicateRules([...currentRules, { provider: m.provider, model: m.id }]);
+    const configPath = writeConfig(ctx.cwd, { hide: newRules });
+    setRules(newRules);
+    if (newRules.length === 0) {
+      unpatchRegistry(registry);
+      ctx.ui.notify(
+        `Model ${m.name} visible. All models visible — filters removed (config: ${configPath}). Run /hide-models again for more.`,
+        "info",
+      );
+    } else {
+      patchRegistry(registry, () => newRules);
+      ctx.ui.notify(
+        `Model ${m.name} ${hasExact ? "visible" : "hidden"}. ${newRules.length} rule(s) active (config: ${configPath}). Run /hide-models again for more.`,
+        "info",
+      );
+    }
+    return;
+  }
+
   const result = await ctx.ui.custom<HideProviderSelectorResult>(
     (tui, theme, _kb, done) => {
       const selector = new HideProviderSelectorComponent(
@@ -414,32 +391,27 @@ async function showHideSelector(
   }
 }
 
-// Count total models using the original (unpatched) getAll.
+// Count total models using the original unfiltered accessor.
 function countTotalFromUnpatched(ctx: ExtensionCommandContext): number {
   const registry = ctx.modelRegistry as unknown as PatchedRegistry;
-  const all = registry.__hide_providers_orig_getAll?.();
-  if (all) return all.length;
   try {
-    return (ctx.modelRegistry.getAll() as any[]).length;
+    return getUnfilteredModels(registry).length;
   } catch {
     return 0;
   }
 }
 
-// Count hidden models using the original (unpatched) getAll.
+// Count hidden models using the original unfiltered accessor.
 function hiddenFromUnpatched(
   ctx: ExtensionCommandContext,
   rules: ReadonlyArray<HideRule>,
 ): number {
   const registry = ctx.modelRegistry as unknown as PatchedRegistry;
-  const all = registry.__hide_providers_orig_getAll?.();
-  if (all) {
-    return (all as any[]).filter((m: any) => isHidden(rules, m.provider, m.id)).length;
-  }
   try {
-    return (ctx.modelRegistry.getAll() as any[]).filter(
-      (m: any) => isHidden(rules, m.provider, m.id),
-    ).length;
+    return getUnfilteredModels(registry).filter((model) => {
+      const m = model as { provider: string; id: string };
+      return isHidden(rules, m.provider, m.id);
+    }).length;
   } catch {
     return 0;
   }
@@ -461,13 +433,13 @@ function showStatus(
   }
 
   const registry = ctx.modelRegistry as unknown as PatchedRegistry;
-  if (registry[PATCH_KEY]) {
+  if (isRegistryPatched(registry)) {
     lines.push("");
-    lines.push("Status: PATCHED — getAvailable/getAll/find filter hidden models");
+    lines.push("Status: PATCHED — model accessors filter hidden models");
   }
 
   try {
-    const all = registry.__hide_providers_orig_getAll?.() ?? [];
+    const all = getUnfilteredModels(registry);
     if (all.length > 0) {
       const hidden = (all as any[]).filter((m: any) => isHidden(rules, m.provider, m.id));
       lines.push("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hide-providers",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Hide providers and models from pi's model selector — filter the /model list and Ctrl+P cycling via a configurable blocklist",
   "type": "module",
   "author": "Tom X Nguyen",
@@ -31,8 +31,8 @@
     "README.md"
   ],
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.80.6",
-    "@earendil-works/pi-tui": "0.80.6",
+    "@earendil-works/pi-coding-agent": "0.80.10",
+    "@earendil-works/pi-tui": "0.80.10",
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",
     "knip": "6.14.1",

package/src/model-filter.ts

@@ -0,0 +1,178 @@
+import { isHidden, type HideRule } from "./index.js";
+
+interface ModelLike {
+  provider: string;
+  id: string;
+}
+
+interface ModelRuntimeLike {
+  getModels(providerId?: string): readonly unknown[];
+  getAvailableSnapshot(): readonly unknown[];
+  getAvailable?(providerId?: string): Promise<readonly unknown[]>;
+  getModel(provider: string, modelId: string): unknown | undefined;
+  __hide_providers_runtime_patched?: boolean;
+  __hide_providers_get_rules?: () => HideRule[];
+  __hide_providers_orig_getModels?: (providerId?: string) => readonly unknown[];
+  __hide_providers_orig_getAvailableSnapshot?: () => readonly unknown[];
+  __hide_providers_orig_getAvailable?: (providerId?: string) => Promise<readonly unknown[]>;
+  __hide_providers_orig_getModel?: (provider: string, modelId: string) => unknown | undefined;
+}
+
+export interface PatchedRegistry {
+  __hide_providers_patched?: boolean;
+  runtime?: ModelRuntimeLike;
+  getAvailable(): unknown[];
+  getAll(): unknown[];
+  find(provider: string, modelId: string): unknown | undefined;
+  __hide_providers_get_rules?: () => HideRule[];
+  __hide_providers_orig_getAvailable?: () => unknown[];
+  __hide_providers_orig_getAll?: () => unknown[];
+  __hide_providers_orig_find?: (provider: string, modelId: string) => unknown | undefined;
+}
+
+function filterModels(models: readonly unknown[], rules: ReadonlyArray<HideRule>): unknown[] {
+  return models.filter((model) => {
+    const candidate = model as ModelLike;
+    return !isHidden(rules, candidate.provider, candidate.id);
+  });
+}
+
+function getRuntime(registry: PatchedRegistry): ModelRuntimeLike | undefined {
+  const runtime = registry.runtime;
+  return runtime &&
+    typeof runtime.getModels === "function" &&
+    typeof runtime.getAvailableSnapshot === "function" &&
+    typeof runtime.getModel === "function"
+    ? runtime
+    : undefined;
+}
+
+function patchRuntime(runtime: ModelRuntimeLike, getRules: () => HideRule[]): void {
+  if (runtime.__hide_providers_runtime_patched) {
+    runtime.__hide_providers_get_rules = getRules;
+    return;
+  }
+
+  runtime.__hide_providers_runtime_patched = true;
+  runtime.__hide_providers_get_rules = getRules;
+  runtime.__hide_providers_orig_getModels = runtime.getModels.bind(runtime);
+  runtime.__hide_providers_orig_getAvailableSnapshot = runtime.getAvailableSnapshot.bind(runtime);
+  runtime.__hide_providers_orig_getModel = runtime.getModel.bind(runtime);
+  if (runtime.getAvailable) {
+    runtime.__hide_providers_orig_getAvailable = runtime.getAvailable.bind(runtime);
+  }
+
+  runtime.getModels = function (this: ModelRuntimeLike, providerId?: string) {
+    return filterModels(
+      this.__hide_providers_orig_getModels!(providerId),
+      this.__hide_providers_get_rules!(),
+    );
+  };
+  runtime.getAvailableSnapshot = function (this: ModelRuntimeLike) {
+    return filterModels(
+      this.__hide_providers_orig_getAvailableSnapshot!(),
+      this.__hide_providers_get_rules!(),
+    );
+  };
+  if (runtime.__hide_providers_orig_getAvailable) {
+    runtime.getAvailable = async function (this: ModelRuntimeLike, providerId?: string) {
+      return filterModels(
+        await this.__hide_providers_orig_getAvailable!(providerId),
+        this.__hide_providers_get_rules!(),
+      );
+    };
+  }
+  runtime.getModel = function (this: ModelRuntimeLike, provider: string, modelId: string) {
+    if (isHidden(this.__hide_providers_get_rules!(), provider, modelId)) return undefined;
+    return this.__hide_providers_orig_getModel!(provider, modelId);
+  };
+}
+
+function unpatchRuntime(runtime: ModelRuntimeLike): void {
+  if (!runtime.__hide_providers_runtime_patched) return;
+
+  runtime.getModels = runtime.__hide_providers_orig_getModels!;
+  runtime.getAvailableSnapshot = runtime.__hide_providers_orig_getAvailableSnapshot!;
+  runtime.getModel = runtime.__hide_providers_orig_getModel!;
+  if (runtime.__hide_providers_orig_getAvailable) {
+    runtime.getAvailable = runtime.__hide_providers_orig_getAvailable;
+  }
+
+  delete runtime.__hide_providers_runtime_patched;
+  delete runtime.__hide_providers_get_rules;
+  delete runtime.__hide_providers_orig_getModels;
+  delete runtime.__hide_providers_orig_getAvailableSnapshot;
+  delete runtime.__hide_providers_orig_getAvailable;
+  delete runtime.__hide_providers_orig_getModel;
+}
+
+export function patchRegistry(registry: PatchedRegistry, getRules: () => HideRule[]): void {
+  const runtime = getRuntime(registry);
+  if (runtime) patchRuntime(runtime, getRules);
+
+  if (registry.__hide_providers_patched) {
+    registry.__hide_providers_get_rules = getRules;
+    return;
+  }
+
+  // Current pi internals read ModelRuntime directly. Patching its compatibility
+  // ModelRegistry facade too would only double-filter results. Older pi versions
+  // do not expose the runtime, so retain the original registry patch as fallback.
+  if (runtime) return;
+
+  registry.__hide_providers_patched = true;
+  registry.__hide_providers_get_rules = getRules;
+  registry.__hide_providers_orig_getAvailable = registry.getAvailable.bind(registry);
+  registry.__hide_providers_orig_getAll = registry.getAll.bind(registry);
+  registry.__hide_providers_orig_find = registry.find.bind(registry);
+
+  registry.getAvailable = function (this: PatchedRegistry) {
+    return filterModels(
+      this.__hide_providers_orig_getAvailable!(),
+      this.__hide_providers_get_rules!(),
+    );
+  };
+  registry.getAll = function (this: PatchedRegistry) {
+    return filterModels(
+      this.__hide_providers_orig_getAll!(),
+      this.__hide_providers_get_rules!(),
+    );
+  };
+  registry.find = function (this: PatchedRegistry, provider: string, modelId: string) {
+    if (isHidden(this.__hide_providers_get_rules!(), provider, modelId)) return undefined;
+    return this.__hide_providers_orig_find!(provider, modelId);
+  };
+}
+
+export function unpatchRegistry(registry: PatchedRegistry): void {
+  const runtime = getRuntime(registry);
+  if (runtime) unpatchRuntime(runtime);
+
+  if (!registry.__hide_providers_patched) return;
+  registry.getAvailable = registry.__hide_providers_orig_getAvailable!;
+  registry.getAll = registry.__hide_providers_orig_getAll!;
+  registry.find = registry.__hide_providers_orig_find!;
+
+  delete registry.__hide_providers_patched;
+  delete registry.__hide_providers_get_rules;
+  delete registry.__hide_providers_orig_getAvailable;
+  delete registry.__hide_providers_orig_getAll;
+  delete registry.__hide_providers_orig_find;
+}
+
+export function isRegistryPatched(registry: PatchedRegistry): boolean {
+  return Boolean(
+    registry.__hide_providers_patched || getRuntime(registry)?.__hide_providers_runtime_patched,
+  );
+}
+
+export function getUnfilteredModels(registry: PatchedRegistry): unknown[] {
+  const runtime = getRuntime(registry);
+  if (runtime?.__hide_providers_orig_getModels) {
+    return [...runtime.__hide_providers_orig_getModels()];
+  }
+  if (registry.__hide_providers_orig_getAll) {
+    return registry.__hide_providers_orig_getAll();
+  }
+  return registry.getAll();
+}