@aliou/pi-ts-aperture 0.3.2 → 0.4.0

package/src/index.ts

@@ -14,54 +14,114 @@ import type {
 import { registerApertureSettings } from "./commands/settings";
 import { registerSetupCommand } from "./commands/setup";
 import { configLoader } from "./config";
-import { applyAperture, refreshActiveModel } from "./providers/aperture";
+import { planConfigChange, resolveProviderBaseUrl } from "./core";
+import {
+  applyAperture,
+  checkGatewayModels,
+  refreshActiveModel,
+} from "./providers/aperture";
 
-function registerApertureLifecycleHook(pi: ExtensionAPI): void {
-  const warnedModels = new Set<string>();
+function notifyMissingModelsOnce(
+  ctx: ExtensionContext,
+  missingModels: string[],
+  warnedModels: Set<string>,
+): void {
+  const newMissing = missingModels.filter((id) => !warnedModels.has(id));
+  if (newMissing.length > 0) {
+    for (const id of newMissing) warnedModels.add(id);
+    ctx.ui.notify(
+      `[aperture] models not available on gateway: ${newMissing.join(", ")}. Add them to the gateway configuration.`,
+      "warning",
+    );
+  }
+}
 
+function registerApertureLifecycleHook(
+  pi: ExtensionAPI,
+  warnedModels: Set<string>,
+): void {
   pi.on("before_agent_start", async (_event, ctx) => {
     if (!ctx?.modelRegistry) return;
 
-    const { providers: overriddenProviders, missingModels } =
-      await applyAperture(pi, ctx.modelRegistry);
+    const { providers: overriddenProviders, gatewayUrl } = await applyAperture(
+      pi,
+      ctx.modelRegistry,
+    );
 
-    const newMissing = missingModels.filter((id) => !warnedModels.has(id));
-    if (newMissing.length > 0) {
-      for (const id of newMissing) warnedModels.add(id);
-      ctx.ui.notify(
-        `[aperture] models not available on gateway: ${newMissing.join(", ")}. Add them to the gateway configuration.`,
-        "warning",
+    if (
+      ctx.model &&
+      overriddenProviders.includes(ctx.model.provider) &&
+      gatewayUrl !== null &&
+      configLoader.getConfig().checkGatewayModels.includes(ctx.model.provider)
+    ) {
+      const { missingModels } = await checkGatewayModels(
+        gatewayUrl,
+        ctx.modelRegistry,
       );
+      notifyMissingModelsOnce(ctx, missingModels, warnedModels);
     }
 
     if (!ctx.model || !overriddenProviders.includes(ctx.model.provider)) return;
 
     await refreshActiveModel(pi, ctx);
   });
+
+  // Also check when user switches to a model whose provider uses aperture
+  pi.on("model_select", async (_event, ctx) => {
+    if (!ctx?.model) return;
+
+    const config = configLoader.getConfig();
+    if (!config.providers.includes(ctx.model.provider)) return;
+
+    const gatewayUrl = resolveProviderBaseUrl(config)?.replace("/v1", "");
+    if (!gatewayUrl) return;
+
+    if (config.checkGatewayModels.includes(ctx.model.provider)) {
+      const { missingModels } = await checkGatewayModels(
+        gatewayUrl,
+        ctx.modelRegistry,
+      );
+      notifyMissingModelsOnce(ctx, missingModels, warnedModels);
+    }
+  });
 }
 
 function createConfigChangeHandler(
   pi: ExtensionAPI,
+  warnedModels: Set<string>,
 ): (ctx: ExtensionContext) => void {
   let lastRegisteredProviders = [...configLoader.getConfig().providers];
 
   return (ctx: ExtensionContext) => {
     const { providers } = configLoader.getConfig();
-    const removedProviders = lastRegisteredProviders.filter(
-      (provider) => !providers.includes(provider),
+
+    const plan = planConfigChange(
+      lastRegisteredProviders,
+      providers,
+      ctx.model?.provider,
     );
 
-    void applyAperture(pi, ctx.modelRegistry).then(({ missingModels }) => {
-      if (missingModels.length > 0) {
-        ctx.ui.notify(
-          `[aperture] models not available on gateway: ${missingModels.join(", ")}. Add them to the gateway configuration.`,
-          "warning",
-        );
-      }
-    });
+    void applyAperture(pi, ctx.modelRegistry).then(
+      async ({ providers, gatewayUrl }) => {
+        if (
+          ctx.model &&
+          providers.includes(ctx.model.provider) &&
+          gatewayUrl !== null &&
+          configLoader
+            .getConfig()
+            .checkGatewayModels.includes(ctx.model.provider)
+        ) {
+          const { missingModels } = await checkGatewayModels(
+            gatewayUrl,
+            ctx.modelRegistry,
+          );
+          notifyMissingModelsOnce(ctx, missingModels, warnedModels);
+        }
+      },
+    );
     lastRegisteredProviders = [...providers];
 
-    if (ctx.model && providers.includes(ctx.model.provider)) {
+    if (plan.shouldRefreshModel) {
       void refreshActiveModel(pi, ctx).then((updated) => {
         if (!updated) return;
         ctx.ui.notify(
@@ -71,7 +131,7 @@ function createConfigChangeHandler(
       });
     }
 
-    for (const provider of removedProviders) {
+    for (const provider of plan.removedProviders) {
       pi.unregisterProvider(provider);
     }
   };
@@ -80,9 +140,11 @@ function createConfigChangeHandler(
 export default async function (pi: ExtensionAPI): Promise<void> {
   await configLoader.load();
 
-  registerApertureLifecycleHook(pi);
+  const warnedModels = new Set<string>();
+
+  registerApertureLifecycleHook(pi, warnedModels);
 
-  const onConfigChange = createConfigChangeHandler(pi);
+  const onConfigChange = createConfigChangeHandler(pi, warnedModels);
   registerSetupCommand(pi, onConfigChange);
   registerApertureSettings(pi, onConfigChange);
 }

package/src/providers/aperture.ts

@@ -1,49 +1,16 @@
 import type {
   ExtensionAPI,
   ExtensionContext,
-  ProviderModelConfig,
 } from "@mariozechner/pi-coding-agent";
 import { configLoader } from "../config";
+import {
+  buildApplyPlan,
+  resolveGatewayUrl,
+  resolveProviderBaseUrl,
+} from "../core";
 import { fetchGatewayModelIds } from "../lib/health";
 
-/**
- * Preserve provenance similarly to pi-synthetic so downstream providers can
- * attribute traffic to Pi / this extension.
- */
-const APERTURE_PROVENANCE_HEADERS = {
-  Referer: "https://pi.dev",
-  "X-Title": "npm:@aliou/pi-ts-aperture",
-};
-
-/** Returns configured gateway URL without trailing slash. */
-export function resolveGatewayUrl(): string | null {
-  const { baseUrl, providers } = configLoader.getConfig();
-  if (!baseUrl || providers.length === 0) return null;
-  return baseUrl.replace(/\/+$/, "");
-}
-
-/**
- * Returns the Aperture provider base URL used for provider registration.
- *
- * Aperture exposes multiple protocol paths (OpenAI, Anthropic, Gemini, ...).
- * For this extension we route through the OpenAI-compatible `/v1` surface that
- * Pi providers use (`openai-completions` API).
- */
-export function resolveApertureProviderBaseUrl(): string | null {
-  const gateway = resolveGatewayUrl();
-  if (!gateway) return null;
-  return `${gateway}/v1`;
-}
-
-function resolveProviderHeaders(
-  models: ProviderModelConfig[],
-): Record<string, string> {
-  const modelHeaders = models.find((m) => m.headers)?.headers ?? {};
-  return {
-    ...APERTURE_PROVENANCE_HEADERS,
-    ...modelHeaders,
-  };
-}
+export { resolveGatewayUrl } from "../core";
 
 /**
  * Apply Aperture override to configured providers.
@@ -57,45 +24,45 @@ function resolveProviderHeaders(
 export async function applyAperture(
   pi: ExtensionAPI,
   registry: ExtensionContext["modelRegistry"],
-): Promise<{ providers: string[]; missingModels: string[] }> {
-  const baseUrl = resolveApertureProviderBaseUrl();
-  if (!baseUrl) return { providers: [], missingModels: [] };
+): Promise<{ providers: string[]; gatewayUrl: string | null }> {
+  const config = configLoader.getConfig();
+  const baseUrl = resolveProviderBaseUrl(config);
+  if (!baseUrl) return { providers: [], gatewayUrl: null };
 
-  const { providers } = configLoader.getConfig();
+  const gatewayUrl = resolveGatewayUrl(config);
 
-  for (const provider of providers) {
-    const existingModels = registry
-      .getAll()
-      .filter((m) => m.provider === provider) as ProviderModelConfig[];
+  const registryModels = registry.getAll();
 
-    if (existingModels.length === 0) continue;
+  const plan = buildApplyPlan(config, registryModels, baseUrl, []);
 
-    pi.registerProvider(provider, {
-      baseUrl,
-      apiKey: "-",
-      headers: resolveProviderHeaders(existingModels),
-      api: existingModels[0].api,
-      models: existingModels,
+  for (const reg of plan.registrations) {
+    pi.registerProvider(reg.provider, {
+      baseUrl: reg.baseUrl,
+      apiKey: reg.apiKey,
+      headers: reg.headers,
+      api: reg.api,
+      models: reg.models,
     });
   }
 
-  const gatewayUrl = resolveGatewayUrl();
-  const gatewayModelIds = gatewayUrl
-    ? await fetchGatewayModelIds(gatewayUrl)
-    : [];
+  return { providers: config.providers, gatewayUrl };
+}
 
-  let missingModels: string[] = [];
-  if (gatewayModelIds.length > 0) {
-    const routedModelIds = registry
-      .getAll()
-      .filter((m) => providers.includes(m.provider))
-      .map((m) => m.id);
-    missingModels = routedModelIds.filter(
-      (id) => !gatewayModelIds.includes(id),
-    );
-  }
+/**
+ * Fetch gateway models and return missing ones relative to the plan.
+ */
+export async function checkGatewayModels(
+  gatewayUrl: string,
+  registry: ExtensionContext["modelRegistry"],
+): Promise<{ missingModels: string[] }> {
+  const config = configLoader.getConfig();
+  const baseUrl = resolveProviderBaseUrl(config);
+  if (!baseUrl) return { missingModels: [] };
 
-  return { providers, missingModels };
+  const gatewayModelIds = await fetchGatewayModelIds(gatewayUrl);
+  const registryModels = registry.getAll();
+  const plan = buildApplyPlan(config, registryModels, baseUrl, gatewayModelIds);
+  return { missingModels: plan.missingModels };
 }
 
 /** Re-resolve and set current model after provider registry updates. */