@aliou/pi-ts-aperture 0.4.0 → 0.5.1

package/README.md

@@ -1,3 +1,5 @@
+![banner](https://assets.aliou.me/pi-extensions/banners/pi-ts-aperture.png)
+
 # pi-ts-aperture
 
 Route Pi LLM providers through [Tailscale Aperture](https://tailscale.com/docs/features/aperture), a managed AI gateway on your tailnet.
@@ -45,4 +47,4 @@ Additionally, the extension can bootstrap model IDs discovered from Aperture (`/
 
 - A Tailscale tailnet with Aperture configured
 - The device running Pi must be on the tailnet (or otherwise able to reach your Aperture endpoint)
-- Use the URL/scheme that matches your deployment (`http://` or `https://`)
+- Use the URL/scheme that matches your deployment (`http://` or `https://`)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aliou/pi-ts-aperture",
   "description": "Route Pi LLM providers through Tailscale Aperture",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "type": "module",
   "license": "MIT",
   "private": false,

package/src/commands/settings.ts

@@ -17,12 +17,12 @@ import type {
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
 import { getSettingsListTheme } from "@mariozechner/pi-coding-agent";
-import type { ApertureConfig, ResolvedConfig } from "../config";
-import { configLoader } from "../config";
+import type { ApertureConfig, ResolvedConfig } from "../lib/config";
+import { configLoader } from "../lib/config";
 
 export function registerApertureSettings(
   pi: ExtensionAPI,
-  onConfigChange: (ctx: ExtensionContext) => void,
+  onSync: (ctx: ExtensionContext) => void,
 ): void {
   registerSettingsCommand<ApertureConfig, ResolvedConfig>(pi, {
     commandName: "aperture:settings",
@@ -129,7 +129,7 @@ export function registerApertureSettings(
       return updated;
     },
     onSave: (ctx) => {
-      onConfigChange(ctx);
+      onSync(ctx);
     },
   });
 }

package/src/commands/setup.ts

@@ -20,9 +20,9 @@ import type {
 } from "@mariozechner/pi-coding-agent";
 import type { Component, TUI } from "@mariozechner/pi-tui";
 import { Input } from "@mariozechner/pi-tui";
-import { configLoader } from "../config";
-import { normalizeInputUrl } from "../core";
-import { checkApertureHealth } from "../lib/health";
+import { configLoader } from "../lib/config";
+import { checkApertureHealth } from "../lib/gateway";
+import { normalizeInputUrl } from "../lib/url";
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
@@ -133,7 +133,7 @@ class UrlStep implements Component {
 
 export function registerSetupCommand(
   pi: ExtensionAPI,
-  onConfigChange: (ctx: ExtensionContext) => void,
+  onSync: (ctx: ExtensionContext) => void,
 ): void {
   pi.registerCommand("aperture:setup", {
     description: "Configure Tailscale Aperture integration",
@@ -222,7 +222,7 @@ export function registerSetupCommand(
         providers,
         checkGatewayModels,
       });
-      onConfigChange(ctx);
+      onSync(ctx);
       ctx.ui.notify(
         `Aperture configured: ${providers.length} provider(s) via ${baseUrl}`,
         "info",

package/src/extension/runtime.test.ts

@@ -0,0 +1,121 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { configLoader } from "../lib/config";
+import { fetchGatewayModels } from "../lib/gateway";
+import type { Api, Model } from "../lib/types";
+import { ApertureRuntime } from "./runtime";
+
+vi.mock("../lib/config", () => ({
+  configLoader: {
+    getConfig: vi.fn(),
+  },
+}));
+
+vi.mock("../lib/gateway", () => ({
+  fetchGatewayModels: vi.fn(),
+}));
+
+const getConfig = vi.mocked(configLoader.getConfig);
+const fetchModels = vi.mocked(fetchGatewayModels);
+
+function model(provider: string, id: string): Model<Api> {
+  return { provider, id } as Model<Api>;
+}
+
+async function check(models: Model<Api>[]) {
+  const notify = vi.fn();
+  const runtime = new ApertureRuntime();
+
+  await runtime.checkMissingModels(
+    {
+      getModels: () => models,
+      notify,
+    },
+    "http://gateway.test",
+  );
+
+  return notify;
+}
+
+describe("ApertureRuntime.checkMissingModels", () => {
+  beforeEach(() => {
+    getConfig.mockReturnValue({
+      baseUrl: "http://gateway.test",
+      providers: [],
+      checkGatewayModels: ["synthetic"],
+    });
+    fetchModels.mockResolvedValue([]);
+  });
+
+  test("matches gateway models by provider and id", async () => {
+    fetchModels.mockResolvedValue([{ providerId: "openrouter", id: "foo" }]);
+
+    const notify = await check([
+      model("synthetic", "foo"),
+      model("openrouter", "foo"),
+    ]);
+
+    expect(notify).toHaveBeenCalledOnce();
+    expect(notify.mock.calls[0][0]).toContain("synthetic: foo");
+  });
+
+  test("only checks configured providers", async () => {
+    getConfig.mockReturnValue({
+      baseUrl: "http://gateway.test",
+      providers: [],
+      checkGatewayModels: ["synthetic"],
+    });
+    fetchModels.mockResolvedValue([{ providerId: "synthetic", id: "foo" }]);
+
+    const notify = await check([
+      model("synthetic", "foo"),
+      model("openrouter", "missing-openrouter"),
+    ]);
+
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  test("truncates missing models per provider", async () => {
+    getConfig.mockReturnValue({
+      baseUrl: "http://gateway.test",
+      providers: [],
+      checkGatewayModels: ["openrouter", "synthetic"],
+    });
+    fetchModels.mockResolvedValue([{ providerId: "synthetic", id: "syn-1" }]);
+
+    const notify = await check([
+      model("openrouter", "or-1"),
+      model("openrouter", "or-2"),
+      model("openrouter", "or-3"),
+      model("openrouter", "or-4"),
+      model("openrouter", "or-5"),
+      model("openrouter", "or-6"),
+      model("openrouter", "or-7"),
+      model("synthetic", "syn-1"),
+      model("synthetic", "syn-2"),
+      model("synthetic", "syn-3"),
+    ]);
+
+    expect(notify).toHaveBeenCalledOnce();
+    const message = notify.mock.calls[0][0];
+    expect(message).toContain(
+      "openrouter: or-1, or-2, or-3, or-4, or-5, 2 more",
+    );
+    expect(message).not.toContain("or-6");
+    expect(message).not.toContain("or-7");
+    expect(message).toContain("synthetic: syn-2, syn-3");
+  });
+
+  test("does not warn when all checked provider models exist", async () => {
+    fetchModels.mockResolvedValue([
+      { providerId: "synthetic", id: "foo" },
+      { providerId: "synthetic", id: "bar" },
+    ]);
+
+    const notify = await check([
+      model("synthetic", "foo"),
+      model("synthetic", "bar"),
+    ]);
+
+    expect(notify).not.toHaveBeenCalled();
+  });
+});

package/src/extension/runtime.ts

@@ -0,0 +1,144 @@
+/**
+ * ApertureRuntime -- core extension runtime logic.
+ *
+ * Handles provider registration, unregistration, and gateway model checking.
+ */
+
+import { getApiProvider } from "@mariozechner/pi-ai";
+import { configLoader } from "../lib/config";
+import { fetchGatewayModels } from "../lib/gateway";
+import type {
+  Api,
+  AssistantMessageEventStream,
+  CheckDeps,
+  Context,
+  Model,
+  SimpleStreamOptions,
+  SyncDeps,
+} from "../lib/types";
+import { resolveProviderBaseUrl } from "../lib/url";
+
+/**
+ * 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",
+};
+
+const MAX_MISSING_MODELS_PER_PROVIDER = 5;
+
+function resolveProviderHeaders(models: Model<Api>[]): Record<string, string> {
+  const modelHeaders = models.find((m) => m.headers)?.headers ?? {};
+  return {
+    ...APERTURE_PROVENANCE_HEADERS,
+    ...modelHeaders,
+  };
+}
+
+export class ApertureRuntime {
+  private registeredProviders = new Set<string>();
+
+  async sync(deps: SyncDeps): Promise<void> {
+    const config = configLoader.getConfig();
+    if (!config.baseUrl || config.providers.length === 0) {
+      return;
+    }
+
+    const baseUrl = resolveProviderBaseUrl(config);
+    if (!baseUrl) return;
+
+    const allModels = deps.getModels();
+
+    for (const providerName of config.providers) {
+      const providerModels = allModels.filter(
+        (m) => m.provider === providerName,
+      );
+      if (providerModels.length === 0) continue;
+
+      const api = providerModels[0].api ?? "openai-completions";
+      const builtIn = getApiProvider(api);
+
+      deps.registerProvider(providerName, {
+        baseUrl,
+        apiKey: "-",
+        headers: resolveProviderHeaders(providerModels),
+        api,
+        streamSimple: builtIn
+          ? (
+              model: Model<Api>,
+              context: Context,
+              options?: SimpleStreamOptions,
+            ): AssistantMessageEventStream =>
+              builtIn.streamSimple(model, context, {
+                ...options,
+                headers: {
+                  ...options?.headers,
+                  "x-session-id": options?.sessionId ?? "",
+                },
+              })
+          : undefined,
+      });
+
+      this.registeredProviders.add(providerName);
+    }
+  }
+
+  async checkMissingModels(deps: CheckDeps, gatewayUrl: string): Promise<void> {
+    const config = configLoader.getConfig();
+    if (config.checkGatewayModels.length === 0) return;
+
+    const gatewayModels = await fetchGatewayModels(gatewayUrl);
+    if (gatewayModels.length === 0) return;
+
+    const allModels = deps.getModels();
+    const checkedProviders = new Set(config.checkGatewayModels);
+    const gatewayModelKeys = new Set(
+      gatewayModels.map((m) => `${m.providerId}:${m.id}`),
+    );
+
+    const routedModels = allModels.filter((m) =>
+      checkedProviders.has(m.provider),
+    );
+    const missingModels = routedModels.filter(
+      (m) => !gatewayModelKeys.has(`${m.provider}:${m.id}`),
+    );
+
+    if (missingModels.length > 0) {
+      const missingByProvider = new Map<string, Model<Api>[]>();
+      for (const model of missingModels) {
+        const providerModels = missingByProvider.get(model.provider) ?? [];
+        providerModels.push(model);
+        missingByProvider.set(model.provider, providerModels);
+      }
+
+      const summary = Array.from(missingByProvider.entries())
+        .map(([provider, models]) => {
+          const shownModels = models
+            .slice(0, MAX_MISSING_MODELS_PER_PROVIDER)
+            .map((m) => m.id);
+          const remainingCount = models.length - shownModels.length;
+          const more = remainingCount > 0 ? `, ${remainingCount} more` : "";
+          return `${provider}: ${shownModels.join(", ")}${more}`;
+        })
+        .join("; ");
+
+      deps.notify(
+        `[aperture] models not available on gateway: ${summary}. Add them to the gateway configuration.`,
+        "warning",
+      );
+    }
+  }
+
+  /**
+   * Returns providers that should be unregistered based on config changes.
+   * Compares previous providers with new ones.
+   */
+  getProvidersToUnregister(
+    prevProviders: string[],
+    nextProviders: string[],
+  ): string[] {
+    return prevProviders.filter((p) => !nextProviders.includes(p));
+  }
+}

package/src/index.ts

@@ -1,10 +1,10 @@
 /**
  * Pi extension for Tailscale Aperture integration.
  *
- * Keeps the entry point focused on orchestration:
- * - load config
- * - register lifecycle hooks
- * - register user commands
+ * Entry point orchestration:
+ * - Load config
+ * - Register session_start hook for provider registration
+ * - Register user commands
  */
 
 import type {
@@ -13,138 +13,85 @@ import type {
 } from "@mariozechner/pi-coding-agent";
 import { registerApertureSettings } from "./commands/settings";
 import { registerSetupCommand } from "./commands/setup";
-import { configLoader } from "./config";
-import { planConfigChange, resolveProviderBaseUrl } from "./core";
-import {
-  applyAperture,
-  checkGatewayModels,
-  refreshActiveModel,
-} from "./providers/aperture";
+import { ApertureRuntime } from "./extension/runtime";
+import { configLoader } from "./lib/config";
+import { resolveGatewayUrl } from "./lib/url";
 
-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, 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);
-  });
+export default async function (pi: ExtensionAPI): Promise<void> {
+  await configLoader.load();
 
-  // Also check when user switches to a model whose provider uses aperture
-  pi.on("model_select", async (_event, ctx) => {
-    if (!ctx?.model) return;
+  const runtime = new ApertureRuntime();
+  let lastRegisteredProviders: string[] = [
+    ...configLoader.getConfig().providers,
+  ];
 
+  // Sync function used by commands after config changes
+  const onSync = (ctx: ExtensionContext): void => {
     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,
+    // Unregister providers that were removed from config
+    const prevProviders = lastRegisteredProviders;
+    const nextProviders = config.providers;
+    const toRemove = runtime.getProvidersToUnregister(
+      prevProviders,
+      nextProviders,
+    );
+    for (const provider of toRemove) {
+      pi.unregisterProvider(provider);
+      ctx.ui.notify(
+        `[aperture] unregistered ${provider}. Run /reload to use the native provider.`,
+        "info",
       );
-      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 plan = planConfigChange(
-      lastRegisteredProviders,
-      providers,
-      ctx.model?.provider,
-    );
 
-    void applyAperture(pi, ctx.modelRegistry).then(
-      async ({ providers, gatewayUrl }) => {
+    // Re-register providers
+    void runtime
+      .sync({
+        registerProvider: pi.registerProvider.bind(pi),
+        getModels: () => ctx.modelRegistry.getAll(),
+      })
+      .then(() => {
+        // Refresh active model if it's from a registered provider
         if (
           ctx.model &&
-          providers.includes(ctx.model.provider) &&
-          gatewayUrl !== null &&
-          configLoader
-            .getConfig()
-            .checkGatewayModels.includes(ctx.model.provider)
+          ctx.modelRegistry.find(ctx.model.provider, ctx.model.id)
         ) {
-          const { missingModels } = await checkGatewayModels(
-            gatewayUrl,
-            ctx.modelRegistry,
+          const updated = ctx.modelRegistry.find(
+            ctx.model.provider,
+            ctx.model.id,
           );
-          notifyMissingModelsOnce(ctx, missingModels, warnedModels);
+          if (updated && config.providers.includes(ctx.model.provider)) {
+            void pi.setModel(updated);
+          }
         }
-      },
-    );
-    lastRegisteredProviders = [...providers];
+      });
 
-    if (plan.shouldRefreshModel) {
-      void refreshActiveModel(pi, ctx).then((updated) => {
-        if (!updated) return;
-        ctx.ui.notify(
-          `[aperture] re-routing ${ctx.model?.id ?? "model"} through ${ctx.model?.baseUrl ?? "aperture"}`,
-          "info",
+    // Check for missing models on gateway if configured
+    if (config.checkGatewayModels.length > 0) {
+      const gatewayUrl = resolveGatewayUrl(config);
+      if (gatewayUrl) {
+        void runtime.checkMissingModels(
+          {
+            getModels: () => ctx.modelRegistry.getAll(),
+            notify: (msg, type) => ctx.ui.notify(msg, type),
+          },
+          gatewayUrl,
         );
-      });
+      }
     }
 
-    for (const provider of plan.removedProviders) {
-      pi.unregisterProvider(provider);
-    }
+    lastRegisteredProviders = [...nextProviders];
   };
-}
-
-export default async function (pi: ExtensionAPI): Promise<void> {
-  await configLoader.load();
 
-  const warnedModels = new Set<string>();
-
-  registerApertureLifecycleHook(pi, warnedModels);
+  // Register providers at session start (for new sessions)
+  pi.on("session_start", (_event, ctx) => {
+    lastRegisteredProviders = [...configLoader.getConfig().providers];
+    void runtime.sync({
+      registerProvider: pi.registerProvider.bind(pi),
+      getModels: () => ctx.modelRegistry.getAll(),
+    });
+  });
 
-  const onConfigChange = createConfigChangeHandler(pi, warnedModels);
-  registerSetupCommand(pi, onConfigChange);
-  registerApertureSettings(pi, onConfigChange);
+  registerSetupCommand(pi, onSync);
+  registerApertureSettings(pi, onSync);
 }

package/src/lib/{health.ts → gateway.ts}

@@ -1,8 +1,5 @@
 /**
- * Health check for the Aperture gateway.
- *
- * Hits GET <baseUrl>/v1/models to verify the gateway is reachable.
- * Uses native fetch (no extra dependencies).
+ * Gateway health and model checking.
  */
 
 export interface HealthCheckResult {
@@ -29,7 +26,14 @@ export async function checkApertureHealth(
   }
 }
 
-export async function fetchGatewayModelIds(baseUrl: string): Promise<string[]> {
+export interface GatewayModel {
+  id: string;
+  providerId: string;
+}
+
+export async function fetchGatewayModels(
+  baseUrl: string,
+): Promise<GatewayModel[]> {
   const url = `${baseUrl.replace(/\/+$/, "")}/v1/models`;
   try {
     const res = await fetch(url, {
@@ -37,8 +41,20 @@ export async function fetchGatewayModelIds(baseUrl: string): Promise<string[]> {
       signal: AbortSignal.timeout(5000),
     });
     if (!res.ok) return [];
-    const body = (await res.json()) as { data?: { id: string }[] };
-    return body.data?.map((m) => m.id) ?? [];
+    const body = (await res.json()) as {
+      data?: {
+        id: string;
+        metadata?: { provider?: { id?: string } };
+      }[];
+    };
+    return (
+      body.data
+        ?.map((m) => ({
+          id: m.id,
+          providerId: m.metadata?.provider?.id ?? "",
+        }))
+        .filter((m) => m.providerId.length > 0) ?? []
+    );
   } catch {
     return [];
   }

package/src/lib/types.ts

@@ -0,0 +1,56 @@
+/**
+ * Internal types for Aperture extension.
+ */
+
+import type {
+  Api,
+  AssistantMessageEventStream,
+  Context,
+  Model,
+  SimpleStreamOptions,
+} from "@mariozechner/pi-ai";
+
+export type {
+  Api,
+  AssistantMessageEventStream,
+  Context,
+  Model,
+  SimpleStreamOptions,
+};
+
+/**
+ * Dependencies for ApertureRuntime.sync()
+ */
+export interface SyncDeps {
+  registerProvider: (
+    name: string,
+    config: {
+      baseUrl: string;
+      apiKey: string;
+      headers: Record<string, string>;
+      api: string;
+      streamSimple?: (
+        model: Model<Api>,
+        context: Context,
+        options?: SimpleStreamOptions,
+      ) => AssistantMessageEventStream;
+    },
+  ) => void;
+  getModels: () => Model<Api>[];
+}
+
+/**
+ * Dependencies for ApertureRuntime.checkMissingModels()
+ */
+export interface CheckDeps {
+  getModels: () => Model<Api>[];
+  notify: (msg: string, type: "warning" | "info") => void;
+}
+
+/**
+ * Headers for provider registration.
+ */
+export interface ProviderHeaders {
+  Referer: string;
+  "X-Title": string;
+}

package/src/{core → lib}/url.ts

@@ -2,7 +2,7 @@
  * Pure URL helpers.
  */
 
-import type { ApertureConfig } from "./types";
+import type { ApertureConfig } from "./config";
 
 /**
  * Normalizes a user-input URL:
@@ -26,7 +26,7 @@ export function normalizeInputUrl(raw: string): string {
  */
 export function resolveGatewayUrl(config: ApertureConfig): string | null {
   const { baseUrl, providers } = config;
-  if (!baseUrl || providers.length === 0) return null;
+  if (!baseUrl || providers?.length === 0) return null;
   return baseUrl.replace(/\/+$/, "");
 }
 

package/src/core/index.ts

@@ -1,7 +0,0 @@
-/**
- * Core module exports -- pure functions and data types.
- */
-
-export * from "./plan";
-export * from "./types";
-export * from "./url";

package/src/core/plan.test.ts

@@ -1,253 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  APERTURE_PROVENANCE_HEADERS,
-  buildApplyPlan,
-  planConfigChange,
-  resolveProviderHeaders,
-} from "./plan";
-import type { ApertureConfig, Api, Model } from "./types";
-
-describe("resolveProviderHeaders", () => {
-  it("includes provenance headers", () => {
-    const models: Model<Api>[] = [{ id: "gpt-4", provider: "openai" }];
-    const headers = resolveProviderHeaders(models);
-    expect(headers).toMatchObject(APERTURE_PROVENANCE_HEADERS);
-  });
-
-  it("merges model headers when present", () => {
-    const models: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai", headers: { "X-Custom": "value" } },
-    ];
-    const headers = resolveProviderHeaders(models);
-    expect(headers).toEqual({
-      ...APERTURE_PROVENANCE_HEADERS,
-      "X-Custom": "value",
-    });
-  });
-
-  it("model headers take precedence over provenance headers", () => {
-    const models: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai", headers: { Referer: "custom" } },
-    ];
-    const headers = resolveProviderHeaders(models);
-    expect(headers.Referer).toBe("custom");
-  });
-
-  it("uses first model with headers", () => {
-    const models: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai" },
-      { id: "gpt-3", provider: "openai", headers: { "X-Auth": "token" } },
-      { id: "gpt-4o", provider: "openai", headers: { "X-Other": "other" } },
-    ];
-    const headers = resolveProviderHeaders(models);
-    expect(headers["X-Auth"]).toBe("token");
-    expect(headers["X-Other"]).toBeUndefined();
-  });
-
-  it("returns only provenance headers when no model has headers", () => {
-    const models: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai" },
-      { id: "gpt-3", provider: "openai" },
-    ];
-    const headers = resolveProviderHeaders(models);
-    expect(headers).toEqual(APERTURE_PROVENANCE_HEADERS);
-  });
-});
-
-describe("buildApplyPlan", () => {
-  const baseConfig: ApertureConfig = {
-    baseUrl: "https://aperture.example.com",
-    providers: ["openai", "anthropic"],
-  };
-
-  const baseUrl = "https://aperture.example.com/v1";
-
-  it("returns empty registrations for empty config", () => {
-    const config: ApertureConfig = { baseUrl: "", providers: [] };
-    const plan = buildApplyPlan(config, [], baseUrl, []);
-    expect(plan.registrations).toEqual([]);
-    expect(plan.missingModels).toEqual([]);
-  });
-
-  it("skips providers with no models in registry", () => {
-    const registryModels: Model<Api>[] = [{ id: "gpt-4", provider: "openai" }];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.registrations).toHaveLength(1);
-    expect(plan.registrations[0].provider).toBe("openai");
-  });
-
-  it("creates registrations for configured providers with models", () => {
-    const registryModels: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai", api: "openai-completions" },
-      { id: "claude-3", provider: "anthropic", api: "anthropic-messages" },
-    ];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.registrations).toHaveLength(2);
-    expect(plan.registrations.map((r) => r.provider)).toContain("openai");
-    expect(plan.registrations.map((r) => r.provider)).toContain("anthropic");
-  });
-
-  it("registration has correct baseUrl", () => {
-    const registryModels: Model<Api>[] = [{ id: "gpt-4", provider: "openai" }];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.registrations[0].baseUrl).toBe(baseUrl);
-  });
-
-  it("registration has apiKey set to dash", () => {
-    const registryModels: Model<Api>[] = [{ id: "gpt-4", provider: "openai" }];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.registrations[0].apiKey).toBe("-");
-  });
-
-  it("registration includes merged headers", () => {
-    const registryModels: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai", headers: { "X-Custom": "value" } },
-    ];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.registrations[0].headers).toEqual({
-      ...APERTURE_PROVENANCE_HEADERS,
-      "X-Custom": "value",
-    });
-  });
-
-  it("registration uses first model's api", () => {
-    const registryModels: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai", api: "openai-completions" },
-      { id: "gpt-3", provider: "openai", api: "openai-chat" },
-    ];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.registrations[0].api).toBe("openai-completions");
-  });
-
-  it("registration defaults api when not specified", () => {
-    const registryModels: Model<Api>[] = [{ id: "gpt-4", provider: "openai" }];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.registrations[0].api).toBe("openai-completions");
-  });
-
-  it("registration includes all models for provider", () => {
-    const registryModels: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai" },
-      { id: "gpt-3", provider: "openai" },
-      { id: "gpt-4o", provider: "openai" },
-    ];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.registrations[0].models).toHaveLength(3);
-  });
-
-  it("computes missing models when gateway IDs provided", () => {
-    const registryModels: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai" },
-      { id: "gpt-3", provider: "openai" },
-    ];
-    const gatewayIds = ["gpt-4"];
-    const plan = buildApplyPlan(
-      baseConfig,
-      registryModels,
-      baseUrl,
-      gatewayIds,
-    );
-    expect(plan.missingModels).toEqual(["gpt-3"]);
-  });
-
-  it("missingModels is empty when gateway IDs empty", () => {
-    const registryModels: Model<Api>[] = [{ id: "gpt-4", provider: "openai" }];
-    const plan = buildApplyPlan(baseConfig, registryModels, baseUrl, []);
-    expect(plan.missingModels).toEqual([]);
-  });
-
-  it("missingModels is empty when all models present on gateway", () => {
-    const registryModels: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai" },
-      { id: "gpt-3", provider: "openai" },
-    ];
-    const gatewayIds = ["gpt-4", "gpt-3"];
-    const plan = buildApplyPlan(
-      baseConfig,
-      registryModels,
-      baseUrl,
-      gatewayIds,
-    );
-    expect(plan.missingModels).toEqual([]);
-  });
-
-  it("only checks missing models for configured providers", () => {
-    const config: ApertureConfig = {
-      baseUrl: "https://aperture.example.com",
-      providers: ["openai"],
-    };
-    const registryModels: Model<Api>[] = [
-      { id: "gpt-4", provider: "openai" },
-      { id: "claude-3", provider: "anthropic" },
-    ];
-    const gatewayIds: string[] = [];
-    const plan = buildApplyPlan(config, registryModels, baseUrl, gatewayIds);
-    // Only openai models are considered, but since gatewayIds is empty, missingModels is empty
-    expect(plan.missingModels).toEqual([]);
-  });
-});
-
-describe("planConfigChange", () => {
-  it("detects removed providers", () => {
-    const prev = ["openai", "anthropic"];
-    const next = ["openai"];
-    const plan = planConfigChange(prev, next);
-    expect(plan.removedProviders).toEqual(["anthropic"]);
-  });
-
-  it("returns empty removedProviders when no providers removed", () => {
-    const prev = ["openai", "anthropic"];
-    const next = ["openai", "anthropic", "google"];
-    const plan = planConfigChange(prev, next);
-    expect(plan.removedProviders).toEqual([]);
-  });
-
-  it("returns empty removedProviders when providers unchanged", () => {
-    const prev = ["openai", "anthropic"];
-    const next = ["openai", "anthropic"];
-    const plan = planConfigChange(prev, next);
-    expect(plan.removedProviders).toEqual([]);
-  });
-
-  it("detects all providers removed", () => {
-    const prev = ["openai", "anthropic"];
-    const next: string[] = [];
-    const plan = planConfigChange(prev, next);
-    expect(plan.removedProviders).toEqual(["openai", "anthropic"]);
-  });
-
-  it("shouldRefreshModel is true when active model provider is in next providers", () => {
-    const prev = ["openai"];
-    const next = ["openai", "anthropic"];
-    const plan = planConfigChange(prev, next, "openai");
-    expect(plan.shouldRefreshModel).toBe(true);
-  });
-
-  it("shouldRefreshModel is false when active model provider was removed", () => {
-    const prev = ["openai", "anthropic"];
-    const next = ["openai"];
-    const plan = planConfigChange(prev, next, "anthropic");
-    expect(plan.shouldRefreshModel).toBe(false);
-  });
-
-  it("shouldRefreshModel is false when no active model", () => {
-    const prev = ["openai"];
-    const next = ["openai", "anthropic"];
-    const plan = planConfigChange(prev, next);
-    expect(plan.shouldRefreshModel).toBe(false);
-  });
-
-  it("shouldRefreshModel is true when adding provider that matches active model", () => {
-    const prev: string[] = [];
-    const next = ["openai"];
-    const plan = planConfigChange(prev, next, "openai");
-    expect(plan.shouldRefreshModel).toBe(true);
-  });
-
-  it("shouldRefreshModel is false when active model provider not in next", () => {
-    const prev = ["openai"];
-    const next = ["anthropic"];
-    const plan = planConfigChange(prev, next, "openai");
-    expect(plan.shouldRefreshModel).toBe(false);
-  });
-});

package/src/core/plan.ts

@@ -1,107 +0,0 @@
-/**
- * Core decision logic -- all pure functions.
- */
-
-import type {
-  ApertureConfig,
-  Api,
-  ApplyPlan,
-  ConfigChangePlan,
-  Model,
-  ProviderRegistration,
-} from "./types";
-
-/**
- * Preserve provenance similarly to pi-synthetic so downstream providers can
- * attribute traffic to Pi / this extension.
- */
-export const APERTURE_PROVENANCE_HEADERS = {
-  Referer: "https://pi.dev",
-  "X-Title": "npm:@aliou/pi-ts-aperture",
-};
-
-/**
- * Resolves headers for a provider registration.
- * Merges provenance headers with the first model's headers (if any).
- */
-export function resolveProviderHeaders(
-  models: Model<Api>[],
-): Record<string, string> {
-  const modelHeaders = models.find((m) => m.headers)?.headers ?? {};
-  return {
-    ...APERTURE_PROVENANCE_HEADERS,
-    ...modelHeaders,
-  };
-}
-
-/**
- * Builds a plan for applying Aperture configuration.
- *
- * Groups registry models by configured provider, builds registrations,
- * and computes missing models (if gateway model IDs are provided).
- *
- * Providers with no models in the registry are skipped (nothing to reroute).
- */
-export function buildApplyPlan(
-  config: ApertureConfig,
-  registryModels: Model<Api>[],
-  providerBaseUrl: string,
-  gatewayModelIds: string[],
-): ApplyPlan {
-  const { providers } = config;
-
-  const registrations: ProviderRegistration[] = [];
-
-  for (const provider of providers) {
-    const existingModels = registryModels.filter(
-      (m) => m.provider === provider,
-    );
-
-    if (existingModels.length === 0) continue;
-
-    registrations.push({
-      provider,
-      baseUrl: providerBaseUrl,
-      apiKey: "-",
-      headers: resolveProviderHeaders(existingModels),
-      api: existingModels[0].api ?? "openai-completions",
-      models: existingModels,
-    });
-  }
-
-  let missingModels: string[] = [];
-  if (gatewayModelIds.length > 0) {
-    const routedModelIds = registryModels
-      .filter((m) => providers.includes(m.provider))
-      .map((m) => m.id);
-    missingModels = routedModelIds.filter(
-      (id) => !gatewayModelIds.includes(id),
-    );
-  }
-
-  return { registrations, missingModels };
-}
-
-/**
- * Plans the effects of a configuration change.
- *
- * @param prevProviders - Providers that were previously configured
- * @param nextProviders - Providers that are now configured
- * @param activeModelProvider - Provider of the currently active model (if any)
- * @returns ConfigChangePlan with removed providers and refresh decision
- */
-export function planConfigChange(
-  prevProviders: string[],
-  nextProviders: string[],
-  activeModelProvider?: string,
-): ConfigChangePlan {
-  const removedProviders = prevProviders.filter(
-    (provider) => !nextProviders.includes(provider),
-  );
-
-  const shouldRefreshModel =
-    activeModelProvider !== undefined &&
-    nextProviders.includes(activeModelProvider);
-
-  return { removedProviders, shouldRefreshModel };
-}

package/src/core/types.ts

@@ -1,33 +0,0 @@
-/**
- * Plain data types used by core functions.
- * Model is re-exported from @mariozechner/pi-ai for internal use.
- */
-import type { Api, Model } from "@mariozechner/pi-ai";
-
-export interface ApertureConfig {
-  baseUrl: string;
-  providers: string[];
-  checkGatewayModels: string[];
-}
-
-export interface ProviderRegistration {
-  provider: string;
-  baseUrl: string;
-  apiKey: string;
-  headers: Record<string, string>;
-  api: string;
-  models: Model<Api>[];
-}
-
-// Re-export Model for use in other core files
-export type { Model, Api };
-
-export interface ApplyPlan {
-  registrations: ProviderRegistration[];
-  missingModels: string[];
-}
-
-export interface ConfigChangePlan {
-  removedProviders: string[];
-  shouldRefreshModel: boolean;
-}

package/src/core/url.test.ts

@@ -1,130 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { ApertureConfig } from "./types";
-import {
-  normalizeInputUrl,
-  resolveGatewayUrl,
-  resolveProviderBaseUrl,
-} from "./url";
-
-describe("normalizeInputUrl", () => {
-  it("returns empty string for empty input", () => {
-    expect(normalizeInputUrl("")).toBe("");
-  });
-
-  it("trims whitespace", () => {
-    expect(normalizeInputUrl("  https://example.com  ")).toBe(
-      "https://example.com",
-    );
-  });
-
-  it("adds http:// scheme when missing", () => {
-    expect(normalizeInputUrl("example.com")).toBe("http://example.com");
-  });
-
-  it("preserves https:// scheme", () => {
-    expect(normalizeInputUrl("https://example.com")).toBe(
-      "https://example.com",
-    );
-  });
-
-  it("preserves http:// scheme", () => {
-    expect(normalizeInputUrl("http://example.com")).toBe("http://example.com");
-  });
-
-  it("strips trailing /v1", () => {
-    expect(normalizeInputUrl("https://example.com/v1")).toBe(
-      "https://example.com",
-    );
-  });
-
-  it("strips trailing /v1/", () => {
-    expect(normalizeInputUrl("https://example.com/v1/")).toBe(
-      "https://example.com",
-    );
-  });
-
-  it("strips trailing slashes", () => {
-    expect(normalizeInputUrl("https://example.com/")).toBe(
-      "https://example.com",
-    );
-  });
-
-  it("strips multiple trailing slashes", () => {
-    expect(normalizeInputUrl("https://example.com///")).toBe(
-      "https://example.com",
-    );
-  });
-
-  it("handles already-normalized URL", () => {
-    expect(normalizeInputUrl("https://example.com")).toBe(
-      "https://example.com",
-    );
-  });
-});
-
-describe("resolveGatewayUrl", () => {
-  it("returns null when baseUrl is empty", () => {
-    const config: ApertureConfig = { baseUrl: "", providers: ["openai"] };
-    expect(resolveGatewayUrl(config)).toBeNull();
-  });
-
-  it("returns null when providers is empty", () => {
-    const config: ApertureConfig = {
-      baseUrl: "https://example.com",
-      providers: [],
-    };
-    expect(resolveGatewayUrl(config)).toBeNull();
-  });
-
-  it("returns null when both baseUrl and providers are empty", () => {
-    const config: ApertureConfig = { baseUrl: "", providers: [] };
-    expect(resolveGatewayUrl(config)).toBeNull();
-  });
-
-  it("returns URL without trailing slash", () => {
-    const config: ApertureConfig = {
-      baseUrl: "https://example.com/",
-      providers: ["openai"],
-    };
-    expect(resolveGatewayUrl(config)).toBe("https://example.com");
-  });
-
-  it("returns URL as-is when no trailing slash", () => {
-    const config: ApertureConfig = {
-      baseUrl: "https://example.com",
-      providers: ["openai"],
-    };
-    expect(resolveGatewayUrl(config)).toBe("https://example.com");
-  });
-
-  it("strips multiple trailing slashes", () => {
-    const config: ApertureConfig = {
-      baseUrl: "https://example.com///",
-      providers: ["openai"],
-    };
-    expect(resolveGatewayUrl(config)).toBe("https://example.com");
-  });
-});
-
-describe("resolveProviderBaseUrl", () => {
-  it("returns null when gateway URL cannot be resolved", () => {
-    const config: ApertureConfig = { baseUrl: "", providers: ["openai"] };
-    expect(resolveProviderBaseUrl(config)).toBeNull();
-  });
-
-  it("appends /v1 to gateway URL", () => {
-    const config: ApertureConfig = {
-      baseUrl: "https://example.com",
-      providers: ["openai"],
-    };
-    expect(resolveProviderBaseUrl(config)).toBe("https://example.com/v1");
-  });
-
-  it("handles trailing slashes correctly", () => {
-    const config: ApertureConfig = {
-      baseUrl: "https://example.com/",
-      providers: ["openai"],
-    };
-    expect(resolveProviderBaseUrl(config)).toBe("https://example.com/v1");
-  });
-});

package/src/providers/aperture.ts

@@ -1,79 +0,0 @@
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { configLoader } from "../config";
-import {
-  buildApplyPlan,
-  resolveGatewayUrl,
-  resolveProviderBaseUrl,
-} from "../core";
-import { fetchGatewayModelIds } from "../lib/health";
-
-export { resolveGatewayUrl } from "../core";
-
-/**
- * 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<{ providers: string[]; gatewayUrl: string | null }> {
-  const config = configLoader.getConfig();
-  const baseUrl = resolveProviderBaseUrl(config);
-  if (!baseUrl) return { providers: [], gatewayUrl: null };
-
-  const gatewayUrl = resolveGatewayUrl(config);
-
-  const registryModels = registry.getAll();
-
-  const plan = buildApplyPlan(config, registryModels, baseUrl, []);
-
-  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: config.providers, gatewayUrl };
-}
-
-/**
- * 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: [] };
-
-  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. */
-export async function refreshActiveModel(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-): Promise<boolean> {
-  if (!ctx.model) return false;
-
-  const updated = ctx.modelRegistry.find(ctx.model.provider, ctx.model.id);
-  if (!updated) return false;
-
-  return pi.setModel(updated);
-}