@aliou/pi-ts-aperture 0.3.1 → 0.4.0

package/src/index.ts

@@ -3,7 +3,6 @@
  *
  * Keeps the entry point focused on orchestration:
  * - load config
- * - bootstrap provider/model visibility
  * - register lifecycle hooks
  * - register user commands
  */
@@ -15,40 +14,114 @@ import type {
 import { registerApertureSettings } from "./commands/settings";
 import { registerSetupCommand } from "./commands/setup";
 import { configLoader } from "./config";
+import { planConfigChange, resolveProviderBaseUrl } from "./core";
 import {
   applyAperture,
-  bootstrapProvidersFromAperture,
+  checkGatewayModels,
   refreshActiveModel,
-  resetApertureModelsCache,
 } from "./providers/aperture";
 
-function registerApertureLifecycleHook(pi: ExtensionAPI): void {
+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 overriddenProviders = await applyAperture(pi, ctx.modelRegistry);
+    const { providers: overriddenProviders, gatewayUrl } = await applyAperture(
+      pi,
+      ctx.modelRegistry,
+    );
+
+    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,
     );
 
-    resetApertureModelsCache();
-    void applyAperture(pi, ctx.modelRegistry);
+    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(
@@ -58,7 +131,7 @@ function createConfigChangeHandler(
       });
     }
 
-    for (const provider of removedProviders) {
+    for (const provider of plan.removedProviders) {
       pi.unregisterProvider(provider);
     }
   };
@@ -66,11 +139,12 @@ function createConfigChangeHandler(
 
 export default async function (pi: ExtensionAPI): Promise<void> {
   await configLoader.load();
-  await bootstrapProvidersFromAperture(pi);
 
-  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/lib/health.ts

@@ -28,3 +28,18 @@ export async function checkApertureHealth(
     return { ok: false, error: msg };
   }
 }
+
+export async function fetchGatewayModelIds(baseUrl: string): Promise<string[]> {
+  const url = `${baseUrl.replace(/\/+$/, "")}/v1/models`;
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) return [];
+    const body = (await res.json()) as { data?: { id: string }[] };
+    return body.data?.map((m) => m.id) ?? [];
+  } catch {
+    return [];
+  }
+}

package/src/providers/aperture.ts

@@ -1,156 +1,68 @@
 import type {
   ExtensionAPI,
   ExtensionContext,
-  ProviderModelConfig,
 } from "@mariozechner/pi-coding-agent";
 import { configLoader } from "../config";
-import { fetchApertureProviderModels } from "../lib/aperture-api";
 import {
-  clearProviderModelsCache,
-  getProviderModelsCache,
-  setProviderModelsCache,
-} from "../state/provider-model-cache";
-import { mergeModels, toModelConfig } from "./model-config";
+  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",
-};
+export { resolveGatewayUrl } from "../core";
 
 /**
- * Providers for which we bootstrap models at startup (before first turn)
- * to make CLI model selection deterministic.
- */
-const BOOTSTRAP_DISCOVERY_PROVIDERS = new Set(["openrouter"]);
-
-/** 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.
+ * Apply Aperture override to configured providers.
  *
- * 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,
-  };
-}
-
-async function getOrLoadProviderModelsCache(
-  gatewayUrl: string,
-  providers: string[],
-): Promise<Map<string, string[]>> {
-  const current = getProviderModelsCache();
-  if (current) return current;
-
-  const loaded = await fetchApertureProviderModels(gatewayUrl, providers);
-  setProviderModelsCache(loaded);
-  return loaded;
-}
-
-export function resetApertureModelsCache(): void {
-  clearProviderModelsCache();
-}
-
-/**
- * Apply Aperture override to configured providers:
- * - provider baseUrl -> aperture /v1 endpoint
- * - apiKey -> dummy token (Aperture injects real key server-side)
- * - headers -> provenance + provider/model headers
+ * Only patches baseUrl, apiKey, and headers. Models are left exactly as
+ * registered by Pi built-ins or other extensions -- Aperture never touches
+ * model definitions.
+ *
+ * Providers with no models in the registry are skipped (nothing to reroute).
  */
 export async function applyAperture(
   pi: ExtensionAPI,
   registry: ExtensionContext["modelRegistry"],
-): Promise<string[]> {
-  const baseUrl = resolveApertureProviderBaseUrl();
-  const gatewayUrl = resolveGatewayUrl();
-  if (!baseUrl || !gatewayUrl) return [];
+): Promise<{ providers: string[]; gatewayUrl: string | null }> {
+  const config = configLoader.getConfig();
+  const baseUrl = resolveProviderBaseUrl(config);
+  if (!baseUrl) return { providers: [], gatewayUrl: null };
 
-  const { providers } = configLoader.getConfig();
-
-  let modelCache: Map<string, string[]>;
-  try {
-    modelCache = await getOrLoadProviderModelsCache(gatewayUrl, providers);
-  } catch {
-    modelCache = new Map();
-  }
+  const gatewayUrl = resolveGatewayUrl(config);
 
-  for (const provider of providers) {
-    const existingModels = registry
-      .getAll()
-      .filter((m) => m.provider === provider) as ProviderModelConfig[];
+  const registryModels = registry.getAll();
 
-    const models = mergeModels(existingModels, modelCache.get(provider));
+  const plan = buildApplyPlan(config, registryModels, baseUrl, []);
 
-    pi.registerProvider(provider, {
-      baseUrl,
-      apiKey: "-",
-      headers: resolveProviderHeaders(models),
-      ...(models.length > 0 && { api: models[0].api, models }),
+  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,
     });
   }
 
-  return providers;
+  return { providers: config.providers, gatewayUrl };
 }
 
 /**
- * Pre-register selected providers from Aperture model discovery so CLI model
- * resolution works even when a model is not present in Pi built-ins.
+ * Fetch gateway models and return missing ones relative to the plan.
  */
-export async function bootstrapProvidersFromAperture(
-  pi: ExtensionAPI,
-): Promise<void> {
-  const baseUrl = resolveApertureProviderBaseUrl();
-  const gatewayUrl = resolveGatewayUrl();
-  if (!baseUrl || !gatewayUrl) return;
-
-  const { providers } = configLoader.getConfig();
-
-  let modelCache: Map<string, string[]>;
-  try {
-    modelCache = await fetchApertureProviderModels(gatewayUrl, providers);
-    setProviderModelsCache(modelCache);
-  } catch {
-    return;
-  }
-
-  for (const provider of providers) {
-    if (!BOOTSTRAP_DISCOVERY_PROVIDERS.has(provider)) continue;
-
-    const modelIds = modelCache.get(provider) ?? [];
-    if (modelIds.length === 0) continue;
-
-    const models = modelIds.map((id) => toModelConfig(id));
-
-    pi.registerProvider(provider, {
-      baseUrl,
-      apiKey: "-",
-      api: "openai-completions",
-      headers: resolveProviderHeaders(models),
-      models,
-    });
-  }
+export async function checkGatewayModels(
+  gatewayUrl: string,
+  registry: ExtensionContext["modelRegistry"],
+): Promise<{ missingModels: string[] }> {
+  const config = configLoader.getConfig();
+  const baseUrl = resolveProviderBaseUrl(config);
+  if (!baseUrl) return { 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. */

package/src/lib/aperture-api.ts

@@ -1,32 +0,0 @@
-export interface ApertureProviderInfo {
-  id?: string;
-  models?: string[];
-}
-
-/**
- * Fetch provider -> model list mapping from Aperture and keep only selected
- * providers configured by the user.
- */
-export async function fetchApertureProviderModels(
-  gatewayUrl: string,
-  providers: string[],
-): Promise<Map<string, string[]>> {
-  const response = await fetch(`${gatewayUrl}/api/providers`, {
-    signal: AbortSignal.timeout(4000),
-  });
-
-  if (!response.ok) {
-    return new Map();
-  }
-
-  const data = (await response.json()) as ApertureProviderInfo[];
-  const selectedProviders = new Set(providers);
-  const modelsByProvider = new Map<string, string[]>();
-
-  for (const provider of data) {
-    if (!provider.id || !selectedProviders.has(provider.id)) continue;
-    modelsByProvider.set(provider.id, provider.models ?? []);
-  }
-
-  return modelsByProvider;
-}

package/src/providers/model-config.ts

@@ -1,54 +0,0 @@
-import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
-
-const DEFAULT_COST = {
-  input: 0,
-  output: 0,
-  cacheRead: 0,
-  cacheWrite: 0,
-};
-
-/**
- * Build a ProviderModelConfig for Aperture-discovered model IDs.
- *
- * When a template model is available (same provider), preserve its API/compat
- * shape so behavior stays consistent after rerouting.
- */
-export function toModelConfig(
-  id: string,
-  template?: ProviderModelConfig,
-): ProviderModelConfig {
-  return {
-    id,
-    name: template?.name ?? id,
-    api: template?.api ?? "openai-completions",
-    reasoning: template?.reasoning ?? false,
-    input: template?.input ?? ["text"],
-    cost: template?.cost ?? DEFAULT_COST,
-    contextWindow: template?.contextWindow ?? 128000,
-    maxTokens: template?.maxTokens ?? 16384,
-    headers: template?.headers,
-    compat: template?.compat,
-  };
-}
-
-/**
- * Merge known provider models with Aperture-discovered model IDs.
- * Existing models win; missing IDs are synthesized from template defaults.
- */
-export function mergeModels(
-  existingModels: ProviderModelConfig[],
-  apertureModelIds: string[] | undefined,
-): ProviderModelConfig[] {
-  if (!apertureModelIds || apertureModelIds.length === 0) return existingModels;
-
-  const modelsById = new Map(existingModels.map((m) => [m.id, m]));
-  const template = existingModels[0];
-
-  for (const modelId of apertureModelIds) {
-    if (!modelsById.has(modelId)) {
-      modelsById.set(modelId, toModelConfig(modelId, template));
-    }
-  }
-
-  return [...modelsById.values()];
-}

package/src/state/provider-model-cache.ts

@@ -1,18 +0,0 @@
-/**
- * In-memory cache for Aperture provider model discovery.
- *
- * Ephemeral by design: reset on config changes and process restart.
- */
-let providerModelsCache: Map<string, string[]> | null = null;
-
-export function getProviderModelsCache(): Map<string, string[]> | null {
-  return providerModelsCache;
-}
-
-export function setProviderModelsCache(models: Map<string, string[]>): void {
-  providerModelsCache = models;
-}
-
-export function clearProviderModelsCache(): void {
-  providerModelsCache = null;
-}