pi-cliproxyapi-provider 0.1.0 → 0.2.0

package/src/discovery.ts

@@ -1,22 +1,6 @@
 import { join } from "node:path";
-import { cacheDir, providerCacheKey, type CpaProviderConfig } from "./config.ts";
-import { fetchCpaModels, type CpaModel } from "./cpa.ts";
-import { getCachedOrFetch, isFresh, readCache } from "./cache.ts";
-import { fetchModelsDevCatalog, readBundledModelsDevFallback } from "./models-dev.ts";
-import type { ModelsDevCatalog } from "./types.ts";
-
-export interface DiscoveryResult {
-  cpaModels: CpaModel[];
-  modelsDevCatalog: ModelsDevCatalog;
-  sources: {
-    cpa: "fresh" | "cache" | "stale";
-    modelsDev: "fresh" | "cache" | "stale" | "bundled" | "disabled";
-  };
-  errors: {
-    cpa?: unknown;
-    modelsDev?: unknown;
-  };
-}
+import { cacheDir, providerCacheKey } from "./config.ts";
+import type { CpaProviderConfig } from "./types.ts";
 
 export function cpaModelsCachePath(config: CpaProviderConfig): string {
   return join(cacheDir(), providerCacheKey(config), "cpa-models.json");
@@ -32,67 +16,3 @@ export function discoveryHeaders(config: CpaProviderConfig, apiKey?: string): Re
     ...(config.authHeader && apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
   };
 }
-
-export async function discoverModels(options: {
-  config: CpaProviderConfig;
-  bundledModelsDevPath: string;
-  force?: boolean;
-  discoveryApiKey?: string;
-}): Promise<DiscoveryResult> {
-  const cpa = await getCachedOrFetch({
-    path: cpaModelsCachePath(options.config),
-    ttlSeconds: options.config.cpaCacheTtlSeconds,
-    force: options.force,
-    fetchFresh: () => fetchCpaModels(options.config.baseUrl, discoveryHeaders(options.config, options.discoveryApiKey)),
-  });
-
-  if (!options.config.modelsDevEnabled) {
-    return {
-      cpaModels: cpa.data,
-      modelsDevCatalog: {},
-      sources: { cpa: cpa.source, modelsDev: "disabled" },
-      errors: { cpa: cpa.error },
-    };
-  }
-
-  if (!options.force) {
-    const cachedModelsDev = await readCache<ModelsDevCatalog>(modelsDevCachePath());
-    if (isFresh(cachedModelsDev, options.config.modelsDevCacheTtlSeconds)) {
-      return {
-        cpaModels: cpa.data,
-        modelsDevCatalog: cachedModelsDev.data,
-        sources: { cpa: cpa.source, modelsDev: "cache" },
-        errors: { cpa: cpa.error },
-      };
-    }
-
-    return {
-      cpaModels: cpa.data,
-      modelsDevCatalog: await readBundledModelsDevFallback(options.bundledModelsDevPath),
-      sources: { cpa: cpa.source, modelsDev: "bundled" },
-      errors: { cpa: cpa.error },
-    };
-  }
-
-  try {
-    const modelsDev = await getCachedOrFetch({
-      path: modelsDevCachePath(),
-      ttlSeconds: options.config.modelsDevCacheTtlSeconds,
-      force: true,
-      fetchFresh: fetchModelsDevCatalog,
-    });
-    return {
-      cpaModels: cpa.data,
-      modelsDevCatalog: modelsDev.data,
-      sources: { cpa: cpa.source, modelsDev: modelsDev.source },
-      errors: { cpa: cpa.error, modelsDev: modelsDev.error },
-    };
-  } catch (error) {
-    return {
-      cpaModels: cpa.data,
-      modelsDevCatalog: await readBundledModelsDevFallback(options.bundledModelsDevPath),
-      sources: { cpa: cpa.source, modelsDev: "bundled" },
-      errors: { cpa: cpa.error, modelsDev: error },
-    };
-  }
-}

package/src/models-dev.ts

@@ -32,6 +32,9 @@ export function parseModelsDevCatalog(payload: unknown): ModelsDevCatalog {
     }
   }
 
+  if (Object.keys(catalog).length === 0 && Object.keys(record).length > 0) {
+    throw new Error("models.dev catalog contained no valid models");
+  }
   return catalog;
 }
 

package/src/runtime.ts

@@ -0,0 +1,41 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { ProviderCatalog, type CatalogRefreshResult, type CatalogSnapshot, type RefreshTarget } from "./catalog.ts";
+import { buildUnavailableProviderModels } from "./provider.ts";
+import { buildProviderRegistration } from "./registration.ts";
+import type { CpaProviderConfig } from "./types.ts";
+
+export interface ProviderRuntimeOptions {
+  pi: ExtensionAPI;
+  config: CpaProviderConfig;
+  catalog: ProviderCatalog;
+}
+
+export class ProviderRuntime {
+  private registeredFingerprint?: string;
+  private readonly options: ProviderRuntimeOptions;
+
+  constructor(options: ProviderRuntimeOptions) {
+    this.options = options;
+  }
+
+  async start(): Promise<CatalogSnapshot> {
+    const snapshot = await this.options.catalog.load();
+    this.register(snapshot, true);
+    return snapshot;
+  }
+
+  async refresh(target: RefreshTarget = "all", mode: "background" | "manual" = "manual"): Promise<CatalogRefreshResult> {
+    const result = await this.options.catalog.refresh(target, mode);
+    if (result.models.updated || result.metadata.updated) this.register(result.snapshot, false);
+    return result;
+  }
+
+  private register(snapshot: CatalogSnapshot, force: boolean): void {
+    const models = snapshot.built.models.length > 0 ? snapshot.built.models : buildUnavailableProviderModels();
+    const fingerprint = JSON.stringify(models);
+    if (!force && fingerprint === this.registeredFingerprint) return;
+    const registration = buildProviderRegistration(this.options.config, models);
+    this.options.pi.registerProvider(registration.providerName, registration.config);
+    this.registeredFingerprint = fingerprint;
+  }
+}

package/src/types.ts

@@ -6,8 +6,6 @@ export interface CpaProviderConfig {
   authRequired: boolean;
   authHeader: boolean;
   headers: Record<string, string>;
-  cpaCacheTtlSeconds: number;
-  modelsDevCacheTtlSeconds: number;
   modelsDevEnabled: boolean;
   modelAliases: Record<string, string>;
 }