@tonyclaw/agent-inspector 2.0.8 → 2.0.10

package/src/routes/api/providers.$providerId.model-metadata.ts

@@ -0,0 +1,134 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { z } from "zod";
+import { getProvider, updateProvider } from "../../proxy/providers";
+import {
+  applyBuiltinProviderModelMetadata,
+  applyProviderModelRegistry,
+  BUILTIN_MODEL_METADATA_SOURCE_URL,
+  ProviderModelRegistrySchema,
+} from "../../lib/providerModelMetadata";
+
+const RefreshModelMetadataInputSchema = z.object({
+  url: z.string().optional(),
+});
+
+function normalizeRefreshUrl(value: string | undefined): string | null {
+  if (value === undefined) return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+
+function isHttpUrl(value: string): boolean {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+async function readRegistryJson(response: Response): Promise<unknown | null> {
+  try {
+    return JSON.parse(await response.text());
+  } catch {
+    return null;
+  }
+}
+
+export const Route = createFileRoute("/api/providers/$providerId/model-metadata")({
+  server: {
+    handlers: {
+      POST: async ({ params, request }: { params: { providerId: string }; request: Request }) => {
+        const provider = getProvider(params.providerId);
+        if (provider === undefined) {
+          return Response.json({ error: "Provider not found" }, { status: 404 });
+        }
+
+        const parsed = RefreshModelMetadataInputSchema.safeParse(await request.json());
+        if (!parsed.success) {
+          return Response.json({ error: parsed.error.message }, { status: 400 });
+        }
+
+        const sourceUrl = normalizeRefreshUrl(
+          parsed.data.url ??
+            provider.modelMetadataUrl ??
+            process.env["AGENT_INSPECTOR_MODEL_METADATA_URL"],
+        );
+        if (sourceUrl === null) {
+          const result = applyBuiltinProviderModelMetadata(provider, new Date().toISOString());
+          const updated = updateProvider(provider.id, {
+            modelMetadata: result.modelMetadata,
+          });
+          if (updated === null) {
+            return Response.json({ error: "Provider not found" }, { status: 404 });
+          }
+          return Response.json({
+            provider: updated,
+            imported: result.imported,
+            matchedModels: result.matchedModels,
+            missingModels: result.missingModels,
+            sourceUrl: BUILTIN_MODEL_METADATA_SOURCE_URL,
+          });
+        }
+        if (!isHttpUrl(sourceUrl)) {
+          return Response.json(
+            { error: "Model metadata URL must be an http(s) URL." },
+            { status: 400 },
+          );
+        }
+
+        let response: Response;
+        try {
+          response = await fetch(sourceUrl, { headers: { Accept: "application/json" } });
+        } catch (err) {
+          return Response.json(
+            { error: `Failed to fetch model metadata: ${String(err)}` },
+            { status: 502 },
+          );
+        }
+
+        if (!response.ok) {
+          return Response.json(
+            { error: `Model metadata fetch failed with HTTP ${String(response.status)}` },
+            { status: 502 },
+          );
+        }
+
+        const registryJson = await readRegistryJson(response);
+        if (registryJson === null) {
+          return Response.json(
+            { error: "Model metadata response is not valid JSON." },
+            { status: 400 },
+          );
+        }
+
+        const registry = ProviderModelRegistrySchema.safeParse(registryJson);
+        if (!registry.success) {
+          return Response.json({ error: registry.error.message }, { status: 400 });
+        }
+
+        const result = applyProviderModelRegistry(
+          provider,
+          registry.data,
+          sourceUrl,
+          new Date().toISOString(),
+        );
+        const updated = updateProvider(provider.id, {
+          modelMetadata: result.modelMetadata,
+          modelMetadataUrl: sourceUrl,
+        });
+        if (updated === null) {
+          return Response.json({ error: "Provider not found" }, { status: 404 });
+        }
+
+        return Response.json({
+          provider: updated,
+          imported: result.imported,
+          matchedModels: result.matchedModels,
+          missingModels: result.missingModels,
+          sourceUrl,
+        });
+      },
+    },
+  },
+});

package/src/routes/api/providers.$providerId.ts

@@ -1,6 +1,7 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { z } from "zod";
 import { getProviders, updateProvider, deleteProvider } from "../../proxy/providers";
+import { ProviderModelMetadataSchema } from "../../lib/providerContract";
 
 const ProviderUpdateSchema = z.object({
   name: z.string().min(1, "Name is required").optional(),
@@ -13,6 +14,8 @@ const ProviderUpdateSchema = z.object({
   anthropicBaseUrl: z.string().optional(),
   openaiBaseUrl: z.string().optional(),
   apiDocsUrl: z.string().optional(),
+  modelMetadataUrl: z.string().optional(),
+  modelMetadata: z.array(ProviderModelMetadataSchema).optional(),
   source: z.enum(["company", "personal"]).optional(),
 });
 

package/src/routes/api/providers.ts

@@ -12,6 +12,7 @@ const ProviderInputSchema = z.object({
   model: z.string().optional(),
   authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
   apiDocsUrl: z.string().optional(),
+  modelMetadataUrl: z.string().optional(),
   source: z.enum(["company", "personal"]).optional(),
 });
 
@@ -37,6 +38,7 @@ export const Route = createFileRoute("/api/providers")({
           parsed.data.anthropicBaseUrl,
           parsed.data.openaiBaseUrl,
           parsed.data.source,
+          parsed.data.modelMetadataUrl,
         );
         return Response.json(newProvider, { status: 201 });
       },