@aliou/pi-ts-aperture 0.3.1 → 0.3.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aliou/pi-ts-aperture",
   "description": "Route Pi LLM providers through Tailscale Aperture",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "license": "MIT",
   "private": false,
@@ -32,9 +32,9 @@
     "@aliou/pi-utils-settings": "^0.10.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": ">=0.55.3",
-    "@mariozechner/pi-coding-agent": ">=0.55.3",
-    "@mariozechner/pi-tui": ">=0.55.3"
+    "@mariozechner/pi-ai": "0.61.0",
+    "@mariozechner/pi-coding-agent": "0.61.0",
+    "@mariozechner/pi-tui": "0.61.0"
   },
   "peerDependenciesMeta": {
     "@mariozechner/pi-coding-agent": {
@@ -51,7 +51,7 @@
     "@aliou/biome-plugins": "^0.3.2",
     "@biomejs/biome": "^2.3.13",
     "@changesets/cli": "^2.27.11",
-    "@mariozechner/pi-coding-agent": "0.55.3",
+    "@mariozechner/pi-coding-agent": "0.61.0",
     "@sinclair/typebox": "^0.34.48",
     "@types/node": "^25.0.10",
     "@vitest/coverage-v8": "^4.0.18",

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,18 +14,26 @@ import type {
 import { registerApertureSettings } from "./commands/settings";
 import { registerSetupCommand } from "./commands/setup";
 import { configLoader } from "./config";
-import {
-  applyAperture,
-  bootstrapProvidersFromAperture,
-  refreshActiveModel,
-  resetApertureModelsCache,
-} from "./providers/aperture";
+import { applyAperture, refreshActiveModel } from "./providers/aperture";
 
 function registerApertureLifecycleHook(pi: ExtensionAPI): void {
+  const warnedModels = new Set<string>();
+
   pi.on("before_agent_start", async (_event, ctx) => {
     if (!ctx?.modelRegistry) return;
 
-    const overriddenProviders = await applyAperture(pi, ctx.modelRegistry);
+    const { providers: overriddenProviders, missingModels } =
+      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)) return;
 
     await refreshActiveModel(pi, ctx);
@@ -44,8 +51,14 @@ function createConfigChangeHandler(
       (provider) => !providers.includes(provider),
     );
 
-    resetApertureModelsCache();
-    void applyAperture(pi, ctx.modelRegistry);
+    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",
+        );
+      }
+    });
     lastRegisteredProviders = [...providers];
 
     if (ctx.model && providers.includes(ctx.model.provider)) {
@@ -66,7 +79,6 @@ function createConfigChangeHandler(
 
 export default async function (pi: ExtensionAPI): Promise<void> {
   await configLoader.load();
-  await bootstrapProvidersFromAperture(pi);
 
   registerApertureLifecycleHook(pi);
 

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

@@ -4,13 +4,7 @@ import type {
   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";
+import { fetchGatewayModelIds } from "../lib/health";
 
 /**
  * Preserve provenance similarly to pi-synthetic so downstream providers can
@@ -21,12 +15,6 @@ const APERTURE_PROVENANCE_HEADERS = {
   "X-Title": "npm:@aliou/pi-ts-aperture",
 };
 
-/**
- * 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();
@@ -57,100 +45,57 @@ function resolveProviderHeaders(
   };
 }
 
-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
+ * Apply Aperture override to configured providers.
+ *
+ * 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[]> {
+): Promise<{ providers: string[]; missingModels: string[] }> {
   const baseUrl = resolveApertureProviderBaseUrl();
-  const gatewayUrl = resolveGatewayUrl();
-  if (!baseUrl || !gatewayUrl) return [];
+  if (!baseUrl) return { providers: [], missingModels: [] };
 
   const { providers } = configLoader.getConfig();
 
-  let modelCache: Map<string, string[]>;
-  try {
-    modelCache = await getOrLoadProviderModelsCache(gatewayUrl, providers);
-  } catch {
-    modelCache = new Map();
-  }
-
   for (const provider of providers) {
     const existingModels = registry
       .getAll()
       .filter((m) => m.provider === provider) as ProviderModelConfig[];
 
-    const models = mergeModels(existingModels, modelCache.get(provider));
+    if (existingModels.length === 0) continue;
 
     pi.registerProvider(provider, {
       baseUrl,
       apiKey: "-",
-      headers: resolveProviderHeaders(models),
-      ...(models.length > 0 && { api: models[0].api, models }),
+      headers: resolveProviderHeaders(existingModels),
+      api: existingModels[0].api,
+      models: existingModels,
     });
   }
 
-  return providers;
-}
-
-/**
- * Pre-register selected providers from Aperture model discovery so CLI model
- * resolution works even when a model is not present in Pi built-ins.
- */
-export async function bootstrapProvidersFromAperture(
-  pi: ExtensionAPI,
-): Promise<void> {
-  const baseUrl = resolveApertureProviderBaseUrl();
   const gatewayUrl = resolveGatewayUrl();
-  if (!baseUrl || !gatewayUrl) return;
-
-  const { providers } = configLoader.getConfig();
+  const gatewayModelIds = gatewayUrl
+    ? await fetchGatewayModelIds(gatewayUrl)
+    : [];
 
-  let modelCache: Map<string, string[]>;
-  try {
-    modelCache = await fetchApertureProviderModels(gatewayUrl, providers);
-    setProviderModelsCache(modelCache);
-  } catch {
-    return;
+  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),
+    );
   }
 
-  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,
-    });
-  }
+  return { providers, 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;
-}