@gonrocca/nodd 0.4.0 → 0.4.1

package/extensions/nodd-models.test.ts

@@ -279,3 +279,39 @@ test("nothing in this extension names forge's config file", () => {
   assert.ok(!source.includes(`zero${"."}json`), "NODD never opens forge's config");
   assert.ok(source.includes("nodd.json") || source.includes("noddConfigPath"), "it uses its own");
 });
+
+test("the picker offers the providers you can actually use, not the whole catalogue", () => {
+  // pi's registry carries every provider it knows how to speak to — bedrock,
+  // baseten, huggingface, cloudflare — whether or not you have credentials for
+  // any of them. Browsing all of it meant scrolling past dozens of providers
+  // that cannot answer. `getAvailable()` is pi's own answer to "which of these
+  // has configured auth", so that is what the picker lists.
+  const registry = {
+    getAll: () => [
+      { provider: "cliproxy", id: "ds/deepseek-flash" },
+      { provider: "amazon-bedrock", id: "claude-3" },
+      { provider: "huggingface", id: "meta-llama/x" },
+    ],
+    getAvailable: () => [{ provider: "cliproxy", id: "ds/deepseek-flash" }],
+  };
+
+  const groups = register.groupsFrom(registry);
+  assert.deepEqual([...groups.keys()], ["cliproxy/ds"], "only the configured provider is browsable");
+});
+
+test("with no availability information the full registry is still offered", () => {
+  // An older host, or one that cannot answer, must not leave the picker empty:
+  // showing everything beats showing nothing.
+  const groups = register.groupsFrom({ getAll: () => [{ provider: "anthropic", id: "claude-opus-4-1" }] });
+  assert.deepEqual([...groups.keys()], ["anthropic"]);
+});
+
+test("an empty availability list falls back rather than offering nothing", () => {
+  // Availability is refreshed asynchronously, so early in a session it can be
+  // legitimately empty. Trusting it blindly would show an empty provider list.
+  const groups = register.groupsFrom({
+    getAll: () => [{ provider: "anthropic", id: "claude-opus-4-1" }],
+    getAvailable: () => [],
+  });
+  assert.deepEqual([...groups.keys()], ["anthropic"], "an empty answer is not an answer");
+});

package/extensions/nodd-models.ts

@@ -48,13 +48,31 @@ export function fileConfigIo(path: string = noddConfigPath()): ConfigIo {
   };
 }
 
-type ModelRegistry = { getAll(): RegistryModel[] };
+type ModelRegistry = {
+  getAll(): RegistryModel[];
+  /** pi's own answer to "which providers have configured auth". */
+  getAvailable?(): RegistryModel[];
+};
 
 const USAGE =
   "uso: /nodd-models · /nodd-models <slot>=<provider>/<modelo> · /nodd-models profile [list|new <n>|save [n]|use <n>|delete <n>]";
 
+/**
+ * The models worth browsing.
+ *
+ * pi's registry lists every provider it can speak to — bedrock, baseten,
+ * huggingface — whether or not credentials exist for any of them, which buried
+ * the few usable ones under dozens that cannot answer. `getAvailable()` narrows
+ * that to the configured providers.
+ *
+ * An empty or missing answer falls back to the full registry: availability is
+ * refreshed asynchronously, so early in a session it can be legitimately empty,
+ * and an empty picker is worse than a long one.
+ */
 function groupsFrom(registry: ModelRegistry | undefined): Map<string, string[]> {
   try {
+    const available = registry?.getAvailable?.();
+    if (available && available.length > 0) return groupByProvider(available);
     const all = registry?.getAll?.();
     return all && all.length > 0 ? groupByProvider(all) : new Map();
   } catch {
@@ -362,5 +380,6 @@ function register(pi?: PiApi): void {
 register.runPicker = runPicker;
 register.createComponent = createComponent;
 register.pickerInput = pickerInput;
+register.groupsFrom = groupsFrom;
 
 export default register;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/nodd",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Non-negotiable Organic Driven Development — the ODD protocol as runtime mechanism for pi: blocking gates, observed evidence, and promotion to /forge.",
   "type": "module",
   "keywords": [

package/src/models/picker.test.ts

@@ -572,3 +572,16 @@ test("with no profile at all there is nothing to preview", () => {
   const state = createPickerState({ models: {}, thinking: {}, groups: new Map(), profiles: {}, activeProfile: null });
   assert.deepEqual(previewRows(state), [], "an empty preview is what suppresses the second panel");
 });
+
+test("choosing through a prefixed group does not double the prefix", () => {
+  // The group key is `cliproxy/ds` and the id inside it is `ds/deepseek-v4-pro`:
+  // joining them naively produced `cliproxy/ds/ds/deepseek-v4-pro`, a model id
+  // that resolves to nothing. The key's prefix belongs to the id, not to the
+  // provider, so only the provider part may be prepended.
+  let state = open({ groups: new Map([["cliproxy/ds", ["ds/deepseek-v4-pro"]]]) });
+  state = press(state, "edit-loose");
+  state = assign(state, "implement", "cliproxy/ds", "ds/deepseek-v4-pro", "high");
+
+  assert.equal(state.edits.models.implement, "cliproxy/ds/deepseek-v4-pro");
+  assert.equal(state.edits.thinking.implement, "high");
+});

package/src/models/picker.ts

@@ -528,9 +528,15 @@ function commitDrill(state: PickerState, level: ThinkingLevel): PickerState {
   const { drillSlot, drillProvider, drillModel } = state;
   if (drillSlot === null || drillModel === null) return state;
 
-  // No provider is a bare model id — which is what the empty-registry path
+  // `drillProvider` is a group key, and a pooled provider's key carries the
+  // pool prefix (`cliproxy/ds`) which the id already repeats
+  // (`ds/deepseek-v4-pro`). Only the provider part is prepended, or the commit
+  // doubles the prefix into an id that resolves to nothing.
+  //
+  // No provider at all is a bare model id — what the empty-registry path
   // produces, and what the command's validation accepts.
-  const qualified = drillProvider ? `${drillProvider}/${drillModel}` : drillModel;
+  const provider = drillProvider?.split("/")[0] ?? null;
+  const qualified = provider ? `${provider}/${drillModel}` : drillModel;
   return {
     ...state,
     edits: {