@samrito/pi-cliproxyapi-provider 0.16.0 → 0.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@samrito/pi-cliproxyapi-provider",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "description": "Pi provider package for CLIProxyAPI with automatic model discovery and models.dev enrichment.",
   "type": "module",
   "license": "MIT",

package/src/matching.ts

@@ -16,7 +16,17 @@ const CANONICAL_OWNER_PREFIXES: Record<string, string> = {
   cohere: "cohere",
 };
 
-export type MetadataMatchMethod = "alias" | "exact" | "owner-prefix" | "owner-hint" | "suffix" | "normalized-suffix" | "provider-fallback";
+export type MetadataMatchMethod =
+  | "alias"
+  | "exact"
+  | "owner-prefix"
+  | "owner-hint"
+  | "suffix"
+  | "normalized-suffix"
+  | "provider-fallback"
+  | "vendor-prefix"
+  | "vendor-first-party"
+  | "vendor-hint";
 
 export interface MetadataMatch {
   metadataId: string;
@@ -59,16 +69,33 @@ function ownerHintMatch(
   owner: string | undefined,
   candidates: string[],
   catalog: ModelsDevCatalog,
+  includeIdPath = false,
 ): string | undefined {
   if (!owner) return undefined;
   const ownerTokens = identifierTokens(owner);
+  const normalizedOwner = normalizeModelName(owner);
   const matches = candidates.flatMap((metadataId) => {
     const metadata = catalog[metadataId];
     if (!metadata) return [];
+    const found = [];
     const provider = sourceProvider(metadataId, metadata);
     const providerTokens = identifierTokens(provider);
-    if (!containsContiguousTokens(ownerTokens, providerTokens)) return [];
-    return [{ metadataId, tokenCount: providerTokens.length, characterCount: provider.length }];
+    if (containsContiguousTokens(ownerTokens, providerTokens)) {
+      found.push({ metadataId, tokenCount: providerTokens.length, characterCount: provider.length });
+    }
+    if (includeIdPath && normalizedOwner) {
+      // Reseller entries often keep the upstream provider in the metadata id
+      // path (e.g. `poe/xai/grok-3-mini` has id `xai/grok-3-mini`). Match the
+      // owner against those path segments as a last-resort vendor hint. The
+      // large token count ranks this above sourceProvider token matches.
+      const idPathSegments = metadata.id.split("/").slice(0, -1);
+      for (const segment of idPathSegments) {
+        if (normalizeModelName(segment) === normalizedOwner) {
+          found.push({ metadataId, tokenCount: 1000 + segment.length, characterCount: segment.length });
+        }
+      }
+    }
+    return found;
   });
   if (matches.length === 0) return undefined;
 
@@ -148,3 +175,180 @@ export function findMetadataMatch(
 
   return undefined;
 }
+
+/**
+ * Proxy-side variant suffixes that CLIProxyAPI appends to model IDs while
+ * models.dev publishes the base model. Stripping them lets `grok-4.7-build-fast`
+ * resolve to `xai/grok-4.7` and `gemini-3.6-flash-high` to
+ * `google/gemini-3.6-flash`. Ordered longest-first so compound suffixes strip
+ * one segment at a time.
+ */
+const VARIANT_SUFFIXES = [
+  "-non-reasoning",
+  "-reasoning",
+  "-thinking",
+  "-preview",
+  "-medium",
+  "-build",
+  "-high",
+  "-fast",
+  "-low",
+] as const;
+
+function stripVariantSuffix(name: string): string | undefined {
+  for (const suffix of VARIANT_SUFFIXES) {
+    if (name.endsWith(suffix) && name.length > suffix.length) return name.slice(0, -suffix.length);
+  }
+  return undefined;
+}
+
+/**
+ * Candidate names to try when the primary matcher fails. For each stripped
+ * variant it also tries a `-preview` variant, because some proxies drop the
+ * `-preview` suffix that models.dev keeps (`gemini-3-flash` vs
+ * `google/gemini-3-flash-preview`).
+ */
+function modelNameCandidates(id: string): string[] {
+  const modelName = id.split("/").at(-1) ?? id;
+  const candidates: string[] = [];
+  const push = (name: string) => {
+    if (!candidates.includes(name)) candidates.push(name);
+  };
+
+  let current = modelName;
+  while (true) {
+    push(current);
+    if (!current.endsWith("-preview")) push(`${current}-preview`);
+    const stripped = stripVariantSuffix(current);
+    if (!stripped) break;
+    current = stripped;
+  }
+  return candidates;
+}
+
+const MODEL_NAME_PROVIDERS: ReadonlyArray<{ test: RegExp; provider: string }> = [
+  { test: /^claude/, provider: "anthropic" },
+  { test: /^(gemini|gemma|veo|imagen|nano-banana|lyria)/, provider: "google" },
+  { test: /^(gpt-|o1|o3|o4|chatgpt|dall-e|sora|text-embedding|whisper|tts)/, provider: "openai" },
+  { test: /^deepseek/, provider: "deepseek" },
+  { test: /^grok/, provider: "xai" },
+  { test: /^(mistral|codestral|mixtral|ministral|pixtral)/, provider: "mistral" },
+  { test: /^glm/, provider: "zhipuai" },
+  { test: /^qwen/, provider: "alibaba" },
+  { test: /^(kimi|moonshot)/, provider: "moonshotai" },
+  { test: /^(minimax|abab)/, provider: "minimax" },
+  { test: /^nemotron/, provider: "nvidia" },
+  { test: /^command-r/, provider: "cohere" },
+];
+
+/**
+ * Infer the canonical provider from a model name. This is used only when the
+ * primary matcher fails, so it cannot steal matches from the stricter,
+ * owner-driven resolution; it exists to rescue proxy-renamed models whose
+ * `owned_by` is missing, generic, or misleading (`deepseek-flash` reported as
+ * `openai`, for example).
+ */
+function canonicalProviderForModelName(modelName: string): string | undefined {
+  const lower = modelName.toLowerCase();
+  return MODEL_NAME_PROVIDERS.find(({ test }) => test.test(lower))?.provider;
+}
+
+function matchCandidateWithInference(
+  cpaModel: Pick<CpaModel, "id" | "owned_by">,
+  candidate: string,
+  catalog: ModelsDevCatalog,
+  fallbackProvider?: string | null,
+): MetadataMatch | undefined {
+  if (catalog[candidate]) {
+    return { metadataId: candidate, metadata: catalog[candidate], method: "exact" };
+  }
+
+  const keys = Object.keys(catalog);
+  const exactMetadataCandidates = keys.filter((key) => catalog[key]?.id === candidate);
+  const exactMetadataKey = oneMatch(exactMetadataCandidates);
+  if (exactMetadataKey) {
+    return { metadataId: exactMetadataKey, metadata: catalog[exactMetadataKey], method: "exact" };
+  }
+
+  const suffixCandidates = keys.filter(
+    (key) => metadataModelName(key, catalog[key]) === candidate,
+  );
+  const normalizedSuffixCandidates = keys.filter(
+    (key) => normalizeModelName(metadataModelName(key, catalog[key])) === normalizeModelName(candidate),
+  );
+
+  const vendor = canonicalProviderForModelName(candidate);
+  if (vendor) {
+    const vendorKey = `${vendor}/${candidate}`;
+    if (catalog[vendorKey]) {
+      return { metadataId: vendorKey, metadata: catalog[vendorKey], method: "vendor-prefix" };
+    }
+  }
+
+  if (vendor) {
+    const firstParty = suffixCandidates.filter((key) => sourceProvider(key, catalog[key]) === vendor);
+    const firstPartyKey = oneMatch(firstParty);
+    if (firstPartyKey) {
+      return { metadataId: firstPartyKey, metadata: catalog[firstPartyKey], method: "vendor-first-party" };
+    }
+  }
+
+  const owner = cpaModel.owned_by?.trim().toLowerCase();
+  const hintedKey = ownerHintMatch(owner, normalizedSuffixCandidates, catalog, true);
+  if (hintedKey) {
+    return { metadataId: hintedKey, metadata: catalog[hintedKey], method: "vendor-hint" };
+  }
+
+  const suffixKey = oneMatch(suffixCandidates);
+  if (suffixKey) {
+    return { metadataId: suffixKey, metadata: catalog[suffixKey], method: "suffix" };
+  }
+
+  const normalizedSuffixKey = oneMatch(normalizedSuffixCandidates);
+  if (normalizedSuffixKey) {
+    return { metadataId: normalizedSuffixKey, metadata: catalog[normalizedSuffixKey], method: "normalized-suffix" };
+  }
+
+  if (fallbackProvider) {
+    const normalizedFallbackProvider = fallbackProvider.trim().toLowerCase();
+    const fallbackKey = oneMatch(normalizedSuffixCandidates.filter((metadataId) => {
+      const metadata = catalog[metadataId];
+      return metadata && sourceProvider(metadataId, metadata).toLowerCase() === normalizedFallbackProvider;
+    }));
+    if (fallbackKey) {
+      return { metadataId: fallbackKey, metadata: catalog[fallbackKey], method: "provider-fallback" };
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Resolve metadata when the primary matcher fails, by stripping proxy variant
+ * suffixes and inferring the vendor from the model name. This is deliberately a
+ * fallback: models the primary matcher resolves keep their existing, more
+ * conservative match source.
+ */
+export function inferMetadataMatch(
+  cpaModel: Pick<CpaModel, "id" | "owned_by">,
+  catalog: ModelsDevCatalog,
+  fallbackProvider?: string | null,
+): MetadataMatch | undefined {
+  for (const candidate of modelNameCandidates(cpaModel.id)) {
+    const match = matchCandidateWithInference(cpaModel, candidate, catalog, fallbackProvider);
+    if (match) return match;
+  }
+  return undefined;
+}
+
+export function resolveMetadataMatch(
+  cpaModel: Pick<CpaModel, "id" | "owned_by">,
+  catalog: ModelsDevCatalog,
+  aliases: Record<string, string>,
+  fallbackProvider?: string | null,
+): MetadataMatch | undefined {
+  return (
+    findMetadataMatch(cpaModel, catalog, aliases, fallbackProvider)
+    ?? inferMetadataMatch(cpaModel, catalog, fallbackProvider)
+  );
+}

package/src/provider.ts

@@ -1,5 +1,5 @@
 import type { CpaModel } from "./cpa.ts";
-import { findMetadataMatch, type MetadataMatchMethod } from "./matching.ts";
+import { resolveMetadataMatch, type MetadataMatchMethod } from "./matching.ts";
 import { getModelApiOverride, isGpt56Model, type ModelApiContext } from "./model-api.ts";
 import { getModelCapabilityOverrides } from "./model-capabilities.ts";
 import { thinkingLevelMapFromReasoningOptions } from "./reasoning-levels.ts";
@@ -139,6 +139,9 @@ function emptyMatchMethods(): Record<MetadataMatchMethod, number> {
     suffix: 0,
     "normalized-suffix": 0,
     "provider-fallback": 0,
+    "vendor-prefix": 0,
+    "vendor-first-party": 0,
+    "vendor-hint": 0,
   };
 }
 
@@ -173,7 +176,7 @@ export function buildProviderModels(
   let enriched = 0;
 
   const models = cpaModels.map((cpaModel) => {
-    const match = findMetadataMatch(cpaModel, catalog, aliases, metadataFallbackProvider);
+    const match = resolveMetadataMatch(cpaModel, catalog, aliases, metadataFallbackProvider);
     if (!match) {
       unmatchedModelIds.push(cpaModel.id);
       return applyModelOverride(defaultModel(cpaModel, gpt56ContextWindow), overrides);