@tonyclaw/agent-inspector 2.0.8 → 2.0.10

package/src/lib/providerModelMetadata.ts

@@ -0,0 +1,327 @@
+import { z } from "zod";
+import type { ProviderConfig, ProviderModelMetadata } from "./providerContract";
+
+export const ProviderRegistryModelSchema = z.object({
+  id: z.string().min(1),
+  aliases: z.array(z.string()).optional().default([]),
+  contextWindow: z.number().int().positive().optional(),
+  outputLimit: z.number().int().positive().optional(),
+  sourceUrl: z.string().optional(),
+});
+
+export const ProviderRegistryProviderSchema = z.object({
+  name: z.string().min(1).optional(),
+  aliases: z.array(z.string()).optional().default([]),
+  baseUrls: z.array(z.string()).optional().default([]),
+  models: z.array(ProviderRegistryModelSchema).min(1),
+});
+
+export const ProviderModelRegistrySchema = z.object({
+  version: z.number().int().positive().optional(),
+  updatedAt: z.string().optional(),
+  providers: z.array(ProviderRegistryProviderSchema).optional().default([]),
+  models: z.array(ProviderRegistryModelSchema).optional().default([]),
+});
+
+export type ProviderRegistryModel = z.infer<typeof ProviderRegistryModelSchema>;
+export type ProviderModelRegistry = z.infer<typeof ProviderModelRegistrySchema>;
+
+export type ProviderContextWindowMatch = {
+  providerName: string;
+  model: string;
+  tokens: number;
+  sourceUrl?: string;
+};
+
+export type ProviderModelRegistryApplyResult = {
+  modelMetadata: ProviderModelMetadata[];
+  imported: number;
+  matchedModels: string[];
+  missingModels: string[];
+};
+
+export const BUILTIN_MODEL_METADATA_SOURCE_URL = "agent-inspector://builtin/model-metadata";
+
+export const BUILTIN_PROVIDER_MODEL_REGISTRY: ProviderModelRegistry = {
+  version: 1,
+  updatedAt: "2026-06-23T00:00:00.000Z",
+  providers: [
+    {
+      name: "DeepSeek",
+      aliases: ["deepseek"],
+      baseUrls: ["https://api.deepseek.com"],
+      models: [
+        {
+          id: "deepseek-v4-pro",
+          aliases: ["DeepSeek-V4-Pro"],
+          contextWindow: 1_000_000,
+        },
+        {
+          id: "deepseek-v4-flash",
+          aliases: ["DeepSeek-V4-Flash"],
+          contextWindow: 1_000_000,
+        },
+      ],
+    },
+    {
+      name: "MiniMax",
+      aliases: ["minimax"],
+      baseUrls: ["https://api.minimaxi.com/anthropic"],
+      models: [
+        {
+          id: "MiniMax M3",
+          aliases: ["MiniMax-M3", "minimax-m3"],
+          contextWindow: 1_000_000,
+        },
+        {
+          id: "MiniMax M2.7",
+          aliases: ["MiniMax-M2.7", "minimax-m2.7"],
+          contextWindow: 204_800,
+        },
+        {
+          id: "MiniMax M2.7-highspeed",
+          aliases: ["MiniMax-M2.7-highspeed", "minimax-m2.7-highspeed"],
+          contextWindow: 204_800,
+        },
+        {
+          id: "MiniMax M2.5",
+          aliases: ["MiniMax-M2.5", "minimax-m2.5"],
+          contextWindow: 204_800,
+        },
+        {
+          id: "MiniMax M2.5-highspeed",
+          aliases: ["MiniMax-M2.5-highspeed", "minimax-m2.5-highspeed"],
+          contextWindow: 204_800,
+        },
+        {
+          id: "MiniMax M2.1",
+          aliases: ["MiniMax-M2.1", "minimax-m2.1"],
+          contextWindow: 204_800,
+        },
+        {
+          id: "MiniMax M2.1-highspeed",
+          aliases: ["MiniMax-M2.1-highspeed", "minimax-m2.1-highspeed"],
+          contextWindow: 204_800,
+        },
+      ],
+    },
+  ],
+  models: [],
+};
+
+function normalizeModelName(value: string): string {
+  return value.trim().toLowerCase().replace(/\s+/g, "-");
+}
+
+function normalizeProviderName(value: string): string {
+  return value.trim().toLowerCase().replace(/\s+/g, "");
+}
+
+function normalizeUrl(value: string | undefined): string | null {
+  if (value === undefined) return null;
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  try {
+    const parsed = new URL(trimmed);
+    const path = parsed.pathname.replace(/\/+$/, "");
+    return `${parsed.origin}${path}`.toLowerCase();
+  } catch {
+    return trimmed.replace(/\/+$/, "").toLowerCase();
+  }
+}
+
+function providerBaseUrls(provider: ProviderConfig): string[] {
+  const urls: string[] = [];
+  if (provider.anthropicBaseUrl !== undefined && provider.anthropicBaseUrl.trim() !== "") {
+    urls.push(provider.anthropicBaseUrl);
+  }
+  if (provider.openaiBaseUrl !== undefined && provider.openaiBaseUrl.trim() !== "") {
+    urls.push(provider.openaiBaseUrl);
+  }
+  if (provider.baseUrl !== undefined && provider.baseUrl.trim() !== "") {
+    urls.push(provider.baseUrl);
+  }
+  return urls;
+}
+
+function providerModels(provider: ProviderConfig): string[] {
+  const models = provider.models.filter((model) => model.trim() !== "");
+  if (models.length > 0) return models;
+  if (provider.model !== undefined && provider.model.trim() !== "") return [provider.model];
+  return [];
+}
+
+function registryModelHasUsableMetadata(model: ProviderRegistryModel): boolean {
+  return model.contextWindow !== undefined || model.outputLimit !== undefined;
+}
+
+function registryModelMatches(model: string, registryModel: ProviderRegistryModel): boolean {
+  const normalized = normalizeModelName(model);
+  if (normalized === normalizeModelName(registryModel.id)) return true;
+  return registryModel.aliases.some((alias) => normalized === normalizeModelName(alias));
+}
+
+function providerEntryMatches(
+  provider: ProviderConfig,
+  entry: ProviderModelRegistry["providers"][number],
+): boolean {
+  const providerName = normalizeProviderName(provider.name);
+  const names = entry.name === undefined ? [...entry.aliases] : [entry.name, ...entry.aliases];
+  const nameMatches = names.some((name) => {
+    const normalized = normalizeProviderName(name);
+    return providerName.includes(normalized) || normalized.includes(providerName);
+  });
+  if (nameMatches) return true;
+
+  const normalizedProviderUrls = providerBaseUrls(provider)
+    .map((url) => normalizeUrl(url))
+    .filter((url): url is string => url !== null);
+  const baseUrlMatches = entry.baseUrls.some((url) => {
+    const normalized = normalizeUrl(url);
+    return normalized !== null && normalizedProviderUrls.includes(normalized);
+  });
+  if (baseUrlMatches) return true;
+
+  return providerModels(provider).some((model) =>
+    entry.models.some((registryModel) => registryModelMatches(model, registryModel)),
+  );
+}
+
+function findRegistryModel(
+  provider: ProviderConfig,
+  model: string,
+  registry: ProviderModelRegistry,
+): ProviderRegistryModel | null {
+  for (const providerEntry of registry.providers) {
+    if (!providerEntryMatches(provider, providerEntry)) continue;
+    const matched = providerEntry.models.find((registryModel) =>
+      registryModelMatches(model, registryModel),
+    );
+    if (matched !== undefined && registryModelHasUsableMetadata(matched)) return matched;
+  }
+
+  const topLevelMatched = registry.models.find((registryModel) =>
+    registryModelMatches(model, registryModel),
+  );
+  if (topLevelMatched !== undefined && registryModelHasUsableMetadata(topLevelMatched)) {
+    return topLevelMatched;
+  }
+
+  return null;
+}
+
+export function findProviderModelMetadata(
+  provider: ProviderConfig,
+  model: string,
+): ProviderModelMetadata | null {
+  const normalized = normalizeModelName(model);
+  const metadata = provider.modelMetadata ?? [];
+  return metadata.find((entry) => normalizeModelName(entry.model) === normalized) ?? null;
+}
+
+export function providerHasContextMetadata(provider: ProviderConfig): boolean {
+  const models = providerModels(provider);
+  if (models.length === 0) return false;
+  return models.every((model) => {
+    const metadata = findProviderModelMetadata(provider, model);
+    return metadata !== null && metadata.contextWindow !== undefined;
+  });
+}
+
+export function resolveProviderContextWindow(
+  model: string | null,
+  providers: readonly ProviderConfig[],
+): ProviderContextWindowMatch | null {
+  if (model === null) return null;
+  for (const provider of providers) {
+    const metadata = findProviderModelMetadata(provider, model);
+    if (metadata !== null && metadata.contextWindow !== undefined) {
+      return {
+        providerName: provider.name,
+        model: metadata.model,
+        tokens: metadata.contextWindow,
+        sourceUrl: metadata.sourceUrl,
+      };
+    }
+  }
+  return null;
+}
+
+export function applyProviderModelRegistry(
+  provider: ProviderConfig,
+  registry: ProviderModelRegistry,
+  sourceUrl: string,
+  updatedAt: string,
+  mode: "replace" | "fill-missing" = "replace",
+): ProviderModelRegistryApplyResult {
+  const existing = new Map<string, ProviderModelMetadata>();
+  for (const metadata of provider.modelMetadata ?? []) {
+    existing.set(normalizeModelName(metadata.model), metadata);
+  }
+
+  const matchedModels: string[] = [];
+  const missingModels: string[] = [];
+
+  for (const model of providerModels(provider)) {
+    const registryModel = findRegistryModel(provider, model, registry);
+    if (registryModel === null) {
+      missingModels.push(model);
+      continue;
+    }
+
+    const normalized = normalizeModelName(model);
+    const existingMetadata = existing.get(normalized);
+    if (
+      mode === "fill-missing" &&
+      existingMetadata !== undefined &&
+      existingMetadata.contextWindow !== undefined &&
+      (existingMetadata.outputLimit !== undefined || registryModel.outputLimit === undefined)
+    ) {
+      continue;
+    }
+
+    existing.set(normalized, {
+      model,
+      contextWindow: existingMetadata?.contextWindow ?? registryModel.contextWindow,
+      outputLimit: existingMetadata?.outputLimit ?? registryModel.outputLimit,
+      source: existingMetadata?.source ?? "registry",
+      sourceUrl: existingMetadata?.sourceUrl ?? registryModel.sourceUrl ?? sourceUrl,
+      updatedAt,
+    });
+    matchedModels.push(model);
+  }
+
+  const modelMetadata = [...existing.values()].toSorted((a, b) => a.model.localeCompare(b.model));
+
+  return {
+    modelMetadata,
+    imported: matchedModels.length,
+    matchedModels,
+    missingModels,
+  };
+}
+
+export function applyBuiltinProviderModelMetadata(
+  provider: ProviderConfig,
+  updatedAt: string,
+): ProviderModelRegistryApplyResult {
+  return applyProviderModelRegistry(
+    provider,
+    BUILTIN_PROVIDER_MODEL_REGISTRY,
+    BUILTIN_MODEL_METADATA_SOURCE_URL,
+    updatedAt,
+    "fill-missing",
+  );
+}
+
+export function withBuiltinProviderModelMetadata(
+  provider: ProviderConfig,
+  updatedAt: string,
+): ProviderConfig {
+  const result = applyBuiltinProviderModelMetadata(provider, updatedAt);
+  if (result.imported === 0) return provider;
+  return {
+    ...provider,
+    modelMetadata: result.modelMetadata,
+  };
+}

package/src/proxy/providers.ts

@@ -5,7 +5,12 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { logger } from "./logger";
 import { getDataDir, hasExplicitDataDir } from "./dataDir";
-import { ProviderConfigSchema, type ProviderConfig } from "../lib/providerContract";
+import {
+  ProviderConfigSchema,
+  ProviderModelMetadataSchema,
+  type ProviderConfig,
+} from "../lib/providerContract";
+import { withBuiltinProviderModelMetadata } from "../lib/providerModelMetadata";
 
 export { ProviderConfigSchema };
 export type { ProviderConfig };
@@ -29,6 +34,8 @@ const LegacyProviderConfigSchema = z.object({
   openaiBaseUrl: z.string().optional(),
   authHeader: z.enum(["bearer", "x-api-key"]).optional(),
   apiDocsUrl: z.string().optional(),
+  modelMetadataUrl: z.string().optional(),
+  modelMetadata: z.array(ProviderModelMetadataSchema).optional(),
   source: z.enum(["company", "personal"]).optional(),
   createdAt: z.string().optional(),
   updatedAt: z.string().optional(),
@@ -80,13 +87,15 @@ export function migrateLegacyProvider(
     openaiBaseUrl,
     authHeader: provider.authHeader ?? "bearer",
     apiDocsUrl: provider.apiDocsUrl,
+    modelMetadataUrl: provider.modelMetadataUrl,
+    modelMetadata: provider.modelMetadata,
     source: provider.source,
     createdAt: provider.createdAt ?? now,
     updatedAt: provider.updatedAt ?? now,
   };
 
   const parsed = ProviderConfigSchema.safeParse(candidate);
-  return parsed.success ? parsed.data : null;
+  return parsed.success ? withBuiltinProviderModelMetadata(parsed.data, now) : null;
 }
 
 function migrateFromDataDirConfig(targetStore: Conf<ProvidersStore>, dataDirPath: string): void {
@@ -148,7 +157,11 @@ function migrateFromLegacyConfLocation(targetStore: Conf<ProvidersStore>): void
     });
     const legacyProviders = legacyStore.get("providers", []);
     if (legacyProviders.length === 0) return;
-    targetStore.set("providers", legacyProviders);
+    const now = new Date().toISOString();
+    targetStore.set(
+      "providers",
+      legacyProviders.map((provider) => withBuiltinProviderModelMetadata(provider, now)),
+    );
     logger.info(
       `[providers] Migrated ${legacyProviders.length} provider(s) from ${legacyStore.path} to ${targetStore.path}`,
     );
@@ -301,6 +314,23 @@ function migrateMultiModel(): void {
 
 migrateMultiModel();
 
+function migrateBuiltinModelMetadata(): void {
+  const providers = store.get("providers", []);
+  if (providers.length === 0) return;
+
+  const now = new Date().toISOString();
+  const updated = providers.map((provider) => withBuiltinProviderModelMetadata(provider, now));
+  const changed = updated.some(
+    (provider, index) => JSON.stringify(provider) !== JSON.stringify(providers[index]),
+  );
+
+  if (changed) {
+    store.set("providers", updated);
+  }
+}
+
+migrateBuiltinModelMetadata();
+
 // Override with JSON env var if provided (for testing)
 const providersJson = process.env["AGENT_INSPECTOR_PROVIDERS_JSON"];
 if (providersJson !== undefined) {
@@ -308,7 +338,10 @@ if (providersJson !== undefined) {
     const parsed = ProviderConfigSchema.array().safeParse(JSON.parse(providersJson));
     if (parsed.success) {
       // Apply migration to JSON providers (e.g., convert baseUrl to openaiBaseUrl/anthropicBaseUrl)
-      const migrated = parsed.data.map(migrateProvider);
+      const now = new Date().toISOString();
+      const migrated = parsed.data
+        .map(migrateProvider)
+        .map((provider) => withBuiltinProviderModelMetadata(provider, now));
       store.set("providers", migrated);
     }
   } catch {
@@ -343,6 +376,7 @@ export function addProvider(
   anthropicBaseUrl?: string,
   openaiBaseUrl?: string,
   source?: "company" | "personal",
+  modelMetadataUrl?: string,
 ): ProviderConfig {
   const providers = getProviders();
   const normalizedKey = normalizeApiKey(apiKey);
@@ -361,38 +395,48 @@ export function addProvider(
       (p.openaiBaseUrl ?? "") === (resolvedOpenaiUrl ?? ""),
   );
   if (existing) {
+    const existingIndex = providers.findIndex((p) => p.id === existing.id);
     const newModels = (models ?? []).filter((m) => m !== "");
+    existing.modelMetadataUrl = modelMetadataUrl ?? existing.modelMetadataUrl;
     if (newModels.length > 0) {
       const mergedModels = new Set(existing.models ?? []);
       for (const m of newModels) mergedModels.add(m);
       existing.models = [...mergedModels];
-      existing.updatedAt = now;
-      store.set("providers", providers);
     }
-    return existing;
+    existing.updatedAt = now;
+    const enriched = withBuiltinProviderModelMetadata(existing, now);
+    if (existingIndex >= 0) {
+      providers[existingIndex] = enriched;
+    }
+    store.set("providers", providers);
+    return enriched;
   }
 
-  const newProvider: ProviderConfig = {
-    id: randomUUID(),
-    name,
-    apiKey: normalizedKey,
-    format:
-      format ??
-      (anthropicBaseUrl !== undefined
-        ? "anthropic"
-        : openaiBaseUrl !== undefined
-          ? "openai"
-          : undefined),
-    baseUrl,
-    models: models ?? [],
-    authHeader: authHeader ?? "bearer",
-    apiDocsUrl,
-    createdAt: now,
-    updatedAt: now,
-    anthropicBaseUrl: resolvedAnthropicUrl,
-    openaiBaseUrl: resolvedOpenaiUrl,
-    source,
-  };
+  const newProvider: ProviderConfig = withBuiltinProviderModelMetadata(
+    {
+      id: randomUUID(),
+      name,
+      apiKey: normalizedKey,
+      format:
+        format ??
+        (anthropicBaseUrl !== undefined
+          ? "anthropic"
+          : openaiBaseUrl !== undefined
+            ? "openai"
+            : undefined),
+      baseUrl,
+      models: models ?? [],
+      authHeader: authHeader ?? "bearer",
+      apiDocsUrl,
+      modelMetadataUrl,
+      createdAt: now,
+      updatedAt: now,
+      anthropicBaseUrl: resolvedAnthropicUrl,
+      openaiBaseUrl: resolvedOpenaiUrl,
+      source,
+    },
+    now,
+  );
   providers.push(newProvider);
   store.set("providers", providers);
   return newProvider;
@@ -406,24 +450,36 @@ export function updateProvider(
   const existing = providers.find((p) => p.id === id);
   if (!existing) return null;
 
-  const updated: ProviderConfig = {
-    id: existing.id,
-    name: updates.name ?? existing.name,
-    apiKey: updates.apiKey !== undefined ? normalizeApiKey(updates.apiKey) : existing.apiKey,
-    models: updates.models !== undefined ? updates.models : existing.models,
-    format: updates.format ?? existing.format,
-    baseUrl: updates.baseUrl !== undefined ? updates.baseUrl : existing.baseUrl,
-    authHeader: updates.authHeader ?? existing.authHeader,
-    apiDocsUrl: updates.apiDocsUrl ?? existing.apiDocsUrl,
-    createdAt: existing.createdAt,
-    updatedAt: new Date().toISOString(),
-    // Handle format-specific URLs
-    anthropicBaseUrl:
-      updates.anthropicBaseUrl !== undefined ? updates.anthropicBaseUrl : existing.anthropicBaseUrl,
-    openaiBaseUrl:
-      updates.openaiBaseUrl !== undefined ? updates.openaiBaseUrl : existing.openaiBaseUrl,
-    source: updates.source !== undefined ? updates.source : existing.source,
-  };
+  const updatedAt = new Date().toISOString();
+  const updated: ProviderConfig = withBuiltinProviderModelMetadata(
+    {
+      id: existing.id,
+      name: updates.name ?? existing.name,
+      apiKey: updates.apiKey !== undefined ? normalizeApiKey(updates.apiKey) : existing.apiKey,
+      models: updates.models !== undefined ? updates.models : existing.models,
+      format: updates.format ?? existing.format,
+      baseUrl: updates.baseUrl !== undefined ? updates.baseUrl : existing.baseUrl,
+      authHeader: updates.authHeader ?? existing.authHeader,
+      apiDocsUrl: updates.apiDocsUrl ?? existing.apiDocsUrl,
+      modelMetadataUrl:
+        updates.modelMetadataUrl !== undefined
+          ? updates.modelMetadataUrl
+          : existing.modelMetadataUrl,
+      modelMetadata:
+        updates.modelMetadata !== undefined ? updates.modelMetadata : existing.modelMetadata,
+      createdAt: existing.createdAt,
+      updatedAt,
+      // Handle format-specific URLs
+      anthropicBaseUrl:
+        updates.anthropicBaseUrl !== undefined
+          ? updates.anthropicBaseUrl
+          : existing.anthropicBaseUrl,
+      openaiBaseUrl:
+        updates.openaiBaseUrl !== undefined ? updates.openaiBaseUrl : existing.openaiBaseUrl,
+      source: updates.source !== undefined ? updates.source : existing.source,
+    },
+    updatedAt,
+  );
   const index = providers.findIndex((p) => p.id === id);
   providers[index] = updated;
   store.set("providers", providers);
@@ -519,12 +575,16 @@ export function importProviders(json: string): { imported: number; errors: strin
       }
 
       // Generate new ID and add
-      const newProvider: ProviderConfig = {
-        ...provider,
-        id: randomUUID(),
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-      };
+      const now = new Date().toISOString();
+      const newProvider: ProviderConfig = withBuiltinProviderModelMetadata(
+        {
+          ...provider,
+          id: randomUUID(),
+          createdAt: now,
+          updatedAt: now,
+        },
+        now,
+      );
 
       newProviders.push(newProvider);
       existingKeys.add(key);