@shop-os/modelkit 0.2.11 → 0.2.13

package/dist/catalog.cjs

@@ -23,6 +23,7 @@ __export(catalog_entry_exports, {
   ADAPTER_IDS: () => ADAPTER_IDS,
   Catalog: () => Catalog,
   CatalogModelSchema: () => CatalogModelSchema,
+  CatalogModelSchemaBase: () => CatalogModelSchemaBase,
   CatalogSchema: () => CatalogSchema,
   ExposureSchema: () => ExposureSchema,
   IMAGE_MODELS: () => IMAGE_MODELS,
@@ -1877,7 +1878,215 @@ var MODELS = [
 ];
 
 // src/catalog/schema.ts
+var import_zod2 = require("zod");
+
+// src/catalog/collisions.ts
+function collisionIssues(rows) {
+  const issues = [];
+  const seenIds = /* @__PURE__ */ new Map();
+  const seenAliases = /* @__PURE__ */ new Map();
+  rows.forEach((row, index) => {
+    if (seenIds.has(row.id)) {
+      issues.push({
+        index,
+        path: ["id"],
+        message: `Duplicate model id "${row.id}"`
+      });
+    } else {
+      const aliasOwner = seenAliases.get(row.id);
+      if (aliasOwner !== void 0) {
+        issues.push({
+          index: aliasOwner.index,
+          path: ["aliases", aliasOwner.aliasIndex],
+          message: `Alias "${row.id}" collides with a model id`
+        });
+      }
+      seenIds.set(row.id, index);
+    }
+    const local = /* @__PURE__ */ new Set();
+    for (const [aliasIndex, alias] of row.aliases.entries()) {
+      if (alias === row.id || seenIds.has(alias)) {
+        issues.push({
+          index,
+          path: ["aliases", aliasIndex],
+          message: `Alias "${alias}" collides with a model id`
+        });
+      } else if (local.has(alias) || seenAliases.has(alias)) {
+        issues.push({
+          index,
+          path: ["aliases", aliasIndex],
+          message: `Duplicate alias "${alias}"`
+        });
+      }
+      local.add(alias);
+      if (!seenAliases.has(alias)) seenAliases.set(alias, { index, aliasIndex });
+    }
+  });
+  return issues;
+}
+
+// src/catalog/input-spec.ts
 var import_zod = require("zod");
+var VIDEO_INPUT_SPEC_KEYS = [
+  "prompt",
+  "durationSeconds",
+  "aspectRatio",
+  "resolution",
+  "firstFrame",
+  "lastFrame",
+  "seed",
+  "negativePrompt",
+  "generateAudio",
+  "cfgScale",
+  "promptExpansion",
+  "referenceImages"
+];
+var AUDIO_INPUT_SPEC_KEYS = [
+  "prompt",
+  "durationSeconds",
+  "seed",
+  "negativePrompt",
+  "references",
+  "sourceVideo",
+  "instrumental"
+];
+var INPUT_SPEC_SUPPORTS_KEYS = [
+  "lastFrame",
+  "seed",
+  "negativePrompt",
+  "generateAudio",
+  "cfgScale",
+  "promptExpansion",
+  "instrumental"
+];
+var VIDEO_KEY_SET = new Set(VIDEO_INPUT_SPEC_KEYS);
+var AUDIO_KEY_SET = new Set(AUDIO_INPUT_SPEC_KEYS);
+var ALL_KEY_SET = /* @__PURE__ */ new Set([
+  ...VIDEO_INPUT_SPEC_KEYS,
+  ...AUDIO_INPUT_SPEC_KEYS
+]);
+var ProviderScalarSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]);
+var FieldsSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.string().min(1)).superRefine((fields, ctx) => {
+  const keys = Object.keys(fields);
+  if (keys.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "inputSpec.fields must name at least one field"
+    });
+    return;
+  }
+  for (const key of keys) {
+    if (!ALL_KEY_SET.has(key)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `inputSpec.fields has unknown canonical key "${key}"`
+      });
+    }
+  }
+});
+var ValuesSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.record(import_zod.z.string(), ProviderScalarSchema)).superRefine((values, ctx) => {
+  for (const key of Object.keys(values)) {
+    if (!ALL_KEY_SET.has(key)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `inputSpec.values has unknown canonical key "${key}"`
+      });
+    }
+  }
+});
+var StaticSchema = import_zod.z.record(import_zod.z.string(), ProviderScalarSchema);
+var InputSpecSchema = import_zod.z.strictObject({
+  fields: FieldsSchema,
+  values: ValuesSchema.optional(),
+  static: StaticSchema.optional()
+}).superRefine((spec, ctx) => {
+  const mappedNames = new Set(Object.values(spec.fields));
+  for (const key of Object.keys(spec.static ?? {})) {
+    if (mappedNames.has(key)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["static", key],
+        message: `inputSpec.static "${key}" collides with a mapped field name`
+      });
+    }
+  }
+});
+function validateInputSpec(raw, row) {
+  const parsed = InputSpecSchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      issues: parsed.error.issues.map((issue) => ({
+        path: issue.path,
+        message: issue.message
+      }))
+    };
+  }
+  const spec = parsed.data;
+  if (row.adapter !== "replicate") {
+    return {
+      ok: false,
+      issues: [{ path: [], message: "inputSpec is only supported on replicate rows" }]
+    };
+  }
+  const issues = [];
+  if (row.type !== "video" && row.type !== "audio") {
+    issues.push({
+      path: [],
+      message: `inputSpec is not supported for "${row.type}" rows`
+    });
+  } else {
+    const allowed = row.type === "video" ? VIDEO_KEY_SET : AUDIO_KEY_SET;
+    for (const key of Object.keys(spec.fields)) {
+      if (!allowed.has(key)) {
+        issues.push({
+          path: ["fields", key],
+          message: `inputSpec.fields "${key}" is not supported for ${row.type} rows`
+        });
+      }
+    }
+    for (const key of Object.keys(spec.values ?? {})) {
+      if (!allowed.has(key)) {
+        issues.push({
+          path: ["values", key],
+          message: `inputSpec.values "${key}" is not supported for ${row.type} rows`
+        });
+      }
+    }
+  }
+  const seenNames = /* @__PURE__ */ new Map();
+  for (const [key, name] of Object.entries(spec.fields)) {
+    const first = seenNames.get(name);
+    if (first === void 0) seenNames.set(name, key);
+    else {
+      issues.push({
+        path: ["fields", key],
+        message: `inputSpec.fields "${first}" and "${key}" both map to "${name}"`
+      });
+    }
+  }
+  for (const key of Object.keys(spec.values ?? {})) {
+    if (!(key in spec.fields)) {
+      issues.push({
+        path: ["values", key],
+        message: `inputSpec.values "${key}" has no matching fields entry`
+      });
+    }
+  }
+  const supports = row.constraints.supports ?? [];
+  for (const key of INPUT_SPEC_SUPPORTS_KEYS) {
+    if (key in spec.fields && !supports.includes(key)) {
+      issues.push({
+        path: ["fields", key],
+        message: `inputSpec.fields "${key}" needs "${key}" in constraints.supports`
+      });
+    }
+  }
+  if (issues.length > 0) return { ok: false, issues };
+  return { ok: true, spec };
+}
+
+// src/catalog/schema.ts
 var ADAPTER_IDS = [
   "ai-sdk-text",
   "google-image",
@@ -1890,16 +2099,16 @@ var ADAPTER_IDS = [
   "higgsfield",
   "xai-video"
 ];
-var ModelTypeSchema = import_zod.z.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
-var LifecycleSchema = import_zod.z.enum(["active", "deprecated", "retired"]);
-var SurfaceSchema = import_zod.z.enum(["cowork", "space_builder"]);
+var ModelTypeSchema = import_zod2.z.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
+var LifecycleSchema = import_zod2.z.enum(["active", "deprecated", "retired"]);
+var SurfaceSchema = import_zod2.z.enum(["cowork", "space_builder"]);
 var SURFACES2 = SurfaceSchema.options;
-var ExposureSchema = import_zod.z.preprocess(
+var ExposureSchema = import_zod2.z.preprocess(
   normalizeExposure,
-  import_zod.z.array(SurfaceSchema)
+  import_zod2.z.array(SurfaceSchema)
 );
-var AdapterSchema = import_zod.z.enum(ADAPTER_IDS);
-var AspectRatioSchema = import_zod.z.enum([
+var AdapterSchema = import_zod2.z.enum(ADAPTER_IDS);
+var AspectRatioSchema = import_zod2.z.enum([
   "1:1",
   "16:9",
   "9:16",
@@ -1914,12 +2123,12 @@ var AspectRatioSchema = import_zod.z.enum([
   "97:30",
   "adaptive"
 ]);
-var ImageSizeSchema = import_zod.z.enum(["512", "1K", "2K", "4K"]);
-var VideoResolutionSchema = import_zod.z.enum(["360p", "480p", "720p", "768p", "1080p", "2k", "4k"]);
-var ImageQualitySchema = import_zod.z.enum(["auto", "low", "medium", "high", "xhigh", "max"]);
-var OutputFormatSchema = import_zod.z.enum(["png", "jpeg", "webp"]);
-var RequiredInputSchema = import_zod.z.enum(["firstFrame", "sourceVideo", "references"]);
-var SupportedOptionSchema = import_zod.z.enum([
+var ImageSizeSchema = import_zod2.z.enum(["512", "1K", "2K", "4K"]);
+var VideoResolutionSchema = import_zod2.z.enum(["360p", "480p", "720p", "768p", "1080p", "2k", "4k"]);
+var ImageQualitySchema = import_zod2.z.enum(["auto", "low", "medium", "high", "xhigh", "max"]);
+var OutputFormatSchema = import_zod2.z.enum(["png", "jpeg", "webp"]);
+var RequiredInputSchema = import_zod2.z.enum(["firstFrame", "sourceVideo", "references"]);
+var SupportedOptionSchema = import_zod2.z.enum([
   "seed",
   "quality",
   "negativePrompt",
@@ -1938,128 +2147,128 @@ var SupportedOptionSchema = import_zod.z.enum([
   "taskType",
   "instrumental"
 ]);
-var UsageUnitSchema = import_zod.z.enum([
+var UsageUnitSchema = import_zod2.z.enum([
   "tokens",
   "images",
   "seconds",
   "reported_cost_usd",
   "compute_seconds"
 ]);
-var PricingKindSchema = import_zod.z.enum(["token", "image_size", "video_per_second", "flat"]);
-var ProviderOptionValueSchema = import_zod.z.lazy(
-  () => import_zod.z.union([
-    import_zod.z.string(),
-    import_zod.z.number(),
-    import_zod.z.boolean(),
-    import_zod.z.array(ProviderOptionValueSchema),
-    import_zod.z.record(import_zod.z.string(), ProviderOptionValueSchema)
+var PricingKindSchema = import_zod2.z.enum(["token", "image_size", "video_per_second", "flat"]);
+var ProviderOptionValueSchema = import_zod2.z.lazy(
+  () => import_zod2.z.union([
+    import_zod2.z.string(),
+    import_zod2.z.number(),
+    import_zod2.z.boolean(),
+    import_zod2.z.array(ProviderOptionValueSchema),
+    import_zod2.z.record(import_zod2.z.string(), ProviderOptionValueSchema)
   ])
 );
-var ProviderOptionsSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.record(import_zod.z.string(), ProviderOptionValueSchema));
-var ReferenceLimitsSchema = import_zod.z.looseObject({
-  images: import_zod.z.number().optional(),
-  imagesWithVideo: import_zod.z.number().optional(),
-  videos: import_zod.z.number().optional(),
-  audios: import_zod.z.number().optional(),
-  total: import_zod.z.number().optional(),
-  audioOnly: import_zod.z.boolean().optional()
+var ProviderOptionsSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.record(import_zod2.z.string(), ProviderOptionValueSchema));
+var ReferenceLimitsSchema = import_zod2.z.looseObject({
+  images: import_zod2.z.number().optional(),
+  imagesWithVideo: import_zod2.z.number().optional(),
+  videos: import_zod2.z.number().optional(),
+  audios: import_zod2.z.number().optional(),
+  total: import_zod2.z.number().optional(),
+  audioOnly: import_zod2.z.boolean().optional()
 });
-var ModelConstraintsSchema = import_zod.z.looseObject({
-  aspectRatios: import_zod.z.array(AspectRatioSchema).optional(),
-  sizes: import_zod.z.array(ImageSizeSchema).optional(),
-  resolutions: import_zod.z.array(VideoResolutionSchema).optional(),
-  durations: import_zod.z.union([import_zod.z.looseObject({ min: import_zod.z.number(), max: import_zod.z.number() }), import_zod.z.array(import_zod.z.number())]).optional(),
-  durationPresets: import_zod.z.array(import_zod.z.number()).optional(),
-  qualityOptions: import_zod.z.array(import_zod.z.string()).optional(),
-  exactSizes: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+var ModelConstraintsSchema = import_zod2.z.looseObject({
+  aspectRatios: import_zod2.z.array(AspectRatioSchema).optional(),
+  sizes: import_zod2.z.array(ImageSizeSchema).optional(),
+  resolutions: import_zod2.z.array(VideoResolutionSchema).optional(),
+  durations: import_zod2.z.union([import_zod2.z.looseObject({ min: import_zod2.z.number(), max: import_zod2.z.number() }), import_zod2.z.array(import_zod2.z.number())]).optional(),
+  durationPresets: import_zod2.z.array(import_zod2.z.number()).optional(),
+  qualityOptions: import_zod2.z.array(import_zod2.z.string()).optional(),
+  exactSizes: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
   references: ReferenceLimitsSchema.optional(),
-  requires: import_zod.z.array(RequiredInputSchema).optional(),
-  supports: import_zod.z.array(SupportedOptionSchema).optional(),
-  ratioIgnoredWith: import_zod.z.array(import_zod.z.enum(["firstFrame", "sourceVideo"])).optional()
+  requires: import_zod2.z.array(RequiredInputSchema).optional(),
+  supports: import_zod2.z.array(SupportedOptionSchema).optional(),
+  ratioIgnoredWith: import_zod2.z.array(import_zod2.z.enum(["firstFrame", "sourceVideo"])).optional()
 });
-var MediaRefSchema = import_zod.z.union([
-  import_zod.z.looseObject({ url: import_zod.z.string(), label: import_zod.z.string().optional() }),
-  import_zod.z.looseObject({
-    bytes: import_zod.z.instanceof(Uint8Array),
-    mime: import_zod.z.string(),
-    label: import_zod.z.string().optional()
+var MediaRefSchema = import_zod2.z.union([
+  import_zod2.z.looseObject({ url: import_zod2.z.string(), label: import_zod2.z.string().optional() }),
+  import_zod2.z.looseObject({
+    bytes: import_zod2.z.instanceof(Uint8Array),
+    mime: import_zod2.z.string(),
+    label: import_zod2.z.string().optional()
   })
 ]);
-var ImageSafetySettingSchema = import_zod.z.looseObject({ category: import_zod.z.string(), threshold: import_zod.z.string() });
-var UpscaleOptionsSchema = import_zod.z.looseObject({
-  enhanceModel: import_zod.z.string().optional(),
-  subjectDetection: import_zod.z.string().optional(),
-  faceEnhancement: import_zod.z.boolean().optional(),
-  faceEnhancementCreativity: import_zod.z.number().optional(),
-  faceEnhancementStrength: import_zod.z.number().optional()
+var ImageSafetySettingSchema = import_zod2.z.looseObject({ category: import_zod2.z.string(), threshold: import_zod2.z.string() });
+var UpscaleOptionsSchema = import_zod2.z.looseObject({
+  enhanceModel: import_zod2.z.string().optional(),
+  subjectDetection: import_zod2.z.string().optional(),
+  faceEnhancement: import_zod2.z.boolean().optional(),
+  faceEnhancementCreativity: import_zod2.z.number().optional(),
+  faceEnhancementStrength: import_zod2.z.number().optional()
 });
-var DefaultsSchema = import_zod.z.looseObject({
-  references: import_zod.z.array(MediaRefSchema).optional(),
+var DefaultsSchema = import_zod2.z.looseObject({
+  references: import_zod2.z.array(MediaRefSchema).optional(),
   aspectRatio: AspectRatioSchema.optional(),
   size: ImageSizeSchema.optional(),
-  exactSize: import_zod.z.string().optional(),
+  exactSize: import_zod2.z.string().optional(),
   quality: ImageQualitySchema.optional(),
-  seed: import_zod.z.number().optional(),
-  count: import_zod.z.number().optional(),
+  seed: import_zod2.z.number().optional(),
+  count: import_zod2.z.number().optional(),
   outputFormat: OutputFormatSchema.optional(),
-  scaleFactor: import_zod.z.number().optional(),
-  safetySettings: import_zod.z.array(ImageSafetySettingSchema).optional(),
-  temperature: import_zod.z.number().optional(),
+  scaleFactor: import_zod2.z.number().optional(),
+  safetySettings: import_zod2.z.array(ImageSafetySettingSchema).optional(),
+  temperature: import_zod2.z.number().optional(),
   upscale: UpscaleOptionsSchema.optional(),
   firstFrame: MediaRefSchema.optional(),
   lastFrame: MediaRefSchema.optional(),
   sourceVideo: MediaRefSchema.optional(),
-  referenceImages: import_zod.z.array(MediaRefSchema).optional(),
-  referenceVideos: import_zod.z.array(MediaRefSchema).optional(),
-  referenceAudios: import_zod.z.array(MediaRefSchema).optional(),
+  referenceImages: import_zod2.z.array(MediaRefSchema).optional(),
+  referenceVideos: import_zod2.z.array(MediaRefSchema).optional(),
+  referenceAudios: import_zod2.z.array(MediaRefSchema).optional(),
   resolution: VideoResolutionSchema.optional(),
-  durationSeconds: import_zod.z.number().optional(),
-  generateAudio: import_zod.z.boolean().optional(),
-  negativePrompt: import_zod.z.string().optional(),
-  cfgScale: import_zod.z.number().optional(),
-  promptExpansion: import_zod.z.enum(["fast", "balanced", "quality"]).optional(),
-  watermark: import_zod.z.boolean().optional(),
-  safetyChecker: import_zod.z.boolean().optional(),
-  taskType: import_zod.z.enum(["reference", "edit", "extend"]).optional(),
-  mode: import_zod.z.enum(["standard", "pro"]).optional(),
-  instrumental: import_zod.z.boolean().optional()
+  durationSeconds: import_zod2.z.number().optional(),
+  generateAudio: import_zod2.z.boolean().optional(),
+  negativePrompt: import_zod2.z.string().optional(),
+  cfgScale: import_zod2.z.number().optional(),
+  promptExpansion: import_zod2.z.enum(["fast", "balanced", "quality"]).optional(),
+  watermark: import_zod2.z.boolean().optional(),
+  safetyChecker: import_zod2.z.boolean().optional(),
+  taskType: import_zod2.z.enum(["reference", "edit", "extend"]).optional(),
+  mode: import_zod2.z.enum(["standard", "pro"]).optional(),
+  instrumental: import_zod2.z.boolean().optional()
 });
-var CatalogDisplaySchema = import_zod.z.looseObject({
-  provider: import_zod.z.string(),
-  description: import_zod.z.string(),
-  logo: import_zod.z.string().optional(),
-  costTier: import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(2), import_zod.z.literal(3)]).optional(),
-  recommended: import_zod.z.boolean().optional(),
-  sortOrder: import_zod.z.number().optional(),
-  chat: import_zod.z.looseObject({
+var CatalogDisplaySchema = import_zod2.z.looseObject({
+  provider: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  logo: import_zod2.z.string().optional(),
+  costTier: import_zod2.z.union([import_zod2.z.literal(1), import_zod2.z.literal(2), import_zod2.z.literal(3)]).optional(),
+  recommended: import_zod2.z.boolean().optional(),
+  sortOrder: import_zod2.z.number().optional(),
+  chat: import_zod2.z.looseObject({
     providerOptions: ProviderOptionsSchema.optional(),
-    temperature: import_zod.z.number().optional()
+    temperature: import_zod2.z.number().optional()
   }).optional()
 });
-var CatalogCapabilitiesSchema = import_zod.z.looseObject({
-  acceptsSourceVideo: import_zod.z.boolean().optional(),
-  framesExcludeReferences: import_zod.z.boolean().optional(),
-  reasoning: import_zod.z.boolean().optional(),
-  vision: import_zod.z.boolean().optional(),
-  contextWindow: import_zod.z.number().optional()
+var CatalogCapabilitiesSchema = import_zod2.z.looseObject({
+  acceptsSourceVideo: import_zod2.z.boolean().optional(),
+  framesExcludeReferences: import_zod2.z.boolean().optional(),
+  reasoning: import_zod2.z.boolean().optional(),
+  vision: import_zod2.z.boolean().optional(),
+  contextWindow: import_zod2.z.number().optional()
 });
-var CatalogModelSchemaBase = import_zod.z.looseObject({
-  id: import_zod.z.string().min(1),
-  aliases: import_zod.z.array(import_zod.z.string()).default([]),
-  label: import_zod.z.string().min(1),
+var CatalogModelSchemaBase = import_zod2.z.looseObject({
+  id: import_zod2.z.string().min(1),
+  aliases: import_zod2.z.array(import_zod2.z.string()).default([]),
+  label: import_zod2.z.string().min(1),
   type: ModelTypeSchema,
   adapter: AdapterSchema,
-  providerModelId: import_zod.z.string().min(1),
+  providerModelId: import_zod2.z.string().min(1),
   lifecycle: LifecycleSchema,
-  replacedBy: import_zod.z.string().optional(),
+  replacedBy: import_zod2.z.string().optional(),
   exposure: ExposureSchema,
   constraints: ModelConstraintsSchema,
   defaults: DefaultsSchema,
   providerOptions: ProviderOptionsSchema.optional(),
-  usage: import_zod.z.looseObject({
+  usage: import_zod2.z.looseObject({
     unit: UsageUnitSchema,
-    slug: import_zod.z.string().optional(),
-    providerLabel: import_zod.z.string().optional()
+    slug: import_zod2.z.string().optional(),
+    providerLabel: import_zod2.z.string().optional()
   }),
   pricingKind: PricingKindSchema,
   display: CatalogDisplaySchema.optional(),
@@ -2097,44 +2306,29 @@ var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
         message: 'transport must be "direct" or "bedrock"'
       });
     }
+    const inputSpecRaw = row.providerOptions?.["modelkit"]?.["inputSpec"];
+    if (inputSpecRaw !== void 0) {
+      const result = validateInputSpec(inputSpecRaw, row);
+      if (!result.ok) {
+        for (const issue of result.issues) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["providerOptions", "modelkit", "inputSpec", ...issue.path],
+            message: issue.message
+          });
+        }
+      }
+    }
   }
 );
-var CatalogSchema = import_zod.z.array(CatalogModelSchemaBase).superRefine((rows, ctx) => {
-  const seenIds = /* @__PURE__ */ new Map();
-  rows.forEach((row, index) => {
-    if (seenIds.has(row.id)) {
-      ctx.addIssue({
-        code: "custom",
-        path: [index, "id"],
-        message: `Duplicate model id "${row.id}"`
-      });
-    } else {
-      seenIds.set(row.id, index);
-    }
-  });
-  const seenAliases = /* @__PURE__ */ new Map();
-  rows.forEach((row, index) => {
-    row.aliases.forEach((alias, aliasIndex) => {
-      const path = [index, "aliases", aliasIndex];
-      if (alias === row.id || seenIds.has(alias)) {
-        ctx.addIssue({
-          code: "custom",
-          path,
-          message: `Alias "${alias}" collides with a model id`
-        });
-        return;
-      }
-      if (seenAliases.has(alias)) {
-        ctx.addIssue({
-          code: "custom",
-          path,
-          message: `Duplicate alias "${alias}"`
-        });
-      } else {
-        seenAliases.set(alias, index);
-      }
+var CatalogSchema = import_zod2.z.array(CatalogModelSchemaBase).superRefine((rows, ctx) => {
+  for (const issue of collisionIssues(rows)) {
+    ctx.addIssue({
+      code: "custom",
+      path: [issue.index, ...issue.path],
+      message: issue.message
     });
-  });
+  }
 });
 
 // src/catalog/live.ts
@@ -2149,26 +2343,102 @@ var liveState = store[KEY] ??= {
 };
 var liveCatalog = liveState.catalog;
 
+// src/json.ts
+var import_zod3 = require("zod");
+var JsonValueSchema = import_zod3.z.lazy(
+  () => import_zod3.z.union([
+    import_zod3.z.string(),
+    import_zod3.z.number(),
+    import_zod3.z.boolean(),
+    import_zod3.z.null(),
+    import_zod3.z.array(JsonValueSchema),
+    import_zod3.z.record(import_zod3.z.string(), JsonValueSchema)
+  ])
+);
+var JsonObjectSchema = import_zod3.z.record(import_zod3.z.string(), JsonValueSchema);
+var thrownErrorSchema = import_zod3.z.object({
+  message: import_zod3.z.string().optional(),
+  status: import_zod3.z.number().optional(),
+  statusCode: import_zod3.z.number().optional(),
+  responseBody: import_zod3.z.string().optional()
+});
+
 // src/catalog/load.ts
-var import_zod2 = require("zod");
+var import_zod4 = require("zod");
 function rowCount() {
   return liveCatalog.list({ lifecycle: ["active", "deprecated", "retired"] }).length;
 }
 function authHeaders(auth) {
   return "bearer" in auth ? { Authorization: `Bearer ${auth.bearer}` } : { "x-api-key": auth.apiKey };
 }
-var EnvelopeSchema = import_zod2.z.object({
-  rows: CatalogSchema,
-  revision: import_zod2.z.string().optional()
+var EnvelopeSchema = import_zod4.z.object({
+  rows: import_zod4.z.array(JsonValueSchema),
+  revision: import_zod4.z.string().optional()
 });
-function toEnvelope(data) {
-  if (data.rows.length === 0) throw new Error("invalid catalog response: no rows");
-  const envelope = { rows: data.rows };
+function dropReason(path, message) {
+  return path.length === 0 ? message : `${path.map((part) => String(part)).join(".")} ${message}`;
+}
+function rowId(raw) {
+  const parsed = import_zod4.z.object({ id: import_zod4.z.string().min(1) }).loose().safeParse(raw);
+  if (!parsed.success) return "?";
+  return parsed.data.id;
+}
+function quarantine(rawRows, logger) {
+  const valid = [];
+  let dropped = 0;
+  for (const raw of rawRows) {
+    const parsed = CatalogModelSchemaBase.safeParse(raw);
+    if (!parsed.success) {
+      const first = parsed.error.issues[0];
+      const reason = first ? dropReason(first.path, first.message) : "invalid row";
+      logger.warn(`[modelkit] catalog row dropped id=${rowId(raw)} reason=${reason}`);
+      dropped += 1;
+      continue;
+    }
+    const row = parsed.data;
+    const inputSpecRaw = row.providerOptions?.["modelkit"]?.["inputSpec"];
+    if (inputSpecRaw !== void 0) {
+      const result = validateInputSpec(inputSpecRaw, row);
+      if (!result.ok) {
+        const first = result.issues[0];
+        const detail = first ? dropReason(first.path, first.message) : "invalid inputSpec";
+        logger.warn(
+          `[modelkit] catalog row ${row.id} has an invalid providerOptions.modelkit.inputSpec: ${detail}; calls fail until it is fixed`
+        );
+      }
+    }
+    valid.push(row);
+  }
+  let kept = valid;
+  for (; ; ) {
+    const issues = collisionIssues(kept);
+    if (issues.length === 0) break;
+    const firstByIndex = /* @__PURE__ */ new Map();
+    for (const issue of issues) {
+      if (!firstByIndex.has(issue.index)) firstByIndex.set(issue.index, issue);
+    }
+    for (const [index, issue] of [...firstByIndex.entries()].sort((a, b) => a[0] - b[0])) {
+      const row = kept[index];
+      if (!row) continue;
+      logger.warn(
+        `[modelkit] catalog row dropped id=${row.id} reason=${String(issue.path[0] ?? "")} ${issue.message}`
+      );
+    }
+    const dropSet = new Set(firstByIndex.keys());
+    kept = kept.filter((_, index) => !dropSet.has(index));
+    dropped += dropSet.size;
+  }
+  return { rows: kept, dropped };
+}
+function toEnvelope(data, logger) {
+  const { rows, dropped } = quarantine(data.rows, logger);
+  if (rows.length === 0) throw new Error("invalid catalog response: no rows");
+  const envelope = { rows, dropped };
   if (data.revision !== void 0) envelope.revision = data.revision;
   return envelope;
 }
-function describeError(err) {
-  return err instanceof Error ? err.message : String(err);
+function describeError(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
 }
 function logPrimed(logger, result) {
   const revision = result.revision === void 0 ? "" : ` revision=${result.revision}`;
@@ -2189,9 +2459,9 @@ async function fetchRemote(source, logger) {
   const json = await res.json();
   const parsed = EnvelopeSchema.safeParse(json);
   if (!parsed.success) throw new Error("invalid catalog response: missing rows");
-  const { rows, revision: rev } = toEnvelope(parsed.data);
-  if (rev === void 0) return { rows, fromCache: false };
-  return { rows, revision: rev, fromCache: false };
+  const { rows, revision: rev, dropped } = toEnvelope(parsed.data, logger);
+  if (rev === void 0) return { rows, fromCache: false, dropped };
+  return { rows, revision: rev, fromCache: false, dropped };
 }
 async function writeCache(source, logger, rows, rev) {
   if (!source.cache) return;
@@ -2216,6 +2486,7 @@ async function prime(source, logger) {
     await writeCache(source, logger, fetched.rows, fetched.revision);
     const result = { origin: liveState.origin, rowCount: rowCount() };
     if (fetched.revision !== void 0) result.revision = fetched.revision;
+    if (fetched.dropped > 0) result.droppedRows = fetched.dropped;
     logPrimed(logger, result);
     return result;
   } catch (err) {
@@ -2226,7 +2497,7 @@ async function prime(source, logger) {
       if (!cached) throw new Error("no cached catalog");
       const cachedParsed = EnvelopeSchema.safeParse(JSON.parse(cached));
       if (!cachedParsed.success) throw new Error("invalid catalog response: missing rows");
-      const { rows, revision: rev } = toEnvelope(cachedParsed.data);
+      const { rows, revision: rev, dropped } = toEnvelope(cachedParsed.data, logger);
       liveCatalog.replace(rows);
       liveState.origin = "last-good";
       liveState.revision = rev;
@@ -2236,6 +2507,7 @@ async function prime(source, logger) {
         error
       };
       if (rev !== void 0) result.revision = rev;
+      if (dropped > 0) result.droppedRows = dropped;
       logPrimed(logger, result);
       return result;
     } catch (cacheErr) {