@agentproto/catalog-sync 0.2.0

package/dist/index.mjs

@@ -0,0 +1,609 @@
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import { ElevenLabsVoicesSnapshotSchema, mapElevenLabsVoices, MinimaxVoicesSnapshotSchema, mapMinimaxVoices } from '@agentproto/model-catalog/providers';
+
+/**
+ * @agentproto/catalog-sync v0.1.0
+ * Build-time generator framework for @agentproto/model-catalog.
+ * Generates *.generated.ts from pinned provider sources.
+ */
+
+// src/types.ts
+function defineGenerator(g) {
+  return g;
+}
+var __dirname$1 = dirname(fileURLToPath(import.meta.url));
+function catalogSyncDir() {
+  return resolve(__dirname$1, "..");
+}
+function snapshotPath(id) {
+  return join(catalogSyncDir(), "snapshots", `${id}.json`);
+}
+function repoRoot() {
+  let dir = catalogSyncDir();
+  for (let i = 0; i < 12; i++) {
+    if (existsSync(join(dir, "pnpm-workspace.yaml"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return dirname(dirname(catalogSyncDir()));
+}
+function readIfExists(absPath) {
+  if (!existsSync(absPath)) return void 0;
+  return readFileSync(absPath, "utf8");
+}
+function resolveHeaders(headers) {
+  const out = {};
+  const missing = [];
+  if (!headers) return { headers: out, missing };
+  for (const [key, value] of Object.entries(headers)) {
+    out[key] = value.replace(/env:([A-Z0-9_]+)/g, (_match, name) => {
+      const v = process.env[name];
+      if (v === void 0 || v === "") {
+        missing.push(name);
+        return "";
+      }
+      return v;
+    });
+  }
+  return { headers: out, missing };
+}
+async function runGenerators(gens, opts) {
+  const files = {};
+  for (const gen of gens) {
+    const ctx = {
+      refresh: opts.refresh,
+      async fetchSource(src) {
+        const path = snapshotPath(src.id);
+        const existing = readIfExists(path);
+        if (!opts.refresh) {
+          if (existing !== void 0) return JSON.parse(existing);
+          throw new Error(
+            `catalog-sync: no committed snapshot for source "${src.id}" (${path}), and --refresh is not set. Run \`catalog-sync generate --refresh\` to fetch ${src.url}.`
+          );
+        }
+        const { headers, missing } = resolveHeaders(src.headers);
+        if (missing.length > 0) {
+          if (existing !== void 0) {
+            process.stderr.write(
+              `catalog-sync: skipping refresh of "${src.id}" \u2014 missing env ${missing.join(", ")}; reusing committed snapshot.
+`
+            );
+            return JSON.parse(existing);
+          }
+          throw new Error(
+            `catalog-sync: cannot refresh "${src.id}" \u2014 missing env ${missing.join(", ")} and no committed snapshot.`
+          );
+        }
+        const res = await fetch(src.url, {
+          method: src.method ?? "GET",
+          headers,
+          ...src.body !== void 0 ? { body: JSON.stringify(src.body) } : {}
+        });
+        if (!res.ok) {
+          throw new Error(
+            `catalog-sync: fetch ${src.url} failed: ${res.status} ${res.statusText}`
+          );
+        }
+        const text = await res.text();
+        const parsed = JSON.parse(text);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+        return parsed;
+      }
+    };
+    const out = await gen.generate(ctx);
+    for (const [path, content] of Object.entries(out)) {
+      files[path] = content;
+    }
+  }
+  const root = repoRoot();
+  const changed = [];
+  for (const [relPath, content] of Object.entries(files)) {
+    const abs = join(root, relPath);
+    const existing = readIfExists(abs);
+    if (existing !== content) {
+      changed.push(relPath);
+      if (opts.write) {
+        mkdirSync(dirname(abs), { recursive: true });
+        writeFileSync(abs, content, "utf8");
+      }
+    }
+  }
+  return { files, changed };
+}
+var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+var OUTPUT_PATH = "packages/model-catalog/src/llm/openrouter-routes.generated.ts";
+var PricingSchema = z.object({
+  prompt: z.string().optional(),
+  completion: z.string().optional(),
+  input_cache_read: z.string().optional(),
+  input_cache_write: z.string().optional()
+}).passthrough();
+var ModelSchema = z.object({
+  id: z.string(),
+  pricing: PricingSchema.optional()
+}).passthrough();
+var SnapshotSchema = z.object({
+  data: z.array(ModelSchema)
+});
+function round6(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+function per1m(tokenPrice) {
+  if (tokenPrice === void 0) return void 0;
+  const n = Number(tokenPrice);
+  if (!Number.isFinite(n)) return void 0;
+  return round6(n * 1e6);
+}
+function fmt(n) {
+  if (!Number.isFinite(n)) return "0";
+  return `${round6(n)}`;
+}
+function vendorOf(id) {
+  if (!id.includes("/")) return id;
+  return id.split("/")[0] ?? id;
+}
+function serializeEntry(e) {
+  const fields = [
+    `inputPer1M: ${fmt(e.inputPer1M)}`,
+    `outputPer1M: ${fmt(e.outputPer1M)}`
+  ];
+  if (e.cacheReadMultiplier !== void 0) {
+    fields.push(`cacheReadMultiplier: ${fmt(e.cacheReadMultiplier)}`);
+  }
+  if (e.cacheWriteMultiplier !== void 0) {
+    fields.push(`cacheWriteMultiplier: ${fmt(e.cacheWriteMultiplier)}`);
+  }
+  fields.push(`vendor: ${JSON.stringify(e.vendor)}`);
+  fields.push(`provider: ${JSON.stringify(e.provider)}`);
+  return `{
+    ${fields.join(",\n    ")},
+  }`;
+}
+function serializeFile(entries) {
+  const ids = Object.keys(entries).sort();
+  const providers = Array.from(new Set(ids.map(vendorOf))).sort();
+  const lines = [
+    "// AUTO-GENERATED by @agentproto/catalog-sync (llm:openrouter).",
+    "// Do not edit by hand \u2014 re-run `pnpm --filter @agentproto/catalog-sync generate`.",
+    `// Source: ${OPENROUTER_MODELS_URL}`,
+    "// Pricing carries provider USD (inputPer1M / outputPer1M) plus cache",
+    "// multipliers (cacheReadMultiplier / cacheWriteMultiplier) derived from the",
+    "// source's input_cache_read / input_cache_write per-token fields when present.",
+    "",
+    'import type { LLMPricing } from "./catalog.js"',
+    "",
+    "export const OPENROUTER_ROUTES: Record<string, LLMPricing> = {"
+  ];
+  for (const id of ids) {
+    lines.push(`  ${JSON.stringify(id)}: ${serializeEntry(entries[id])},`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("/** Provider slugs treated as OpenRouter routes by the picker. */");
+  lines.push("export const OPENROUTER_PROVIDERS: readonly string[] = [");
+  for (const p of providers) {
+    lines.push(`  ${JSON.stringify(p)},`);
+  }
+  lines.push("]");
+  lines.push("");
+  return lines.join("\n");
+}
+async function generate(ctx) {
+  const src = sources[0];
+  if (!src) throw new Error("llm:openrouter: no source configured");
+  const parsed = SnapshotSchema.parse(await ctx.fetchSource(src));
+  const entries = {};
+  for (const model of parsed.data) {
+    const pricing = model.pricing;
+    if (!pricing) continue;
+    const inputPer1M = per1m(pricing.prompt);
+    const outputPer1M = per1m(pricing.completion);
+    if (inputPer1M === void 0 || outputPer1M === void 0) continue;
+    if (inputPer1M === 0 && outputPer1M === 0) continue;
+    const entry = {
+      inputPer1M,
+      outputPer1M,
+      vendor: vendorOf(model.id),
+      provider: "openrouter"
+    };
+    const cacheReadPer1M = per1m(pricing.input_cache_read);
+    const cacheWritePer1M = per1m(pricing.input_cache_write);
+    if (cacheReadPer1M !== void 0 && cacheReadPer1M > 0 && inputPer1M > 0) {
+      entry.cacheReadMultiplier = round6(cacheReadPer1M / inputPer1M);
+    }
+    if (cacheWritePer1M !== void 0 && cacheWritePer1M > 0 && inputPer1M > 0) {
+      entry.cacheWriteMultiplier = round6(cacheWritePer1M / inputPer1M);
+    }
+    entries[model.id] = entry;
+  }
+  return { [OUTPUT_PATH]: serializeFile(entries) };
+}
+var sources = [{ id: "llm-openrouter", url: OPENROUTER_MODELS_URL }];
+var llmOpenRouterGenerator = defineGenerator({
+  name: "llm:openrouter",
+  modality: "llm",
+  sources,
+  generate
+});
+
+// src/generators/serialize-voices.ts
+function serializeVoice(v) {
+  const lines = ["  {"];
+  lines.push(`    catalogId: ${JSON.stringify(v.catalogId)},`);
+  lines.push(`    providerVoiceId: ${JSON.stringify(v.providerVoiceId)},`);
+  lines.push(`    provider: ${JSON.stringify(v.provider)},`);
+  lines.push(`    label: ${JSON.stringify(v.label)},`);
+  lines.push(`    description: ${JSON.stringify(v.description)},`);
+  lines.push(`    gender: ${JSON.stringify(v.gender)},`);
+  lines.push(`    primaryLanguage: ${JSON.stringify(v.primaryLanguage)},`);
+  lines.push(
+    `    supportedLanguages: [${v.supportedLanguages.map((l) => JSON.stringify(l)).join(", ")}],`
+  );
+  if (v.quality !== void 0) lines.push(`    quality: ${JSON.stringify(v.quality)},`);
+  if (v.featured !== void 0) lines.push(`    featured: ${v.featured},`);
+  if (v.samplePath !== void 0) lines.push(`    samplePath: ${JSON.stringify(v.samplePath)},`);
+  if (v.age !== void 0) lines.push(`    age: ${JSON.stringify(v.age)},`);
+  lines.push("  },");
+  return lines.join("\n");
+}
+function serializeVoiceModule(generatorName, exportName, voices) {
+  const lines = [
+    `// Generated by @agentproto/catalog-sync generator ${generatorName}`,
+    "// DO NOT EDIT MANUALLY \u2014 regenerate with catalog-sync",
+    "",
+    'import type { CatalogVoice } from "@agentproto/model-catalog/schema/voice"',
+    "",
+    `export const ${exportName}: readonly CatalogVoice[] = [`
+  ];
+  for (const v of voices) lines.push(serializeVoice(v));
+  lines.push("] as const");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/generators/voice-elevenlabs.ts
+var ELEVENLABS_SOURCE = {
+  id: "voice-elevenlabs",
+  url: "https://api.elevenlabs.io/v1/voices",
+  // Live refresh needs the account key; offline reads ignore this.
+  headers: { "xi-api-key": "env:ELEVENLABS_API_KEY" }
+};
+var OUTPUT_PATH2 = "packages/catalog-sync/generated/voice-elevenlabs.generated.ts";
+var voiceElevenlabs = defineGenerator({
+  name: "voice:elevenlabs",
+  modality: "voice",
+  sources: [ELEVENLABS_SOURCE],
+  async generate(ctx) {
+    const snapshot = ElevenLabsVoicesSnapshotSchema.parse(
+      await ctx.fetchSource(ELEVENLABS_SOURCE)
+    );
+    const voices = mapElevenLabsVoices(snapshot);
+    return {
+      [OUTPUT_PATH2]: serializeVoiceModule(
+        "voice:elevenlabs",
+        "ELEVENLABS_VOICES",
+        voices
+      )
+    };
+  }
+});
+var MINIMAX_SOURCE = {
+  id: "voice-minimax",
+  url: "https://api.minimax.io/v1/get_voice",
+  // get_voice is a POST; live refresh needs the account key (Bearer). Without
+  // MINIMAX_API_KEY set, the framework reuses the committed snapshot.
+  method: "POST",
+  headers: {
+    Authorization: "Bearer env:MINIMAX_API_KEY",
+    "Content-Type": "application/json"
+  },
+  body: { voice_type: "system" }
+};
+var OUTPUT_PATH3 = "packages/catalog-sync/generated/voice-minimax.generated.ts";
+var voiceMinimax = defineGenerator({
+  name: "voice:minimax",
+  modality: "voice",
+  sources: [MINIMAX_SOURCE],
+  async generate(ctx) {
+    const snapshot = MinimaxVoicesSnapshotSchema.parse(
+      await ctx.fetchSource(MINIMAX_SOURCE)
+    );
+    const voices = mapMinimaxVoices(snapshot);
+    return {
+      [OUTPUT_PATH3]: serializeVoiceModule(
+        "voice:minimax",
+        "MINIMAX_VOICES",
+        voices
+      )
+    };
+  }
+});
+
+// src/generators/image-replicate.ts
+var PRICING = {
+  "nano-banana-pro": { costPerImage: 0.15, costTier: "high", baseCost: 0.15, creditCost: 10 },
+  "nano-banana-2": { costPerImage: 0.06, costTier: "medium", baseCost: 0.06, creditCost: 5 },
+  "nano-banana": { costPerImage: 0.04, costTier: "low", baseCost: 0.04, creditCost: 5 },
+  "flux-2-dev": { costPerImage: 0.03, costTier: "low", baseCost: 0.03, creditCost: 3 },
+  "flux-kontext-pro": { costPerImage: 0.04, costTier: "low", baseCost: 0.04, creditCost: 5 },
+  "flux-kontext-max": { costPerImage: 0.08, costTier: "medium", baseCost: 0.08, creditCost: 8 },
+  "flux-1.1-pro-ultra": { costPerImage: 0.06, costTier: "medium", baseCost: 0.06, creditCost: 8 },
+  "seedream-4": { costPerImage: 0.03, costTier: "low", baseCost: 0.03, creditCost: 3 },
+  "recraft-v3": { costPerImage: 0.04, costTier: "low", baseCost: 0.04, creditCost: 5 },
+  "image-01": { costPerImage: 0.02, costTier: "low", baseCost: 0.02, creditCost: 2 },
+  "gpt-image-1": { costPerImage: 0.04, costTier: "low", baseCost: 0.04, creditCost: 5 },
+  "ideogram-v3-turbo": { costPerImage: 0.03, costTier: "low", baseCost: 0.03, creditCost: 4 },
+  "flux-1.1-pro": { costPerImage: 0.04, costTier: "low", baseCost: 0.04, creditCost: 5 }
+};
+var AGENT_VISIBLE = /* @__PURE__ */ new Set([
+  "nano-banana-pro",
+  "nano-banana-2",
+  "nano-banana",
+  "flux-2-dev",
+  "flux-kontext-pro",
+  "flux-kontext-max",
+  "flux-1.1-pro-ultra",
+  "seedream-4",
+  "recraft-v3",
+  "image-01",
+  "gpt-image-1",
+  "ideogram-v3-turbo"
+]);
+var ASPECT_RATIOS_DEFAULT = {
+  supported: ["1:1", "9:16", "16:9", "2:3", "3:2", "3:4", "4:3"],
+  default: "1:1"
+};
+var ASPECT_RATIOS_WIDE = {
+  supported: ["1:1", "9:16", "16:9", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4"],
+  default: "1:1"
+};
+var ASPECT_RATIOS_ULTRA = {
+  supported: ["1:1", "9:16", "16:9", "21:9", "9:21", "3:4", "4:3"],
+  default: "1:1"
+};
+var ASPECT_RATIOS_NBPRO = {
+  supported: [
+    "1:1",
+    "9:16",
+    "16:9",
+    "2:3",
+    "3:2",
+    "3:4",
+    "4:3",
+    "4:5",
+    "5:4",
+    "21:9"
+  ],
+  default: "match_input_image"
+};
+var ASPECT_RATIOS_NB2 = {
+  supported: [
+    "1:1",
+    "9:16",
+    "16:9",
+    "2:3",
+    "3:2",
+    "3:4",
+    "4:3",
+    "4:5",
+    "5:4"
+  ],
+  default: "match_input_image"
+};
+var ASPECT_RATIOS_SQUARE = {
+  supported: ["1:1"],
+  default: "1:1"
+};
+var MODEL_SPECS = {
+  "nano-banana-pro": {
+    id: "nano-banana-pro",
+    name: "Nano Banana Pro",
+    capabilities: { generate: true, edit: true },
+    referenceImages: { supported: true, fieldName: "image_input", maxCount: 14, singular: false },
+    aspectRatio: ASPECT_RATIOS_NBPRO,
+    output: "string"
+  },
+  "nano-banana-2": {
+    id: "nano-banana-2",
+    name: "Nano Banana 2",
+    capabilities: { generate: true, edit: true },
+    referenceImages: { supported: true, fieldName: "image_input", maxCount: 4, singular: false },
+    aspectRatio: ASPECT_RATIOS_NB2,
+    output: "string"
+  },
+  "nano-banana": {
+    id: "nano-banana",
+    name: "Nano Banana",
+    capabilities: { generate: true, edit: true },
+    referenceImages: { supported: true, fieldName: "image_input", maxCount: 4, singular: false },
+    aspectRatio: ASPECT_RATIOS_DEFAULT,
+    output: "string"
+  },
+  "flux-2-dev": {
+    id: "flux-2-dev",
+    name: "Flux 2 Dev",
+    capabilities: { generate: true, edit: true },
+    referenceImages: { supported: true, fieldName: "input_images", maxCount: 5, singular: false },
+    aspectRatio: ASPECT_RATIOS_WIDE,
+    output: "string"
+  },
+  "flux-kontext-pro": {
+    id: "flux-kontext-pro",
+    name: "Flux Kontext Pro",
+    capabilities: { generate: true, edit: true },
+    referenceImages: { supported: true, fieldName: "input_image", maxCount: 1, singular: true },
+    aspectRatio: ASPECT_RATIOS_DEFAULT,
+    output: "string"
+  },
+  "flux-kontext-max": {
+    id: "flux-kontext-max",
+    name: "Flux Kontext Max",
+    capabilities: { generate: true, edit: true },
+    referenceImages: { supported: true, fieldName: "input_image", maxCount: 1, singular: true },
+    aspectRatio: ASPECT_RATIOS_DEFAULT,
+    output: "string"
+  },
+  "flux-1.1-pro-ultra": {
+    id: "flux-1.1-pro-ultra",
+    name: "Flux 1.1 Pro Ultra",
+    capabilities: { generate: true, edit: false },
+    referenceImages: { supported: false, fieldName: "none", maxCount: 0, singular: false },
+    aspectRatio: ASPECT_RATIOS_ULTRA,
+    output: "string"
+  },
+  "seedream-4": {
+    id: "seedream-4",
+    name: "SeedReam 4",
+    capabilities: { generate: true, edit: true },
+    referenceImages: { supported: true, fieldName: "image_input", maxCount: 10, singular: false },
+    aspectRatio: ASPECT_RATIOS_DEFAULT,
+    output: "string"
+  },
+  "recraft-v3": {
+    id: "recraft",
+    name: "Recraft V3",
+    capabilities: { generate: true, edit: false },
+    referenceImages: { supported: false, fieldName: "none", maxCount: 0, singular: false },
+    aspectRatio: ASPECT_RATIOS_SQUARE,
+    output: "string"
+  },
+  "image-01": {
+    id: "minimax",
+    name: "MiniMax Image",
+    capabilities: { generate: true, edit: false },
+    referenceImages: { supported: false, fieldName: "none", maxCount: 0, singular: false },
+    aspectRatio: { supported: ["1:1", "9:16", "16:9", "3:4", "4:3"], default: "1:1" },
+    output: "array"
+  },
+  "gpt-image-1": {
+    id: "gpt-image-1",
+    name: "OpenAI GPT Image 1",
+    capabilities: { generate: true, edit: true },
+    referenceImages: { supported: true, fieldName: "input_image", maxCount: 1, singular: true },
+    aspectRatio: { supported: ["1:1", "2:3", "3:2"], default: "1:1" },
+    output: "string"
+  },
+  "ideogram-v3-turbo": {
+    id: "ideogram-v3",
+    name: "Ideogram v3",
+    capabilities: { generate: true, edit: false },
+    referenceImages: { supported: false, fieldName: "none", maxCount: 0, singular: false },
+    aspectRatio: { supported: ["1:1", "9:16", "16:9", "2:3", "3:2"], default: "1:1" },
+    output: "string"
+  },
+  "flux-1.1-pro": {
+    id: "flux",
+    name: "Flux 1.1 Pro",
+    capabilities: { generate: true, edit: false },
+    referenceImages: { supported: false, fieldName: "none", maxCount: 0, singular: false },
+    aspectRatio: { supported: ["1:1", "9:16", "16:9"], default: "1:1" },
+    output: "string"
+  }
+};
+function mapModel(raw) {
+  const providerId = `${raw.owner}/${raw.name}`;
+  const spec = MODEL_SPECS[raw.name] ?? {
+    id: raw.name,
+    name: raw.name,
+    capabilities: { generate: true, edit: false },
+    referenceImages: { supported: false, fieldName: "none", maxCount: 0, singular: false },
+    aspectRatio: ASPECT_RATIOS_DEFAULT,
+    output: "string"
+  };
+  const pricing = PRICING[raw.name] ?? {
+    costPerImage: 0.03,
+    costTier: "low",
+    baseCost: 0.03,
+    creditCost: 3
+  };
+  return {
+    id: spec.id,
+    name: spec.name,
+    providerId,
+    provider: raw.owner === "openai" ? "openai" : raw.owner === "minimax" ? "minimax" : "replicate",
+    capabilities: spec.capabilities,
+    referenceImages: spec.referenceImages,
+    aspectRatio: spec.aspectRatio,
+    output: spec.output,
+    pricing: {
+      costPerImage: pricing.costPerImage,
+      costTier: pricing.costTier,
+      billingUnit: "per_image",
+      baseCost: pricing.baseCost,
+      ...pricing.creditCost !== void 0 ? { creditCost: pricing.creditCost } : {},
+      ...pricing.overrideCreditCost !== void 0 ? { overrideCreditCost: pricing.overrideCreditCost } : {}
+    },
+    description: raw.description,
+    agentVisible: AGENT_VISIBLE.has(raw.name),
+    ...spec.triggerWord ? { triggerWord: spec.triggerWord } : {}
+  };
+}
+var REPLICATE_SOURCE = {
+  id: "image-replicate",
+  url: "https://api.replicate.com/v1/models?query=image+generation"
+};
+var imageReplicate = defineGenerator({
+  name: "image:replicate",
+  modality: "image",
+  sources: [REPLICATE_SOURCE],
+  async generate(ctx) {
+    const data = await ctx.fetchSource(REPLICATE_SOURCE);
+    const entries = data.models.map(mapModel);
+    const lines = [
+      "// Generated by @agentproto/catalog-sync generator image:replicate",
+      "// DO NOT EDIT MANUALLY \u2014 regenerate with catalog-sync",
+      "",
+      'import type { ImageModelDefinition } from "@agentproto/model-catalog/image"',
+      "",
+      "export const REPLICATE_IMAGE_MODELS: Record<string, ImageModelDefinition> = {"
+    ];
+    for (const e of entries) {
+      const trigger = e.triggerWord ? `,
+    triggerWord: ${JSON.stringify(e.triggerWord)}` : "";
+      const creditCost = e.pricing.creditCost !== void 0 ? `,
+      creditCost: ${e.pricing.creditCost}` : "";
+      const override = e.pricing.overrideCreditCost !== void 0 ? `,
+      overrideCreditCost: ${e.pricing.overrideCreditCost}` : "";
+      lines.push(`  ${JSON.stringify(e.id)}: {`);
+      lines.push(`    id: ${JSON.stringify(e.id)},`);
+      lines.push(`    name: ${JSON.stringify(e.name)},`);
+      lines.push(`    providerId: ${JSON.stringify(e.providerId)},`);
+      lines.push(`    provider: ${JSON.stringify(e.provider)},`);
+      lines.push(`    capabilities: { generate: ${e.capabilities.generate}, edit: ${e.capabilities.edit}${e.capabilities.upscale ? `, upscale: ${e.capabilities.upscale}` : ""} },`);
+      lines.push(`    referenceImages: {`);
+      lines.push(`      supported: ${e.referenceImages.supported},`);
+      lines.push(`      fieldName: ${JSON.stringify(e.referenceImages.fieldName)},`);
+      lines.push(`      maxCount: ${e.referenceImages.maxCount},`);
+      lines.push(`      singular: ${e.referenceImages.singular},`);
+      lines.push(`    },`);
+      lines.push(`    aspectRatio: {`);
+      lines.push(`      supported: [${e.aspectRatio.supported.map((a) => JSON.stringify(a)).join(", ")}],`);
+      lines.push(`      default: ${JSON.stringify(e.aspectRatio.default)},`);
+      lines.push(`    },`);
+      lines.push(`    output: ${JSON.stringify(e.output)},`);
+      lines.push(`    pricing: {`);
+      lines.push(`      costPerImage: ${e.pricing.costPerImage},`);
+      lines.push(`      costTier: ${JSON.stringify(e.pricing.costTier)},`);
+      lines.push(`      billingUnit: ${JSON.stringify(e.pricing.billingUnit)},`);
+      lines.push(`      baseCost: ${e.pricing.baseCost},${creditCost}${override}`);
+      lines.push(`    },`);
+      lines.push(`    description: ${JSON.stringify(e.description)},`);
+      lines.push(`    agentVisible: ${e.agentVisible},${trigger}`);
+      lines.push(`  },`);
+    }
+    lines.push("}");
+    lines.push("");
+    const outputPath = "packages/catalog-sync/generated/image-replicate.generated.ts";
+    return { [outputPath]: lines.join("\n") };
+  }
+});
+
+export { defineGenerator, imageReplicate, llmOpenRouterGenerator, runGenerators, voiceElevenlabs, voiceMinimax };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map