@howells/motif-sdk 0.6.0 → 0.7.0

package/dist/image.js

@@ -0,0 +1,1525 @@
+// src/image/index.ts
+import { generateImage } from "ai";
+import { err as err2, ok as ok2 } from "neverthrow";
+
+// src/server.ts
+import { err, ok } from "neverthrow";
+
+// src/models.ts
+var AA_IMAGE_LEADERBOARD_SNAPSHOT = "2026-05-12";
+var AA_IMAGE_SOURCES = [
+  "https://artificialanalysis.ai/image/leaderboard/text-to-image",
+  "https://artificialanalysis.ai/image/leaderboard/editing"
+];
+var FAL_PRICING_CHECKED_AT = "2026-05-12";
+var FAL_PRICING_CHECKED_JUL_2026 = "2026-07-11";
+var MODELS = {
+  // ─── Generation Models ────────────────────────────────────────
+  gpt2: {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1249, pricePer1k: 211, rank: 3, winRate: 0.66 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1337, pricePer1k: 211, rank: 1, winRate: 0.8 }
+      },
+      speed: {
+        medianSeconds: 200.7,
+        p95Seconds: 232.6,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "ultra", quality: "frontier", speed: "very_slow" },
+      useCase: "Highest-ranked text-to-image quality and transparent PNGs"
+    },
+    editEndpoint: "openai/gpt-image-2/image-to-image",
+    endpoint: "openai/gpt-image-2",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "openai/gpt-image-2",
+      estimatedCostPerImageUsd: 0.211,
+      source: "fal-pricing-api",
+      unit: "units",
+      unitPrice: 1
+    },
+    maxReferenceImages: 4,
+    name: "GPT Image 2",
+    pricePerImageUsd: 0.211,
+    pricing: "$0.211",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsMaskImage: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsQuality: true,
+    supportsResolution: false,
+    supportsSyncMode: true,
+    type: "generation",
+    useQueue: true
+  },
+  gpt: {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1262, pricePer1k: 133, rank: 2, winRate: 0.69 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1268, pricePer1k: 133, rank: 2, winRate: 0.73 }
+      },
+      speed: {
+        medianSeconds: 34.6,
+        p95Seconds: 38.3,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "ultra", quality: "frontier", speed: "slow" },
+      useCase: "Best OpenAI edit quality with transparent PNG support"
+    },
+    editEndpoint: "fal-ai/gpt-image-1.5/edit",
+    endpoint: "fal-ai/gpt-image-1.5",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/gpt-image-1.5",
+      estimatedCostPerImageUsd: 0.133,
+      source: "fal-pricing-api",
+      unit: "units",
+      unitPrice: 1
+    },
+    maxReferenceImages: 4,
+    name: "GPT Image 1.5",
+    pricePerImageUsd: 0.133,
+    pricing: "$0.133",
+    sizeMode: "gpt_size",
+    supportsAspect: false,
+    supportsBackground: true,
+    supportsEdit: true,
+    supportsMaskImage: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsQuality: true,
+    supportsResolution: false,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  banana2: {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1231, pricePer1k: 67, rank: 5, winRate: 0.63 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1263, pricePer1k: 67, rank: 3, winRate: 0.71 }
+      },
+      tiers: { price: "premium", quality: "frontier", speed: "unknown" },
+      useCase: "Best balance of quality, edit support, web search, and cost"
+    },
+    editEndpoint: "fal-ai/nano-banana-2/edit",
+    endpoint: "fal-ai/nano-banana-2",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/nano-banana-2",
+      estimatedCostPerImageUsd: 0.08,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.08
+    },
+    maxReferenceImages: 4,
+    name: "Nano Banana 2",
+    pricePerImageUsd: 0.08,
+    pricing: "$0.08",
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsGoogleSearch: true,
+    supportsLimitGenerations: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    supportsThinkingLevel: true,
+    supportsWebSearch: true,
+    type: "generation"
+  },
+  banana: {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1241, pricePer1k: 134, rank: 4, winRate: 0.65 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1220, pricePer1k: 134, rank: 5, winRate: 0.66 }
+      },
+      speed: {
+        medianSeconds: 19.2,
+        p95Seconds: 30.3,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "ultra", quality: "frontier", speed: "balanced" },
+      useCase: "Premium Gemini image generation and multi-reference edits"
+    },
+    editEndpoint: "fal-ai/nano-banana-pro/edit",
+    endpoint: "fal-ai/nano-banana-pro",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/nano-banana-pro",
+      estimatedCostPerImageUsd: 0.15,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.15
+    },
+    maxReferenceImages: 14,
+    name: "Nano Banana Pro",
+    pricePerImageUsd: 0.15,
+    pricing: "$0.15",
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsGoogleSearch: true,
+    supportsLimitGenerations: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    supportsWebSearch: true,
+    type: "generation"
+  },
+  gemini: {
+    editEndpoint: "fal-ai/gemini-25-flash-image/edit",
+    endpoint: "fal-ai/gemini-25-flash-image",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/gemini-25-flash-image",
+      estimatedCostPerImageUsd: 0.0398,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.0398
+    },
+    maxReferenceImages: 4,
+    name: "Gemini 2.5 Flash",
+    pricePerImageUsd: 0.0398,
+    pricing: "$0.04",
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: false,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  gemini3: {
+    editEndpoint: "fal-ai/gemini-3-pro-image-preview/edit",
+    endpoint: "fal-ai/gemini-3-pro-image-preview",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/gemini-3-pro-image-preview",
+      estimatedCostPerImageUsd: 0.15,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.15
+    },
+    maxReferenceImages: 4,
+    name: "Gemini 3 Pro",
+    pricePerImageUsd: 0.15,
+    pricing: "$0.15",
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    supportsWebSearch: true,
+    type: "generation"
+  },
+  seedream4: {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1184, pricePer1k: 30, rank: 16, winRate: 0.61 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1198, pricePer1k: 30, rank: 6, winRate: 0.59 }
+      },
+      speed: {
+        medianSeconds: 14.3,
+        p95Seconds: 21,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "budget", quality: "best", speed: "balanced" },
+      useCase: "High-ranked budget generation and large multi-reference edits"
+    },
+    editEndpoint: "fal-ai/bytedance/seedream/v4/edit",
+    endpoint: "fal-ai/bytedance/seedream/v4/text-to-image",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/bytedance/seedream/v4/text-to-image",
+      estimatedCostPerImageUsd: 0.03,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.03
+    },
+    maxReferenceImages: 10,
+    name: "Seedream 4.0",
+    pricePerImageUsd: 0.03,
+    pricing: "$0.03",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsResolution: false,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  seedream45: {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1184, pricePer1k: 40, rank: 17, winRate: 0.58 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1167, pricePer1k: 40, rank: 17, winRate: 0.63 }
+      },
+      speed: {
+        medianSeconds: 18.2,
+        p95Seconds: 43.3,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "standard", quality: "better", speed: "balanced" },
+      useCase: "Cheap current Seedream model with good animation/art scores"
+    },
+    editEndpoint: "fal-ai/bytedance/seedream/v4.5/edit",
+    endpoint: "fal-ai/bytedance/seedream/v4.5/text-to-image",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/bytedance/seedream/v4.5/text-to-image",
+      estimatedCostPerImageUsd: 0.04,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.04
+    },
+    maxReferenceImages: 10,
+    name: "Seedream 4.5",
+    pricePerImageUsd: 0.04,
+    pricing: "$0.04",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsResolution: false,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  seedream5: {
+    name: "Seedream 5.0 Pro",
+    endpoint: "bytedance/seedream/v5/pro/text-to-image",
+    editEndpoint: "bytedance/seedream/v5/pro/edit",
+    type: "generation",
+    // fal tiers Seedream v5 Pro by output size: $0.0675 up to 1536², $0.135 up to 2048².
+    pricing: "$0.0675 (\u22641536\xB2) / $0.135 (\u22642048\xB2)",
+    pricePerImageUsd: 0.0675,
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_JUL_2026,
+      currency: "USD",
+      endpointId: "bytedance/seedream/v5/pro/text-to-image",
+      estimatedCostPerImageUsd: 0.0675,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.0675
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 10
+  },
+  "seedream5-lite": {
+    name: "Seedream 5.0 Lite",
+    endpoint: "fal-ai/bytedance/seedream/v5/lite/text-to-image",
+    editEndpoint: "fal-ai/bytedance/seedream/v5/lite/edit",
+    type: "generation",
+    // Flat price regardless of resolution; native up to Auto 3K (~9.4MP).
+    pricing: "$0.035",
+    pricePerImageUsd: 0.035,
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_JUL_2026,
+      currency: "USD",
+      endpointId: "fal-ai/bytedance/seedream/v5/lite/text-to-image",
+      estimatedCostPerImageUsd: 0.035,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.035
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 10
+  },
+  "flux2-max": {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1206, pricePer1k: 140, rank: 10, winRate: 0.6 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1197, pricePer1k: 70, rank: 8, winRate: 0.67 }
+      },
+      speed: {
+        medianSeconds: 31.6,
+        p95Seconds: 41,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "premium", quality: "best", speed: "slow" },
+      useCase: "Best FLUX quality and high-end editing"
+    },
+    editEndpoint: "fal-ai/flux-2-max/edit",
+    endpoint: "fal-ai/flux-2-max",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/flux-2-max",
+      estimatedCostPerImageUsd: 0.07,
+      source: "fal-pricing-api",
+      unit: "megapixels",
+      unitPrice: 0.07
+    },
+    maxReferenceImages: 10,
+    name: "FLUX.2 Max",
+    pricePerImageUsd: 0.07,
+    pricing: "$0.07/MP",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsNumImages: false,
+    supportsOutputFormat: true,
+    supportsResolution: false,
+    supportsSafetyChecker: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  "flux2-pro": {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1170, pricePer1k: 30, rank: 21 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1186, pricePer1k: 30, rank: 10, winRate: 0.62 }
+      },
+      speed: {
+        medianSeconds: 16.1,
+        p95Seconds: 23.9,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "budget", quality: "best", speed: "balanced" },
+      useCase: "Production FLUX quality at a low per-megapixel price"
+    },
+    editEndpoint: "fal-ai/flux-2-pro/edit",
+    endpoint: "fal-ai/flux-2-pro",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/flux-2-pro",
+      estimatedCostPerImageUsd: 0.03,
+      source: "fal-pricing-api",
+      unit: "processed megapixels",
+      unitPrice: 0.03
+    },
+    maxReferenceImages: 10,
+    name: "FLUX.2 Pro",
+    pricePerImageUsd: 0.03,
+    pricing: "$0.03/MP",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsNumImages: false,
+    supportsOutputFormat: true,
+    supportsResolution: false,
+    supportsSafetyChecker: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  "flux2-flex": {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1161, pricePer1k: 60, rank: 22 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1182, pricePer1k: 60, rank: 13, winRate: 0.61 }
+      },
+      speed: {
+        medianSeconds: 15.3,
+        p95Seconds: 22.2,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "standard", quality: "best", speed: "balanced" },
+      useCase: "FLUX quality with guidance and step controls"
+    },
+    editEndpoint: "fal-ai/flux-2-flex/edit",
+    endpoint: "fal-ai/flux-2-flex",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/flux-2-flex",
+      estimatedCostPerImageUsd: 0.05,
+      source: "fal-pricing-api",
+      unit: "processed megapixels",
+      unitPrice: 0.05
+    },
+    maxReferenceImages: 10,
+    name: "FLUX.2 Flex",
+    pricePerImageUsd: 0.05,
+    pricing: "$0.05/MP",
+    sizeMode: "image_size_enum",
+    supportedOutputFormats: ["jpeg", "png"],
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsGuidanceScale: true,
+    supportsInferenceSteps: true,
+    supportsNumImages: false,
+    supportsOutputFormat: true,
+    supportsResolution: false,
+    supportsSafetyChecker: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  "flux2-dev": {
+    benchmark: {
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1160, pricePer1k: 12, rank: 19, winRate: 0.57 }
+      },
+      speed: {
+        medianSeconds: 4.6,
+        p95Seconds: 69.6,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "variable", quality: "better", speed: "fast" },
+      useCase: "Open FLUX.2 quality with low average cost"
+    },
+    editEndpoint: "fal-ai/flux-2/edit",
+    endpoint: "fal-ai/flux-2",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/flux-2",
+      estimatedCostPerImageUsd: 0.012,
+      source: "fal-pricing-api",
+      unit: "compute seconds",
+      unitPrice: 167e-5
+    },
+    maxReferenceImages: 10,
+    name: "FLUX.2 [dev]",
+    pricePerImageUsd: 0.012,
+    pricing: "$0.00167/sec",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsGuidanceScale: true,
+    supportsInferenceSteps: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: false,
+    supportsSafetyChecker: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  "flux2-turbo": {
+    endpoint: "fal-ai/flux-2/turbo",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_JUL_2026,
+      currency: "USD",
+      endpointId: "fal-ai/flux-2/turbo",
+      estimatedCostPerImageUsd: 8e-3,
+      source: "fal-pricing-api",
+      unit: "megapixels",
+      unitPrice: 8e-3
+    },
+    name: "FLUX.2 Turbo",
+    pricePerImageUsd: 8e-3,
+    pricing: "$0.008/MP",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: false,
+    supportsGuidanceScale: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: false,
+    supportsSafetyChecker: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  flux: {
+    endpoint: "fal-ai/flux-pro/v1.1-ultra",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/flux-pro/v1.1-ultra",
+      estimatedCostPerImageUsd: 0.06,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.06
+    },
+    maxReferenceImages: 1,
+    name: "FLUX Pro Ultra",
+    pricePerImageUsd: 0.06,
+    pricing: "$0.06",
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsEnhancePrompt: true,
+    supportsImagePromptStrength: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsRaw: true,
+    supportsResolution: false,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  "flux-fast": {
+    endpoint: "fal-ai/flux/schnell",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/flux/schnell",
+      estimatedCostPerImageUsd: 3e-3,
+      source: "fal-pricing-api",
+      unit: "megapixels",
+      unitPrice: 3e-3
+    },
+    name: "FLUX Schnell",
+    pricePerImageUsd: 3e-3,
+    pricing: "$0.003",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: false,
+    supportsGuidanceScale: true,
+    supportsInferenceSteps: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: false,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  recraft: {
+    endpoint: "fal-ai/recraft-v3",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/recraft-v3",
+      estimatedCostPerImageUsd: 0.04,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.04
+    },
+    name: "Recraft V3",
+    pricePerImageUsd: 0.04,
+    pricing: "$0.04",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: false,
+    supportsNumImages: false,
+    supportsResolution: false,
+    supportsStyle: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  recraft4: {
+    endpoint: "fal-ai/recraft/v4/text-to-image",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_JUL_2026,
+      currency: "USD",
+      endpointId: "fal-ai/recraft/v4/text-to-image",
+      estimatedCostPerImageUsd: 0.04,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.04
+    },
+    name: "Recraft V4",
+    pricePerImageUsd: 0.04,
+    pricing: "$0.04",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: false,
+    supportsNumImages: false,
+    supportsResolution: false,
+    supportsStyle: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  ideogram: {
+    endpoint: "fal-ai/ideogram/v3",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/ideogram/v3",
+      estimatedCostPerImageUsd: 0.03,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.03
+    },
+    name: "Ideogram V3",
+    pricePerImageUsd: 0.03,
+    pricing: "$0.03",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: false,
+    supportsExpandPrompt: true,
+    supportsNegativePrompt: true,
+    supportsNumImages: true,
+    supportsRenderingSpeed: true,
+    supportsResolution: false,
+    supportsSeed: true,
+    supportsStyle: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  ideogram4: {
+    name: "Ideogram V4",
+    endpoint: "ideogram/v4",
+    type: "generation",
+    // fal bills v4 per output megapixel by rendering speed: TURBO $0.03, BALANCED
+    // $0.06, QUALITY $0.10 (plus a flat $0.03 when prompt expansion is used).
+    // Headline uses the TURBO 1MP rate, matching how ideogram v3 is modeled.
+    pricing: "$0.03",
+    pricePerImageUsd: 0.03,
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_JUL_2026,
+      currency: "USD",
+      endpointId: "ideogram/v4",
+      estimatedCostPerImageUsd: 0.03,
+      source: "fal-pricing-api",
+      unit: "megapixels",
+      unitPrice: 0.03
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: true,
+    supportsRenderingSpeed: true,
+    supportsSeed: true,
+    supportsOutputFormat: true,
+    supportedOutputFormats: ["jpeg", "png"],
+    supportsSafetyChecker: true,
+    supportsSyncMode: true
+  },
+  "grok-image": {
+    benchmark: {
+      artificialAnalysis: {
+        editing: { elo: 1213, pricePer1k: 20, rank: 7, winRate: 0.6 },
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1182, pricePer1k: 20, rank: 12, winRate: 0.6 }
+      },
+      speed: {
+        medianSeconds: 5.1,
+        p95Seconds: 6.5,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "budget", quality: "best", speed: "fast" },
+      useCase: "Very fast, cheap generation and edits"
+    },
+    editEndpoint: "xai/grok-imagine-image/edit",
+    endpoint: "xai/grok-imagine-image",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "xai/grok-imagine-image",
+      estimatedCostPerImageUsd: 0.02,
+      source: "fal-pricing-api",
+      unit: "images",
+      unitPrice: 0.02
+    },
+    maxReferenceImages: 4,
+    name: "Grok Imagine Image",
+    pricePerImageUsd: 0.02,
+    pricing: "$0.02",
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  qwen: {
+    benchmark: {
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { elo: 1158, pricePer1k: 20, rank: 20, winRate: 0.6 }
+      },
+      speed: {
+        medianSeconds: 23.3,
+        p95Seconds: 491,
+        source: "artificial-analysis-models"
+      },
+      tiers: { price: "budget", quality: "better", speed: "slow" },
+      useCase: "Low-cost open-weight text and design generation"
+    },
+    endpoint: "fal-ai/qwen-image",
+    falPricing: {
+      checkedAt: FAL_PRICING_CHECKED_AT,
+      currency: "USD",
+      endpointId: "fal-ai/qwen-image",
+      estimatedCostPerImageUsd: 0.02,
+      source: "fal-pricing-api",
+      unit: "megapixels",
+      unitPrice: 0.02
+    },
+    name: "Qwen Image",
+    pricePerImageUsd: 0.02,
+    pricing: "$0.02/MP",
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsEdit: false,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsResolution: false,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    type: "generation"
+  },
+  // ─── Video Models ─────────────────────────────────────────────
+  kling: {
+    endpoint: "fal-ai/kling-video/v3/pro/image-to-video",
+    name: "Kling v3 Pro",
+    pricing: "$0.11/sec",
+    sizeMode: "none",
+    supportsAspect: false,
+    supportsEdit: false,
+    supportsNumImages: false,
+    supportsResolution: false,
+    type: "video"
+  },
+  // ─── Utility Models ───────────────────────────────────────────
+  clarity: {
+    endpoint: "fal-ai/clarity-upscaler",
+    name: "Clarity Upscaler",
+    pricing: "$0.03/MP",
+    supportsAspect: false,
+    supportsEdit: false,
+    supportsNumImages: false,
+    supportsResolution: false,
+    type: "utility"
+  },
+  crystal: {
+    endpoint: "clarityai/crystal-upscaler",
+    name: "Crystal Upscaler",
+    pricing: "$0.02",
+    supportsAspect: false,
+    supportsEdit: false,
+    supportsNumImages: false,
+    supportsResolution: false,
+    type: "utility"
+  },
+  rmbg: {
+    endpoint: "fal-ai/birefnet",
+    name: "BiRefNet (Background Removal)",
+    pricing: "$0.02",
+    supportsAspect: false,
+    supportsEdit: false,
+    supportsNumImages: false,
+    supportsResolution: false,
+    type: "utility"
+  },
+  bria: {
+    endpoint: "fal-ai/bria/background/remove",
+    name: "Bria RMBG 2.0",
+    pricing: "$0.02",
+    supportsAspect: false,
+    supportsEdit: false,
+    supportsNumImages: false,
+    supportsResolution: false,
+    type: "utility"
+  }
+};
+var GENERATION_MODELS = [
+  "gpt2",
+  "gpt",
+  "banana2",
+  "banana",
+  "gemini",
+  "gemini3",
+  "seedream4",
+  "seedream45",
+  "seedream5",
+  "seedream5-lite",
+  "flux2-max",
+  "flux2-pro",
+  "flux2-flex",
+  "flux2-dev",
+  "flux2-turbo",
+  "flux",
+  "flux-fast",
+  "recraft",
+  "recraft4",
+  "ideogram",
+  "ideogram4",
+  "grok-image",
+  "qwen"
+];
+var EDIT_CAPABLE_MODELS = GENERATION_MODELS.filter(
+  (id) => MODELS[id]?.supportsEdit === true
+);
+
+// src/tools.ts
+var FAL_TOOLS = {
+  birefnet: {
+    category: "background",
+    defaultOptions: {
+      model: "General Use (Light)",
+      operating_resolution: "1024x1024",
+      output_format: "png",
+      refine_foreground: true
+    },
+    description: "High-resolution dichotomous image segmentation and background removal.",
+    endpoint: "fal-ai/birefnet/v2",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "BirefNet Background Removal",
+    outputKeys: ["image", "mask_image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/birefnet/v2",
+    task: "image background removal"
+  },
+  "bria-rmbg": {
+    category: "background",
+    description: "Commercial-safe background removal for images.",
+    endpoint: "fal-ai/bria/background/remove",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "Bria RMBG 2.0",
+    outputKeys: ["image"],
+    pricing: "$0.02/image",
+    sourceUrl: "https://fal.ai/models/fal-ai/bria/background/remove",
+    task: "image background removal"
+  },
+  "bria-video-rmbg": {
+    category: "background",
+    defaultOptions: {
+      background_color: "Black",
+      output_container_and_codec: "webm_vp9",
+      preserve_audio: true
+    },
+    description: "Remove video backgrounds with configurable output container.",
+    endpoint: "bria/video/background-removal",
+    inputField: "video_url",
+    inputKind: "video",
+    name: "Bria Video Background Removal",
+    outputKeys: ["video"],
+    pricing: "$0.14/sec",
+    sourceUrl: "https://fal.ai/models/bria/video/background-removal",
+    task: "video background removal"
+  },
+  "depth-anything": {
+    category: "preprocess",
+    description: "Generate Depth Anything v2 depth maps from input images.",
+    endpoint: "fal-ai/image-preprocessors/depth-anything/v2",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "Depth Anything v2 Preprocessor",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/image-preprocessors/depth-anything/v2",
+    task: "depth preprocessing"
+  },
+  lineart: {
+    category: "preprocess",
+    defaultOptions: {
+      coarse: false
+    },
+    description: "Generate line art/control-style edges from an input image.",
+    endpoint: "fal-ai/image-preprocessors/lineart",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "Line Art Preprocessor",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/image-preprocessors/lineart",
+    task: "image preprocessing"
+  },
+  "marigold-depth": {
+    category: "depth",
+    defaultOptions: {
+      ensemble_size: 10,
+      num_inference_steps: 10
+    },
+    description: "Create depth maps using Marigold depth estimation.",
+    endpoint: "fal-ai/imageutils/marigold-depth",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "Marigold Depth Estimation",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/imageutils/marigold-depth",
+    task: "depth map"
+  },
+  "midas-depth": {
+    category: "depth",
+    defaultOptions: {
+      a: Math.PI * 2,
+      bg_th: 0.1
+    },
+    description: "Create MiDaS depth maps from input images.",
+    endpoint: "fal-ai/imageutils/depth",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "MiDaS Depth Estimation",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/imageutils/depth",
+    task: "depth map"
+  },
+  "midas-preprocessor": {
+    category: "preprocess",
+    description: "Generate MiDaS depth and normal maps for image workflows.",
+    endpoint: "fal-ai/image-preprocessors/midas",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "MiDaS Preprocessor",
+    outputKeys: ["depth_map", "normal_map"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/image-preprocessors/midas",
+    task: "depth and normal preprocessing"
+  },
+  nsfw: {
+    category: "moderation",
+    description: "Predict whether one or more images contain NSFW concepts.",
+    endpoint: "fal-ai/x-ailab/nsfw",
+    inputField: "image_urls",
+    inputKind: "images",
+    name: "NSFW Checker",
+    outputKeys: ["has_nsfw_concepts"],
+    pricing: "$0.001/image",
+    sourceUrl: "https://fal.ai/models/fal-ai/x-ailab/nsfw",
+    task: "vision moderation"
+  },
+  rembg: {
+    category: "background",
+    defaultOptions: {
+      crop_to_bbox: false
+    },
+    description: "Generic image background removal utility.",
+    endpoint: "fal-ai/imageutils/rembg",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "Remove Background",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/imageutils/rembg",
+    task: "image background removal"
+  },
+  "sam-preprocessor": {
+    category: "preprocess",
+    description: "Generate a SAM segmentation map for ControlNet-style workflows.",
+    endpoint: "fal-ai/image-preprocessors/sam",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "SAM Preprocessor",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/image-preprocessors/sam",
+    task: "segmentation preprocessing"
+  },
+  "sam2-auto": {
+    category: "segmentation",
+    defaultOptions: {
+      min_mask_region_area: 100,
+      output_format: "png",
+      points_per_side: 32,
+      pred_iou_thresh: 0.88,
+      stability_score_thresh: 0.95
+    },
+    description: "Automatically segment an image into combined and individual masks.",
+    endpoint: "fal-ai/sam2/auto-segment",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "SAM 2 Auto Segment",
+    outputKeys: ["combined_mask", "individual_masks"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam2/auto-segment",
+    task: "automatic image segmentation"
+  },
+  "sam3-1-image": {
+    category: "segmentation",
+    defaultOptions: {
+      apply_mask: true,
+      max_masks: 3,
+      output_format: "png"
+    },
+    description: "Segment image objects with text, point, or box prompts. SAM 3.1 adds Object Multiplex for faster multi-object tracking.",
+    endpoint: "fal-ai/sam-3-1/image",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "SAM 3.1 Image",
+    outputKeys: ["image", "masks", "metadata", "scores", "boxes"],
+    pricing: "$0.005/request",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3-1/image",
+    task: "promptable image segmentation"
+  },
+  "sam3-1-video": {
+    category: "segmentation",
+    defaultOptions: {
+      apply_mask: true,
+      prompt: "person"
+    },
+    description: "SAM 3.1 video segmentation with Object Multiplex tracking for multiple objects.",
+    endpoint: "fal-ai/sam-3-1/video",
+    inputField: "video_url",
+    inputKind: "video",
+    name: "SAM 3.1 Video",
+    outputKeys: ["video", "boundingbox_frames_zip"],
+    pricing: "fal pricing varies by frame count",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3-1/video",
+    task: "multi-object video segmentation"
+  },
+  "sam3-3d-align": {
+    category: "3d",
+    description: "Align SAM 3D objects and bodies into a shared scene.",
+    endpoint: "fal-ai/sam-3/3d-align",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "SAM 3D Align",
+    outputKeys: ["scene_glb", "metadata", "artifacts_zip"],
+    pricing: "fal pricing varies by scene",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/3d-align",
+    task: "3D scene alignment"
+  },
+  "sam3-3d-body": {
+    category: "3d",
+    defaultOptions: {
+      export_meshes: true,
+      include_3d_keypoints: true,
+      include_mhr_params: true
+    },
+    description: "Reconstruct human body meshes and keypoints from a single image.",
+    endpoint: "fal-ai/sam-3/3d-body",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "SAM 3D Body",
+    outputKeys: ["model_glb", "visualization", "meshes", "metadata"],
+    pricing: "$0.015/inference",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/3d-body",
+    task: "single-image 3D body reconstruction"
+  },
+  "sam3-3d-objects": {
+    category: "3d",
+    defaultOptions: {
+      prompt: "car"
+    },
+    description: "Reconstruct one or more 3D objects from an image and prompts.",
+    endpoint: "fal-ai/sam-3/3d-objects",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "SAM 3D Objects",
+    outputKeys: [
+      "gaussian_splat",
+      "model_glb",
+      "metadata",
+      "individual_splats",
+      "individual_glbs",
+      "artifacts_zip"
+    ],
+    pricing: "$0.02/generation",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/3d-objects",
+    task: "single-image 3D object reconstruction"
+  },
+  "sam3-image": {
+    category: "segmentation",
+    defaultOptions: {
+      apply_mask: true,
+      max_masks: 3,
+      output_format: "png"
+    },
+    description: "Segment image objects with text, point, or box prompts.",
+    endpoint: "fal-ai/sam-3/image",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "SAM 3 Image",
+    outputKeys: ["image", "masks", "metadata", "scores", "boxes"],
+    pricing: "$0.005/request",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/image",
+    task: "promptable image segmentation"
+  },
+  "sam3-image-rle": {
+    category: "segmentation",
+    defaultOptions: {
+      apply_mask: true,
+      max_masks: 3
+    },
+    description: "Segment image objects and return run-length encoded masks.",
+    endpoint: "fal-ai/sam-3/image-rle",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "SAM 3 Image RLE",
+    outputKeys: ["rle_masks", "metadata", "scores", "boxes"],
+    pricing: "$0.005/request",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/image-rle",
+    task: "promptable image segmentation to RLE"
+  },
+  "sam3-video": {
+    category: "segmentation",
+    defaultOptions: {
+      apply_mask: true,
+      detection_threshold: 0.5,
+      prompt: "person",
+      video_output_type: "X264 (.mp4)"
+    },
+    description: "Segment and track prompted objects across video frames.",
+    endpoint: "fal-ai/sam-3/video",
+    inputField: "video_url",
+    inputKind: "video",
+    name: "SAM 3 Video",
+    outputKeys: ["video", "boundingbox_frames_zip"],
+    pricing: "$0.005/16 frames",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/video",
+    task: "promptable video segmentation"
+  },
+  "sam3-video-rle": {
+    category: "segmentation",
+    defaultOptions: {
+      apply_mask: true,
+      detection_threshold: 0.5,
+      prompt: "person"
+    },
+    description: "Track prompted video objects and return RLE mask data.",
+    endpoint: "fal-ai/sam-3/video-rle",
+    inputField: "video_url",
+    inputKind: "video",
+    name: "SAM 3 Video RLE",
+    outputKeys: ["rle_masks", "metadata"],
+    pricing: "$0.005/16 frames",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/video-rle",
+    task: "promptable video segmentation to RLE"
+  },
+  "topaz-image": {
+    category: "upscale",
+    defaultOptions: {
+      model: "Standard V2",
+      output_format: "jpeg",
+      upscale_factor: 2
+    },
+    description: "Professional Topaz image enhancement and upscaling.",
+    endpoint: "fal-ai/topaz/upscale/image",
+    inputField: "image_url",
+    inputKind: "image",
+    name: "Topaz Image Upscale",
+    outputKeys: ["image"],
+    pricing: "$0.08+ by output megapixels",
+    sourceUrl: "https://fal.ai/models/fal-ai/topaz/upscale/image",
+    task: "image enhancement"
+  },
+  "topaz-video": {
+    category: "upscale",
+    defaultOptions: {
+      model: "Proteus",
+      upscale_factor: 2
+    },
+    description: "Professional Topaz video enhancement and upscaling.",
+    endpoint: "fal-ai/topaz/upscale/video",
+    inputField: "video_url",
+    inputKind: "video",
+    name: "Topaz Video Upscale",
+    outputKeys: ["video"],
+    pricing: "$0.01-$0.08/sec by output resolution",
+    sourceUrl: "https://fal.ai/models/fal-ai/topaz/upscale/video",
+    task: "video enhancement"
+  }
+};
+var FAL_TOOL_IDS = Object.keys(
+  FAL_TOOLS
+);
+
+// src/server.ts
+var MotifError = class extends Error {
+  status;
+  code;
+  /** fal's request-correlation id (from the `x-fal-request-id` header or the
+   * error body). Ties a failure back to fal's dashboard/support. */
+  requestId;
+  constructor(message, status, code, requestId) {
+    super(message);
+    this.name = "MotifError";
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+  }
+};
+
+// src/image/cost.ts
+var GOOGLE_IMAGE_PRICE_USD = {
+  "gemini-2.5-flash-image": 0.039,
+  "gemini-3.1-flash-image-preview": 0.039,
+  "gemini-3-pro-image-preview": 0.134
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function costFromProviderMetadata(providerMetadata) {
+  if (!isRecord2(providerMetadata)) {
+    return void 0;
+  }
+  for (const value of Object.values(providerMetadata)) {
+    if (isRecord2(value)) {
+      const cost = value.cost;
+      if (typeof cost === "number" && Number.isFinite(cost)) {
+        return cost;
+      }
+    }
+  }
+  return void 0;
+}
+function tablePricePerImage(provider, modelId) {
+  if (provider === "google") {
+    return GOOGLE_IMAGE_PRICE_USD[modelId];
+  }
+  return void 0;
+}
+function roundUsd(value) {
+  return Number(value.toFixed(6));
+}
+function costForImages(provider, modelId, providerMetadata, imageCount) {
+  const metaCost = costFromProviderMetadata(providerMetadata);
+  if (metaCost !== void 0) {
+    return { usd: roundUsd(metaCost), source: "provider-metadata" };
+  }
+  const perImage = tablePricePerImage(provider, modelId);
+  if (perImage !== void 0) {
+    return {
+      usd: roundUsd(perImage * Math.max(imageCount, 1)),
+      source: "table"
+    };
+  }
+  return { usd: 0, source: "unknown" };
+}
+
+// src/image/google.ts
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+var GOOGLE_TIER_MODELS = {
+  fast: "gemini-2.5-flash-image",
+  balanced: "gemini-3.1-flash-image-preview",
+  quality: "gemini-3-pro-image-preview",
+  hero: "gemini-3-pro-image-preview"
+};
+var GOOGLE_API_KEY_ENV = "GOOGLE_GENERATIVE_AI_API_KEY";
+function googleModelForTier(tier) {
+  return GOOGLE_TIER_MODELS[tier];
+}
+function resolveModel(modelId, apiKey) {
+  const key = apiKey ?? process.env[GOOGLE_API_KEY_ENV];
+  if (key === void 0 || key === "") {
+    throw new MotifError(
+      `Google image generation requires an API key (config.google.apiKey or ${GOOGLE_API_KEY_ENV})`,
+      0
+    );
+  }
+  return createGoogleGenerativeAI({ apiKey: key }).image(modelId);
+}
+
+// src/image/index.ts
+var DEFAULT_TIER = "balanced";
+var DEFAULT_PROVIDER = "google";
+function createMotifImage(config = {}, deps = {}) {
+  const generateImageFn = deps.generateImage ?? generateImage;
+  const resolveModelFn = deps.resolveModel ?? defaultResolveModel;
+  function resolveProvider(provider) {
+    return provider ?? config.defaultProvider ?? DEFAULT_PROVIDER;
+  }
+  function apiKeyFor(provider) {
+    if (provider === "google") {
+      return config.google?.apiKey;
+    }
+    return void 0;
+  }
+  async function generate(opts) {
+    const provider = resolveProvider(opts.provider);
+    try {
+      const modelId = resolveModelId(provider, opts.model, opts.tier);
+      const model = resolveModelFn(provider, modelId, apiKeyFor(provider));
+      const result = await generateImageFn({
+        model,
+        prompt: opts.prompt,
+        ...opts.n === void 0 ? {} : { n: opts.n },
+        ...opts.size === void 0 ? {} : { size: opts.size },
+        ...opts.aspectRatio === void 0 ? {} : { aspectRatio: opts.aspectRatio },
+        ...opts.providerOptions === void 0 ? {} : { providerOptions: toProviderOptions(opts.providerOptions) }
+      });
+      return ok2(toMotifImageResult(result, provider, modelId));
+    } catch (error) {
+      return err2(toMotifError(error));
+    }
+  }
+  async function edit(opts) {
+    const provider = resolveProvider(opts.provider);
+    try {
+      const modelId = resolveModelId(provider, opts.model, opts.tier);
+      const model = resolveModelFn(provider, modelId, apiKeyFor(provider));
+      const result = await generateImageFn({
+        model,
+        prompt: {
+          images: opts.images,
+          text: opts.instruction,
+          ...opts.mask === void 0 ? {} : { mask: opts.mask }
+        },
+        ...opts.n === void 0 ? {} : { n: opts.n },
+        ...opts.providerOptions === void 0 ? {} : { providerOptions: toProviderOptions(opts.providerOptions) }
+      });
+      return ok2(toMotifImageResult(result, provider, modelId));
+    } catch (error) {
+      return err2(toMotifError(error));
+    }
+  }
+  return { generate, edit };
+}
+function defaultResolveModel(provider, modelId, apiKey) {
+  if (provider === "google") {
+    return resolveModel(modelId, apiKey);
+  }
+  throw new MotifError(`Unsupported image provider: ${provider}`, 0);
+}
+function resolveModelId(provider, model, tier) {
+  if (model !== void 0 && model !== "") {
+    return model;
+  }
+  const resolvedTier = tier ?? DEFAULT_TIER;
+  if (provider === "google") {
+    return googleModelForTier(resolvedTier);
+  }
+  throw new MotifError(`Unsupported image provider: ${provider}`, 0);
+}
+function toMotifImageResult(result, provider, model) {
+  const images = result.images.map((file) => ({
+    uint8Array: file.uint8Array,
+    base64: file.base64,
+    mediaType: file.mediaType
+  }));
+  const cost = costForImages(
+    provider,
+    model,
+    result.providerMetadata,
+    images.length
+  );
+  const requestId = extractRequestId(result);
+  return {
+    images,
+    cost,
+    provider,
+    model,
+    ...requestId === void 0 ? {} : { requestId }
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractRequestId(result) {
+  const fromMetadata = requestIdFromMetadata(result.providerMetadata);
+  if (fromMetadata !== void 0) {
+    return fromMetadata;
+  }
+  for (const response of result.responses) {
+    const { headers } = response;
+    if (headers) {
+      const id = headers["x-request-id"] ?? headers["x-goog-request-id"] ?? headers["x-fal-request-id"];
+      if (typeof id === "string" && id !== "") {
+        return id;
+      }
+    }
+  }
+  return void 0;
+}
+function requestIdFromMetadata(providerMetadata) {
+  if (!isRecord3(providerMetadata)) {
+    return void 0;
+  }
+  for (const value of Object.values(providerMetadata)) {
+    if (isRecord3(value)) {
+      const id = value.requestId ?? value.request_id;
+      if (typeof id === "string" && id !== "") {
+        return id;
+      }
+    }
+  }
+  return void 0;
+}
+function toProviderOptions(input) {
+  const out = {};
+  for (const [namespace, options] of Object.entries(input)) {
+    const inner = {};
+    for (const [key, value] of Object.entries(options)) {
+      inner[key] = toJsonValue(value);
+    }
+    out[namespace] = inner;
+  }
+  return out;
+}
+function toJsonValue(value) {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "object") {
+    if (Array.isArray(value)) {
+      const arr = [];
+      for (const item of value) {
+        arr.push(toJsonValue(item));
+      }
+      return arr;
+    }
+    const obj = {};
+    for (const [key, entry] of Object.entries(value)) {
+      obj[key] = toJsonValue(entry);
+    }
+    return obj;
+  }
+  return null;
+}
+function toMotifError(error) {
+  if (error instanceof MotifError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+  return new MotifError(message, 0, code);
+}
+export {
+  GOOGLE_API_KEY_ENV,
+  GOOGLE_TIER_MODELS,
+  costForImages,
+  costFromProviderMetadata,
+  createMotifImage
+};