@aliou/pi-ts-aperture 0.5.0 → 0.5.1

package/package.json

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

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

@@ -6,7 +6,7 @@
 
 import { getApiProvider } from "@mariozechner/pi-ai";
 import { configLoader } from "../lib/config";
-import { fetchGatewayModelIds } from "../lib/gateway";
+import { fetchGatewayModels } from "../lib/gateway";
 import type {
   Api,
   AssistantMessageEventStream,
@@ -27,6 +27,8 @@ const APERTURE_PROVENANCE_HEADERS = {
   "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 {
@@ -87,23 +89,43 @@ export class ApertureRuntime {
     const config = configLoader.getConfig();
     if (config.checkGatewayModels.length === 0) return;
 
-    const gatewayModelIds = await fetchGatewayModelIds(gatewayUrl);
-    if (gatewayModelIds.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) => !gatewayModelIds.includes(m.id),
+      (m) => !gatewayModelKeys.has(`${m.provider}:${m.id}`),
     );
 
     if (missingModels.length > 0) {
-      const ids = missingModels.map((m) => m.id).join(", ");
+      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: ${ids}. Add them to the gateway configuration.`,
+        `[aperture] models not available on gateway: ${summary}. Add them to the gateway configuration.`,
         "warning",
       );
     }

package/src/lib/gateway.ts

@@ -26,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, {
@@ -34,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 [];
   }