pi-orchestrator-config 4.2.1 → 4.3.2

package/extensions/providers/index.ts

@@ -26,8 +26,10 @@ import type {
   SimpleStreamOptions,
   StreamOptions,
 } from "@earendil-works/pi-ai";
+import { createLogger } from "../shared/logger.js";
 import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { asStringArray, getSetting } from "../orchestrator/project-settings.js";
 import { buildExternalSystemPrompt } from "../shared/build-system-prompt.js";
 import {
@@ -36,10 +38,14 @@ import {
 } from "../orchestrator/utils.js";
 import {
   buildAmbientLoginAuth,
-  buildRuntimeModel,
   createRuntimeProvider,
   filterModelsWhenConfigured,
 } from "../shared/create-runtime-provider.js";
+import {
+  applyThinkingLevelFromModel,
+  loadModelsDevCatalog,
+  type ModelsDevCatalog,
+} from "../shared/models-dev.js";
 import { StreamAssembler, createAssistantMessageOutput } from "../shared/stream-builder.js";
 import { ProviderDriverRegistry } from "../shared/provider-registry.js";
 import type { ProviderInstance, DiscoveredModel } from "../shared/provider-driver.js";
@@ -48,13 +54,18 @@ import { mapCliDiscoveredModels } from "../cli-provider/runtime-models.js";
 import { mapAcpxDiscoveredModels } from "../acpx-provider/runtime-models.js";
 import {
   startCliSessionReaper,
-  stopCliSessionReaper,
 } from "../cli-provider/session-reaper.js";
 import {
   readPiSessionIdFromManager,
 } from "../cli-provider/sessions.js";
 import { fileLog } from "../shared/file-logger.js";
 import { isCliAgentName } from "../cli-provider/providers.js";
+import {
+  isProvidersInitialized,
+  markProvidersInitialized,
+} from "./initialized-guard.js";
+import { restoreDefaultModelOnSessionStart } from "./restore-default-model.js";
+import { teardownProvidersOnSessionShutdown } from "./session-shutdown.js";
 
 const LOG_DOMAIN = "providers";
 const DISCOVERY_TIMEOUT_MS = 30_000;
@@ -70,7 +81,6 @@ const cliInstances = new Map<string, ProviderInstance>();
 const acpxInstances = new Map<string, ProviderInstance>();
 
 let projectCwd = "";
-let initialized = false;
 
 // ---------------------------------------------------------------------------
 // Configured Gates
@@ -185,12 +195,13 @@ async function registerCliAgent(
   pi: ExtensionAPI,
   agent: string,
   instance: ProviderInstance,
+  catalog: ModelsDevCatalog | null,
 ): Promise<void> {
   const providerId = `cli-${agent}`;
   const snapshot = instance.snapshot.getSnapshot();
   const discovered = snapshot.models;
 
-  const models = mapCliDiscoveredModels(agent, discovered);
+  const models = mapCliDiscoveredModels(agent, discovered, catalog);
   const streamFn = makeStreamFunction("cli", agent, () => cliInstances.get(agent));
 
   const provider = await createRuntimeProvider({
@@ -209,7 +220,8 @@ async function registerCliAgent(
       const inst = cliInstances.get(agent);
       if (!inst) return [];
       const snap = await inst.snapshot.refresh();
-      return mapCliDiscoveredModels(agent, snap.models);
+      const fresh = await loadModelsDevCatalog();
+      return mapCliDiscoveredModels(agent, snap.models, fresh);
     },
     filterModels: (catalog, credential) =>
       filterModelsWhenConfigured(catalog, credential, () =>
@@ -226,12 +238,13 @@ async function registerAcpxAgent(
   pi: ExtensionAPI,
   agent: string,
   instance: ProviderInstance,
+  catalog: ModelsDevCatalog | null,
 ): Promise<void> {
   const providerId = `acpx-${agent}`;
   const snapshot = instance.snapshot.getSnapshot();
   const modelIds = snapshot.models.map((m) => m.id);
 
-  const models = mapAcpxDiscoveredModels(agent, modelIds);
+  const models = mapAcpxDiscoveredModels(agent, modelIds, catalog);
   const streamFn = makeStreamFunction("acpx", agent, () => acpxInstances.get(agent));
 
   const provider = await createRuntimeProvider({
@@ -249,7 +262,8 @@ async function registerAcpxAgent(
       const inst = acpxInstances.get(agent);
       if (!inst) return [];
       const snap = await inst.snapshot.refresh();
-      return mapAcpxDiscoveredModels(agent, snap.models.map((m) => m.id));
+      const fresh = await loadModelsDevCatalog();
+      return mapAcpxDiscoveredModels(agent, snap.models.map((m) => m.id), fresh);
     },
     filterModels: (catalog, credential) =>
       filterModelsWhenConfigured(catalog, credential, () =>
@@ -266,15 +280,27 @@ async function registerAcpxAgent(
 // Extension Entry Point
 // ---------------------------------------------------------------------------
 
+const log = createLogger("providers");
+log.debug("providers module loaded");
+
 export default async function (pi: ExtensionAPI) {
   // pi --help / --version — skip discovery
   if (isPiMetaInvocation()) return;
 
   // Idempotency guard — shims re-export this default, so it may be called
   // multiple times (cli-provider shim, acpx-provider shim, providers dir).
-  // Only run once per process.
-  if (initialized) return;
-  initialized = true;
+  // Only run once per session; session_shutdown resets so /new|/resume|/fork
+  // re-registers providers on the next factory invocation.
+  if (isProvidersInitialized()) {
+    log.debug(
+      "providers factory early-return: already initialized (same-session double-load)",
+    );
+    return;
+  }
+  markProvidersInitialized();
+  log.debug(
+    "providers factory: proceeding after reset / first load — re-entering discovery",
+  );
 
   const versionCheck = checkMinPiVersion();
   if (!versionCheck.ok && versionCheck.installed !== null) {
@@ -295,6 +321,14 @@ export default async function (pi: ExtensionAPI) {
   // CLI agents (load in subagent children too)
   // ---------------------------------------------------------------------------
   const cliAgentList = asStringArray(getSetting(projectCwd, "cli_agents")).filter(isCliAgentName);
+  const acpxAgentList = asStringArray(getSetting(projectCwd, "acpx_agents"));
+  const modelsDevCatalog =
+    cliAgentList.length > 0 || acpxAgentList.length > 0
+      ? await loadModelsDevCatalog()
+      : null;
+  if (modelsDevCatalog) {
+    log.info("models.dev catalog loaded for cli/acpx model fill");
+  }
 
   if (cliAgentList.length > 0) {
     startCliSessionReaper({
@@ -339,8 +373,8 @@ export default async function (pi: ExtensionAPI) {
 
     const cliResults = await Promise.allSettled(
       cliAgentList.map(async (agent) => {
-        const driverKind = CLI_AGENT_TO_DRIVER[agent];
-        if (!driverKind) {
+        const driverKind = Object.hasOwn(CLI_AGENT_TO_DRIVER, agent) ? CLI_AGENT_TO_DRIVER[agent] : undefined;
+        if (typeof driverKind !== "string" || driverKind.length === 0) {
           fileLog(LOG_DOMAIN, "warn", LOG_DOMAIN,
             `cli-${agent}: no driver registered`);
           return null;
@@ -397,7 +431,7 @@ export default async function (pi: ExtensionAPI) {
       if (result.status !== "fulfilled" || !result.value) continue;
       const { agent, instance } = result.value;
       try {
-        await registerCliAgent(pi, agent, instance);
+        await registerCliAgent(pi, agent, instance, modelsDevCatalog);
       } catch (err) {
         fileLog(LOG_DOMAIN, "error", LOG_DOMAIN,
           `cli-${agent}: registration failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -412,7 +446,12 @@ export default async function (pi: ExtensionAPI) {
 
     const acpxResults = await Promise.allSettled(
       acpxAgentList.map(async (agent) => {
-        const driverKind = ACPX_AGENT_TO_DRIVER[agent] || "acpx";
+        const driverKind = Object.hasOwn(ACPX_AGENT_TO_DRIVER, agent) ? ACPX_AGENT_TO_DRIVER[agent] : undefined;
+        if (typeof driverKind !== "string" || driverKind.length === 0) {
+          fileLog(LOG_DOMAIN, "warn", LOG_DOMAIN,
+            `acpx-${agent}: no driver mapping in ACPX_AGENT_TO_DRIVER`);
+          return null;
+        }
         // Only proceed if the driver is registered
         if (!registry.getDriver(driverKind)) {
           fileLog(LOG_DOMAIN, "warn", LOG_DOMAIN,
@@ -437,7 +476,11 @@ export default async function (pi: ExtensionAPI) {
               { driver: driverKind, config: { agent }, enabled: true },
               projectCwd,
             );
-            if (timedOut) return { agent, instance };
+            if (timedOut) {
+              fileLog(LOG_DOMAIN, "warn", LOG_DOMAIN,
+                `acpx-${agent}: completed after timeout — cleaning up`);
+              return { agent, instance };
+            }
             acpxInstances.set(agent, instance);
             return { agent, instance };
           } catch (err) {
@@ -471,7 +514,7 @@ export default async function (pi: ExtensionAPI) {
       if (result.status !== "fulfilled" || !result.value) continue;
       const { agent, instance } = result.value;
       try {
-        await registerAcpxAgent(pi, agent, instance);
+        await registerAcpxAgent(pi, agent, instance, modelsDevCatalog);
       } catch (err) {
         fileLog(LOG_DOMAIN, "error", LOG_DOMAIN,
           `acpx-${agent}: registration failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -482,7 +525,8 @@ export default async function (pi: ExtensionAPI) {
   // Run CLI and ACPX discovery concurrently
   await Promise.all([discoverAndRegisterCli(), discoverAndRegisterAcpx()]);
 
-  // Show discovery summary on session start
+  // Show discovery summary on session start; restore saved default model when
+  // findInitialModel raced hasConfiguredAuth false → wrong initial model (#753).
   const providerSummaryParts: string[] = [];
   for (const [agent, inst] of cliInstances) {
     const count = inst.snapshot.getSnapshot().models.length;
@@ -492,22 +536,96 @@ export default async function (pi: ExtensionAPI) {
     const count = inst.snapshot.getSnapshot().models.length;
     providerSummaryParts.push(`acpx-${agent} (${count})`);
   }
-  if (providerSummaryParts.length > 0) {
-    pi.on("session_start", (_event, ctx) => {
-      if (!ctx.hasUI) return;
+
+  // Fire-and-forget restore so session_start is not blocked by retries (#753).
+  // Omit registeredProviders: cli/acpx-only lists falsely fail-fast native defaults.
+  const applyCliAcpxThinking = (model: { id: string; provider: string } | undefined) => {
+    log.debug("applyCliAcpxThinking", model?.provider, model?.id);
+    try {
+      applyThinkingLevelFromModel(
+        model,
+        (level) => pi.setThinkingLevel(level as ThinkingLevel),
+        () => pi.getThinkingLevel(),
+      );
+    } catch (err) {
+      log.warn(
+        "thinking from id failed",
+        err instanceof Error ? err.message : String(err),
+      );
+    }
+  };
+
+  pi.on("session_start", (event, ctx) => {
+    const reason = typeof event?.reason === "string" ? event.reason : "";
+    if (providerSummaryParts.length > 0 && ctx.hasUI) {
       try {
         ctx.ui.notify(`Providers: ${providerSummaryParts.join(", ")}`, "info");
-      } catch { /* stale ctx */ }
+      } catch (err) {
+        log.debug(
+          "providers notify skipped",
+          err instanceof Error ? err.message : String(err),
+        );
+      }
+    }
+    applyCliAcpxThinking(
+      ctx.model
+        ? { id: ctx.model.id, provider: String(ctx.model.provider) }
+        : undefined,
+    );
+    // agentDir via PI_CODING_AGENT_DIR / ~/.pi/agent only (ctx has cwd, not agentDir).
+    // Merge global + cwd/.pi/settings.json (project wins) only when trusted —
+    // same gate as pi SettingsManager (ctx.isProjectTrusted). Fail closed.
+    const cwd = typeof ctx.cwd === "string" ? ctx.cwd : undefined;
+    let projectTrusted = false;
+    try {
+      projectTrusted = typeof ctx.isProjectTrusted === "function"
+        ? ctx.isProjectTrusted() === true
+        : false;
+    } catch (err) {
+      log.debug(
+        "restore-default-model isProjectTrusted failed",
+        err instanceof Error ? err.message : String(err),
+      );
+      projectTrusted = false;
+    }
+    void restoreDefaultModelOnSessionStart({
+      ctx: {
+        model: ctx.model
+          ? { id: ctx.model.id, provider: String(ctx.model.provider) }
+          : undefined,
+        modelRegistry: ctx.modelRegistry,
+      },
+      reason,
+      cwd,
+      projectTrusted,
+      getCurrentModel: () =>
+        ctx.model
+          ? { id: ctx.model.id, provider: String(ctx.model.provider) }
+          : undefined,
+      setModel: (model) => pi.setModel(model as Model<any>),
+    }).catch((err) => {
+      log.warn(
+        "restore-default-model session_start error",
+        err instanceof Error ? err.message : String(err),
+      );
     });
-  }
+  });
+
+  pi.on("model_select", (event) => {
+    applyCliAcpxThinking({
+      id: event.model.id,
+      provider: String(event.model.provider),
+    });
+  });
 
   // ---------------------------------------------------------------------------
   // Shutdown
   // ---------------------------------------------------------------------------
   pi.on("session_shutdown", async () => {
-    stopCliSessionReaper();
-    await registry.teardownAll();
-    cliInstances.clear();
-    acpxInstances.clear();
+    await teardownProvidersOnSessionShutdown(
+      registry,
+      cliInstances,
+      acpxInstances,
+    );
   });
 }

package/extensions/providers/initialized-guard.ts

@@ -0,0 +1,27 @@
+/**
+ * Session-scoped init guard for the unified providers extension.
+ *
+ * Shims (cli-provider / acpx-provider) and providers/ may call the same
+ * default factory multiple times in one process — early-return while set.
+ * session_shutdown must clear this so /new|/resume|/fork re-registers (#752).
+ */
+
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("providers");
+
+let initialized = false;
+
+export function isProvidersInitialized(): boolean {
+  return initialized;
+}
+
+export function markProvidersInitialized(): void {
+  initialized = true;
+  log.debug("initialized-guard", "markProvidersInitialized → true");
+}
+
+export function resetProvidersInitialized(): void {
+  initialized = false;
+  log.debug("initialized-guard", "resetProvidersInitialized → false");
+}