pi-cliproxyapi-provider 0.1.0 → 0.3.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/model-capabilities.ts

@@ -0,0 +1,54 @@
+import type { ThinkingLevelMap } from "@earendil-works/pi-ai";
+
+export interface ModelCapabilityContext {
+  availableModelId: string;
+  metadataModelId?: string;
+}
+
+export interface ModelCapabilityOverrides {
+  reasoning?: boolean;
+  thinkingLevelMap?: ThinkingLevelMap;
+}
+
+interface ModelCapabilityRule {
+  matches: (context: ModelCapabilityContext) => boolean;
+  overrides: ModelCapabilityOverrides;
+}
+
+const GPT_5_6_THINKING_LEVEL_MAP: ThinkingLevelMap = {
+  off: "none",
+  minimal: "minimal",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh",
+  max: "max",
+};
+
+function includesModelFamily(context: ModelCapabilityContext, family: string): boolean {
+  return [context.availableModelId, context.metadataModelId]
+    .filter((id): id is string => id !== undefined)
+    .some((id) => id.includes(family));
+}
+
+const MODEL_CAPABILITY_RULES: readonly ModelCapabilityRule[] = [
+  {
+    matches: (context) => includesModelFamily(context, "gpt-5.6"),
+    overrides: {
+      reasoning: true,
+      thinkingLevelMap: GPT_5_6_THINKING_LEVEL_MAP,
+    },
+  },
+];
+
+export function getModelCapabilityOverrides(context: ModelCapabilityContext): ModelCapabilityOverrides {
+  const resolved: ModelCapabilityOverrides = {};
+
+  for (const rule of MODEL_CAPABILITY_RULES) {
+    if (!rule.matches(context)) continue;
+    if (rule.overrides.reasoning !== undefined) resolved.reasoning = rule.overrides.reasoning;
+    if (rule.overrides.thinkingLevelMap) resolved.thinkingLevelMap = { ...rule.overrides.thinkingLevelMap };
+  }
+
+  return resolved;
+}

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/provider.ts

@@ -1,5 +1,6 @@
 import type { CpaModel } from "./cpa.ts";
 import { findMetadataMatch, type MetadataMatchMethod } from "./matching.ts";
+import { getModelCapabilityOverrides } from "./model-capabilities.ts";
 import type { InputModality, ModelsDevCatalog, ModelsDevMetadata, ProviderModelConfigLike } from "./types.ts";
 
 export const PI_MODEL_DEFAULTS = {
@@ -38,10 +39,18 @@ function costFromMetadata(metadata: ModelsDevMetadata): ProviderModelConfigLike[
 }
 
 function modelFromMetadata(cpaModel: CpaModel, metadata: ModelsDevMetadata): ProviderModelConfigLike {
+  const capabilityOverrides = getModelCapabilityOverrides({
+    availableModelId: cpaModel.id,
+    metadataModelId: metadata.id,
+  });
+
   return {
     id: cpaModel.id,
     name: metadata.name ?? cpaModel.id,
-    reasoning: metadata.reasoning ?? PI_MODEL_DEFAULTS.reasoning,
+    reasoning: capabilityOverrides.reasoning ?? metadata.reasoning ?? PI_MODEL_DEFAULTS.reasoning,
+    ...(capabilityOverrides.thinkingLevelMap
+      ? { thinkingLevelMap: capabilityOverrides.thinkingLevelMap }
+      : {}),
     input: inputFromMetadata(metadata),
     cost: costFromMetadata(metadata),
     contextWindow: metadata.limit?.context ?? PI_MODEL_DEFAULTS.contextWindow,
@@ -58,10 +67,13 @@ function cloneModelDefaults(): typeof PI_MODEL_DEFAULTS {
 }
 
 function defaultModel(cpaModel: CpaModel): ProviderModelConfigLike {
+  const capabilityOverrides = getModelCapabilityOverrides({ availableModelId: cpaModel.id });
+
   return {
     id: cpaModel.id,
     name: cpaModel.id,
     ...cloneModelDefaults(),
+    ...capabilityOverrides,
   };
 }
 

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

@@ -1,3 +1,5 @@
+import type { ThinkingLevelMap } from "@earendil-works/pi-ai";
+
 export type InputModality = "text" | "image";
 
 export interface CpaProviderConfig {
@@ -6,8 +8,6 @@ export interface CpaProviderConfig {
   authRequired: boolean;
   authHeader: boolean;
   headers: Record<string, string>;
-  cpaCacheTtlSeconds: number;
-  modelsDevCacheTtlSeconds: number;
   modelsDevEnabled: boolean;
   modelAliases: Record<string, string>;
 }
@@ -38,6 +38,7 @@ export interface ProviderModelConfigLike {
   id: string;
   name: string;
   reasoning: boolean;
+  thinkingLevelMap?: ThinkingLevelMap;
   input: InputModality[];
   cost: {
     input: number;