@telepat/rilo 0.1.6 → 0.1.8

package/src/config/models.js

@@ -1,17 +1,17 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import {
+  getLimnGenerationModels,
+  isKnownLimnFamily,
+  resolveFamilyFromReplicateModelId
+} from '../images/limnModelCatalog.js';
 
 const CONFIG_DIR = path.dirname(fileURLToPath(import.meta.url));
 const MODELS_DIR = path.resolve(CONFIG_DIR, '../../models');
 
 export const MODELS = {
   deepseek: 'deepseek-ai/deepseek-v3',
-  keyframe: 'prunaai/z-image-turbo',
-  flux: 'black-forest-labs/flux-2-pro',
-  fluxSchnell: 'black-forest-labs/flux-schnell',
-  nanoBananaPro: 'google/nano-banana-pro',
-  seedream4: 'bytedance/seedream-4',
   video: 'wan-video/wan-2.2-i2v-fast',
   klingVideo3: 'kwaivgi/kling-v3-video',
   pixverseV56: 'pixverse/pixverse-v5.6',
@@ -32,7 +32,7 @@ export const MODEL_CATEGORIES = {
 export const DEFAULT_MODEL_SELECTIONS = {
   [MODEL_CATEGORIES.textToText]: MODELS.deepseek,
   [MODEL_CATEGORIES.textToSpeech]: MODELS.tts,
-  [MODEL_CATEGORIES.textToImage]: MODELS.keyframe,
+  [MODEL_CATEGORIES.textToImage]: 'z-image',
   [MODEL_CATEGORIES.imageTextToVideo]: MODELS.video
 };
 
@@ -41,11 +41,6 @@ export const MODEL_OPTION_KEYS = [...MODEL_SELECTION_KEYS];
 
 const MODEL_METADATA_FILES = {
   [MODELS.deepseek]: 'deepseek-ai__deepseek-v3.json',
-  [MODELS.keyframe]: 'prunaai__z-image-turbo.json',
-  [MODELS.flux]: 'black-forest-labs__flux-2-pro.json',
-  [MODELS.fluxSchnell]: 'black-forest-labs__flux-schnell.json',
-  [MODELS.nanoBananaPro]: 'google__nano-banana-pro.json',
-  [MODELS.seedream4]: 'bytedance__seedream-4.json',
   [MODELS.video]: 'wan-video__wan-2.2-i2v-fast.json',
   [MODELS.klingVideo3]: 'kwaivgi__kling-v3-video.json',
   [MODELS.pixverseV56]: 'pixverse__pixverse-v5.6.json',
@@ -59,10 +54,13 @@ const MODEL_METADATA_FILES = {
 export const MODEL_IDS_BY_CATEGORY = {
   [MODEL_CATEGORIES.textToText]: [MODELS.deepseek],
   [MODEL_CATEGORIES.textToSpeech]: [MODELS.tts, MODELS.chatterboxTurbo, MODELS.kokoro82m],
-  [MODEL_CATEGORIES.textToImage]: [MODELS.keyframe, MODELS.flux, MODELS.fluxSchnell, MODELS.nanoBananaPro, MODELS.seedream4],
   [MODEL_CATEGORIES.imageTextToVideo]: [MODELS.video, MODELS.klingVideo3, MODELS.pixverseV56, MODELS.veo31, MODELS.veo31Fast]
 };
 
+export function getTextToImageModelIds() {
+  return getLimnGenerationModels().map((model) => model.family);
+}
+
 export function toNullableNumber(value) {
   if (value === null || value === undefined || value === '') {
     return null;
@@ -109,7 +107,14 @@ export const MODEL_METADATA = Object.fromEntries(
   Object.values(MODELS).map((modelId) => [modelId, readModelMetadata(modelId)])
 );
 
-export const SUPPORTED_MODEL_IDS = Object.keys(MODEL_METADATA);
+export const SUPPORTED_MODEL_IDS = [
+  ...Object.keys(MODEL_METADATA),
+  ...getTextToImageModelIds(),
+  ...getTextToImageModelIds().flatMap((family) => {
+    const match = getLimnGenerationModels().find((m) => m.family === family);
+    return match ? match.replicateModelIds : [];
+  })
+];
 
 export const MODEL_PRICING = Object.fromEntries(
   Object.entries(MODEL_METADATA).map(([modelId, metadata]) => [modelId, normalizePricing(metadata.pricing || {})])
@@ -181,6 +186,9 @@ export function resolveProjectModelOptions(modelOptions = {}, modelSelections =
 }
 
 export function isKnownModelId(modelId) {
+  if (typeof modelId === 'string' && isKnownLimnFamily(modelId)) {
+    return true;
+  }
   return typeof modelId === 'string' && SUPPORTED_MODEL_IDS.includes(modelId);
 }
 
@@ -198,10 +206,22 @@ export function resolveProjectModelSelections(modelSelections = {}) {
   for (const key of MODEL_SELECTION_KEYS) {
     const candidate = modelSelections[key];
     if (typeof candidate === 'string' && candidate.trim()) {
-      resolved[key] = candidate.trim();
+      const trimmed = candidate.trim();
+      // Normalize old Replicate T2I IDs to Limn family names
+      if (key === MODEL_CATEGORIES.textToImage) {
+        const family = resolveFamilyFromReplicateModelId(trimmed);
+        resolved[key] = family ?? trimmed;
+      } else {
+        resolved[key] = trimmed;
+      }
     }
   }
 
+  // Preserve textToImageReplicateModel if present
+  if (typeof modelSelections.textToImageReplicateModel === 'string' && modelSelections.textToImageReplicateModel.trim()) {
+    resolved.textToImageReplicateModel = modelSelections.textToImageReplicateModel.trim();
+  }
+
   return resolved;
 }
 
@@ -217,6 +237,10 @@ export function getSupportedModelIdsForCategory(category) {
     throw new Error(`Unknown model category: ${category}`);
   }
 
+  if (category === MODEL_CATEGORIES.textToImage) {
+    return getTextToImageModelIds();
+  }
+
   return [...(MODEL_IDS_BY_CATEGORY[category] || [])];
 }
 

package/src/config/settingsSchema.js

@@ -22,7 +22,16 @@ export const SETTINGS = [
     description: 'Your Replicate API key (replicate.com/account/api-tokens).',
     type: 'secure',
     keystoreKey: 'replicateApiToken',
-    envNames: ['RILO_REPLICATE_API_TOKEN', 'REPLICATE_API_TOKEN'],
+    envNames: ['TELEPAT_REPLICATE_TOKEN'],
+    default: ''
+  },
+  {
+    id: 'openRouterApiKey',
+    label: 'OpenRouter API Key',
+    description: 'Your OpenRouter API key for LLM-driven prompt transformation (openrouter.ai/keys).',
+    type: 'secure',
+    keystoreKey: 'openRouterApiKey',
+    envNames: ['TELEPAT_OPENROUTER_KEY'],
     default: ''
   },
   {

package/src/images/limnModelCatalog.js

@@ -0,0 +1,39 @@
+import { getSupportedModelCatalog } from '@telepat/limn';
+
+export function getLimnGenerationModels() {
+  return getSupportedModelCatalog().filter((entry) => entry.generationEnabled);
+}
+
+export const DEFAULT_LIMN_MODEL_ID = 'z-image';
+
+export function resolveFamilyFromReplicateModelId(replicateModelId) {
+  const match = getLimnGenerationModels().find((model) =>
+    model.replicateModelIds.includes(replicateModelId)
+  );
+  return match?.family ?? null;
+}
+
+export function isKnownLimnFamily(family) {
+  return getLimnGenerationModels().some((model) => model.family === family);
+}
+
+export function isReplicateModelIdForFamily(family, replicateModelId) {
+  const match = getLimnGenerationModels().find((model) => model.family === family);
+  if (!match) {
+    return false;
+  }
+  return match.replicateModelIds.includes(replicateModelId);
+}
+
+export function getLimnReplicateModelsForFamily(family) {
+  const match = getLimnGenerationModels().find((model) => model.family === family);
+  if (!match) {
+    return [];
+  }
+  return [...match.replicateModelIds];
+}
+
+export function getLimnDefaultReplicateModel(family) {
+  const match = getLimnGenerationModels().find((model) => model.family === family);
+  return match?.defaultReplicateModelId ?? null;
+}

package/src/pipeline/orchestrator.js

@@ -28,17 +28,21 @@ import {
 import {
   DEFAULT_VIDEO_CONFIG,
   MODEL_CATEGORIES,
+  MODEL_SELECTION_KEYS,
   resolveKeyframeSize,
   resolveProjectModelOptions,
   resolveProjectModelSelections,
   resolveShotCount,
   resolveTargetDurationSec
 } from '../config/models.js';
+import { Limn } from '@telepat/limn';
+import { resolveFamilyFromReplicateModelId } from '../images/limnModelCatalog.js';
 import fs from 'node:fs/promises';
 import crypto from 'node:crypto';
 import path from 'node:path';
 import { ensureDir, writeJson } from '../media/files.js';
 import { probeMediaDurationSeconds } from '../media/ffmpeg.js';
+import { env } from '../config/env.js';
 import {
   ensureProject,
   readProjectConfig,
@@ -229,6 +233,15 @@ export async function regenerateProjectAsset(projectName, target, options = {})
   const projectConfig = await deps.readProjectConfig(project);
   const modelSelections = resolveProjectModelSelections(projectConfig.models);
   const modelOptions = resolveProjectModelOptions(projectConfig.modelOptions, modelSelections);
+  const rawT2IModel = modelSelections[MODEL_CATEGORIES.textToImage];
+  const limnFamily = resolveFamilyFromReplicateModelId(rawT2IModel) ?? rawT2IModel;
+  const limnImageDryRun = !env.replicateApiToken;
+  const limn = limnImageDryRun ? null : new Limn({
+    openrouterApiKey: env.openRouterApiKey || undefined,
+    replicateApiKey: env.replicateApiToken,
+    openrouterModel: modelSelections[MODEL_CATEGORIES.textToText]
+  });
+  const t2iReplicateModel = modelSelections.textToImageReplicateModel || undefined;
   const projectDir = deps.getProjectDir(project);
   const runState = await deps.readProjectRunState(project);
 
@@ -452,21 +465,21 @@ export async function regenerateProjectAsset(projectName, target, options = {})
   }
 
   if (targetType === 'keyframe') {
-    const keyframeSize = resolveKeyframeSize(projectConfig);
-    const keyframeUrl = await deps.generateKeyframe(
+    const keyframeResult = await deps.generateKeyframe(
       artifacts.shots[index],
       artifacts.tone || 'neutral',
       projectConfig.aspectRatio,
       index,
       traceBase,
-      keyframeSize,
       {
-        modelId: modelSelections[MODEL_CATEGORIES.textToImage],
+        limn,
+        family: limnFamily,
+        replicateModel: t2iReplicateModel,
         modelOptions: modelOptions[MODEL_CATEGORIES.textToImage]
       }
     );
-    artifacts.keyframeUrls[index] = keyframeUrl;
-    artifacts.keyframePaths[index] = await deps.persistKeyframe(projectDir, keyframeUrl, index);
+    artifacts.keyframeUrls[index] = keyframeResult.outputUrl || keyframeResult.modelSlug;
+    artifacts.keyframePaths[index] = await deps.persistKeyframe(projectDir, keyframeResult, index);
 
     const affectedSegmentIndexes = collectAffectedSegmentIndexes([index], artifacts.shots.length);
     const maxSegmentIndex = Math.max(0, artifacts.shots.length - 1);
@@ -627,6 +640,15 @@ export async function runPipeline(jobId, options = {}) {
     const projectConfig = await deps.readProjectConfig(project);
     const modelSelections = resolveProjectModelSelections(projectConfig.models);
     const modelOptions = resolveProjectModelOptions(projectConfig.modelOptions, modelSelections);
+    const rawT2IModel = modelSelections[MODEL_CATEGORIES.textToImage];
+    const limnFamily = resolveFamilyFromReplicateModelId(rawT2IModel) ?? rawT2IModel;
+    const limnImageDryRun = !env.replicateApiToken;
+    const limn = limnImageDryRun ? null : new Limn({
+      openrouterApiKey: env.openRouterApiKey || undefined,
+      replicateApiKey: env.replicateApiToken,
+      openrouterModel: modelSelections[MODEL_CATEGORIES.textToText]
+    });
+    const t2iReplicateModel = modelSelections.textToImageReplicateModel || undefined;
     const projectDir = deps.getProjectDir(project);
     const targetDurationSec = resolveTargetDurationSec(projectConfig);
     const plannedShots = resolveShotCount(projectConfig);
@@ -899,6 +921,10 @@ export async function runPipeline(jobId, options = {}) {
       (category) => JSON.stringify(previousModelOptions[category]) !== JSON.stringify(modelOptions[category])
     );
 
+    const modelSelectionsChanged = MODEL_SELECTION_KEYS.some(
+      (key) => modelSelections[key] !== previousModelSelections[key]
+    );
+
     const resetFromScript = () => {
       seedSteps[JobStep.SCRIPT] = false;
       seedSteps[JobStep.VOICE] = false;
@@ -975,7 +1001,7 @@ export async function runPipeline(jobId, options = {}) {
       resetFromScript();
     }
 
-    if (JSON.stringify(previousModelSelections) !== JSON.stringify(modelSelections)) {
+    if (modelSelectionsChanged) {
       resetFromScript();
     }
 
@@ -1214,20 +1240,21 @@ export async function runPipeline(jobId, options = {}) {
         if (shotIndex < 0 || shotIndex >= currentJob.artifacts.shots.length) {
           continue;
         }
-        const keyframeUrl = await deps.generateKeyframe(
+        const keyframeResult = await deps.generateKeyframe(
           currentJob.artifacts.shots[shotIndex],
           currentJob.artifacts.tone || 'neutral',
           projectConfig.aspectRatio,
           shotIndex,
           traceBase,
-          keyframeSize,
           {
-            modelId: modelSelections[MODEL_CATEGORIES.textToImage],
+            limn,
+            family: limnFamily,
+            replicateModel: t2iReplicateModel,
             modelOptions: modelOptions[MODEL_CATEGORIES.textToImage]
           }
         );
-        keyframeUrls[shotIndex] = keyframeUrl;
-        keyframePaths[shotIndex] = await deps.persistKeyframe(projectDir, keyframeUrl, shotIndex);
+        keyframeUrls[shotIndex] = keyframeResult.outputUrl || keyframeResult.modelSlug;
+        keyframePaths[shotIndex] = await deps.persistKeyframe(projectDir, keyframeResult, shotIndex);
       }
 
       const totalShots = currentJob.artifacts.shots.length;
@@ -1356,18 +1383,20 @@ export async function runPipeline(jobId, options = {}) {
         }
 
         if (!hasUrl) {
-          keyframeUrls[shotIndex] = await deps.generateKeyframe(
+          const keyframeResult = await deps.generateKeyframe(
             currentJob.artifacts.shots[shotIndex],
             currentJob.artifacts.tone || 'neutral',
             projectConfig.aspectRatio,
             shotIndex,
             traceBase,
-            keyframeSize,
             {
-              modelId: modelSelections[MODEL_CATEGORIES.textToImage],
+              limn,
+              family: limnFamily,
+              replicateModel: t2iReplicateModel,
               modelOptions: modelOptions[MODEL_CATEGORIES.textToImage]
             }
           );
+          keyframeUrls[shotIndex] = keyframeResult.outputUrl || keyframeResult.modelSlug;
         }
 
         keyframePaths[shotIndex] = await deps.persistKeyframe(projectDir, keyframeUrls[shotIndex], shotIndex);

package/src/steps/generateKeyframes.js

@@ -1,68 +1,94 @@
-import { ASPECT_RATIO_PRESETS, MODEL_CATEGORIES, resolveModelForCategory } from '../config/models.js';
-import { runModel, extractOutputUri } from '../providers/predictions.js';
 import path from 'node:path';
-import { downloadToFile, ensureDir } from '../media/files.js';
-import { resolveTextToImageAdapter } from './textToImageAdapters.js';
+import { writeFile } from 'node:fs/promises';
+import { ensureDir } from '../media/files.js';
 
 export async function generateKeyframe(
   promptText,
   tone,
   aspectRatio = '9:16',
   index = 0,
-  trace = null,
-  sizeOverride = null,
+  _trace,
   options = {}
 ) {
   const deps = options.deps || {};
-  const runModelFn = deps.runModel || runModel;
-  const extractOutputUriFn = deps.extractOutputUri || extractOutputUri;
+  const limn = options.limn || deps.limn || null;
+  const family = options.family;
+  const replicateModel = options.replicateModel;
+  const modelOptions = options.modelOptions ?? {};
 
-  const preset = ASPECT_RATIO_PRESETS[aspectRatio] || ASPECT_RATIO_PRESETS['9:16'];
-  const width = sizeOverride?.width || preset.keyframeWidth || ASPECT_RATIO_PRESETS['9:16'].keyframeWidth;
-  const height = sizeOverride?.height || preset.keyframeHeight || ASPECT_RATIO_PRESETS['9:16'].keyframeHeight;
-  const modelId = options.modelId || resolveModelForCategory(MODEL_CATEGORIES.textToImage);
-  const modelOptions = options.modelOptions;
-  const adapter = resolveTextToImageAdapter(modelId);
+  if (!family) {
+    throw new Error('Limn model family is required for keyframe generation');
+  }
+
+  if (!limn) {
+    throw new Error('Limn instance is required for keyframe generation');
+  }
 
-  const prediction = await runModelFn({
-    model: modelId,
-    input: adapter.buildInput({ promptText, tone, index, aspectRatio, width, height, modelOptions }),
-    trace: trace ? { ...trace, step: 'keyframe', index } : null
+  const result = await limn.generate(promptText, family, {
+    aspectRatio,
+    ...(replicateModel ? { replicateModel } : {}),
+    options: modelOptions
   });
 
-  const imageUrl = extractOutputUriFn(prediction.output);
-  if (!imageUrl) {
+  if (!result || !result.image) {
     throw new Error(`Missing keyframe output for shot ${index + 1}`);
   }
 
-  return imageUrl;
+  return {
+    buffer: result.image,
+    outputUrl: result.outputUrl || '',
+    mimeType: result.mimeType || 'image/png',
+    modelSlug: result.modelSlug || family
+  };
 }
 
-export async function generateKeyframes(shots, tone, aspectRatio = '9:16', trace = null, options = {}) {
-  const urls = [];
+export async function generateKeyframes(shots, tone, aspectRatio = '9:16', _trace, options = {}) {
+  const results = [];
   for (let i = 0; i < shots.length; i += 1) {
-    const imageUrl = await generateKeyframe(shots[i], tone, aspectRatio, i, trace, null, options);
-    urls.push(imageUrl);
+    const result = await generateKeyframe(shots[i], tone, aspectRatio, i, _trace, options);
+    results.push(result);
   }
-  return urls;
+  return results;
+}
+
+function mimeTypeToExtension(mimeType) {
+  if (mimeType === 'image/jpeg') return 'jpg';
+  if (mimeType === 'image/webp') return 'webp';
+  return 'png';
 }
 
-export async function persistKeyframe(projectDir, keyframeUrl, index, options = {}) {
+export async function persistKeyframe(projectDir, keyframeResult, index, options = {}) {
   const deps = options.deps || {};
   const ensureDirFn = deps.ensureDir || ensureDir;
-  const downloadToFileFn = deps.downloadToFile || downloadToFile;
+  const writeFileFn = deps.writeFile || writeFile;
 
   const keyframesDir = path.join(projectDir, 'assets', 'keyframes');
   await ensureDirFn(keyframesDir);
-  const keyframePath = path.join(keyframesDir, `keyframe_${String(index + 1).padStart(2, '0')}.png`);
-  await downloadToFileFn(keyframeUrl, keyframePath);
-  return keyframePath;
+
+  // Handle Limn buffer result
+  if (keyframeResult && typeof keyframeResult === 'object' && keyframeResult.buffer) {
+    const ext = mimeTypeToExtension(keyframeResult.mimeType || 'image/png');
+    const keyframePath = path.join(keyframesDir, `keyframe_${String(index + 1).padStart(2, '0')}.${ext}`);
+    await writeFileFn(keyframePath, keyframeResult.buffer);
+    return keyframePath;
+  }
+
+  // Handle legacy URL string
+  if (typeof keyframeResult === 'string') {
+    const depsDownload = deps.downloadToFile;
+    const downloadToFileFn = depsDownload || (await import('../media/files.js')).downloadToFile;
+    const keyframePath = path.join(keyframesDir, `keyframe_${String(index + 1).padStart(2, '0')}.png`);
+    await downloadToFileFn(keyframeResult, keyframePath);
+    return keyframePath;
+  }
+
+  throw new Error('Invalid keyframe result: expected buffer object or URL string');
 }
 
-export async function persistKeyframes(projectDir, keyframeUrls, options = {}) {
+export async function persistKeyframes(projectDir, keyframeResults, options = {}) {
   const keyframePaths = [];
-  for (let i = 0; i < keyframeUrls.length; i += 1) {
-    const keyframePath = await persistKeyframe(projectDir, keyframeUrls[i], i, options);
+  for (let i = 0; i < keyframeResults.length; i += 1) {
+    const keyframePath = await persistKeyframe(projectDir, keyframeResults[i], i, options);
     keyframePaths.push(keyframePath);
   }
 

package/src/store/projectStore.js

@@ -5,11 +5,13 @@ import { ensureDir, writeJson } from '../media/files.js';
 import {
   DEFAULT_MODEL_SELECTIONS,
   DEFAULT_VIDEO_CONFIG,
+  MODEL_CATEGORIES,
   MODEL_OPTION_KEYS,
   MODEL_SELECTION_KEYS,
   SUPPORTED_MODEL_IDS,
   resolveModelInputOptionsForCategory,
-  resolveProjectModelOptions
+  resolveProjectModelOptions,
+  resolveProjectModelSelections
 } from '../config/models.js';
 
 export const SUPPORTED_ASPECT_RATIOS = ['1:1', '16:9', '9:16'];
@@ -358,6 +360,11 @@ function validateProjectModelOptions(modelOptions, modelSelections) {
       throw new Error(`Invalid project config: modelOptions.${category} must be an object`);
     }
 
+    // T2I model options are validated by Limn at generation time
+    if (category === MODEL_CATEGORIES.textToImage) {
+      continue;
+    }
+
     const inputOptions = resolveModelInputOptionsForCategory(category, modelSelections);
     const allowedOptions = new Set(inputOptions.userConfigurable);
     const fields = inputOptions.fields || {};
@@ -400,12 +407,18 @@ export function normalizeProjectConfig(config) {
     }
   }
 
+  // Reject unknown model selection keys before normalization
+  if (nextConfig.models && typeof nextConfig.models === 'object' && !Array.isArray(nextConfig.models)) {
+    for (const key of Object.keys(nextConfig.models)) {
+      if (!MODEL_SELECTION_KEYS.includes(key) && key !== 'textToImageReplicateModel') {
+        throw new Error(`Invalid project config: models.${key} is not a supported model category`);
+      }
+    }
+  }
+
   const mergedModels = nextConfig.models === undefined
     ? { ...DEFAULT_MODEL_SELECTIONS }
-    : {
-        ...DEFAULT_MODEL_SELECTIONS,
-        ...(nextConfig.models || {})
-      };
+    : resolveProjectModelSelections(nextConfig.models);
   const mergedModelOptions = mergeProjectModelOptions(nextConfig.modelOptions, mergedModels);
 
   return {

package/frontend/dist/talefire-logo-dark.svg

@@ -1,34 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="18 26 197 48" width="394" height="96">
-  <defs>
-    <linearGradient id="flameGrad" x1="0%" y1="100%" x2="0%" y2="0%">
-      <stop offset="0%" stop-color="#ff3d00"/>
-      <stop offset="60%" stop-color="#ff7a00"/>
-      <stop offset="100%" stop-color="#ffcc00"/>
-    </linearGradient>
-
-    <filter id="flameGlow" x="-40%" y="-40%" width="180%" height="180%">
-      <feGaussianBlur stdDeviation="1.5" result="blur"/>
-      <feMerge>
-        <feMergeNode in="blur"/>
-        <feMergeNode in="SourceGraphic"/>
-      </feMerge>
-    </filter>
-  </defs>
-
-  <!-- Transparent background -->
-
-  <!-- Minimal flame — two triangles -->
-  <polygon points="44,31 58,68 30,68" fill="#ff4e00"/>
-  <polygon points="44,44 53,68 35,68" fill="#ff7a00"/>
-
-  <!-- Wordmark — white text, orange "fire" -->
-  <text
-    x="66" y="68"
-    font-family="'Helvetica Neue', Helvetica, Arial, sans-serif"
-    font-size="52"
-    font-weight="200"
-    letter-spacing="-1"
-    fill="#ffffff"
-  >tale<tspan font-weight="600" fill="#ff4e00">fire</tspan></text>
-
-</svg>

package/frontend/dist/talefire-logo-light.svg

@@ -1,36 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="18 26 197 48" width="394" height="96">
-  <defs>
-    <linearGradient id="flameGrad" x1="0%" y1="100%" x2="0%" y2="0%">
-      <stop offset="0%" stop-color="#ff3d00"/>
-      <stop offset="60%" stop-color="#ff7a00"/>
-      <stop offset="100%" stop-color="#ffcc00"/>
-    </linearGradient>
-
-    <filter id="flameGlow" x="-40%" y="-40%" width="180%" height="180%">
-      <feGaussianBlur stdDeviation="1.5" result="blur"/>
-      <feMerge>
-        <feMergeNode in="blur"/>
-        <feMergeNode in="SourceGraphic"/>
-      </feMerge>
-    </filter>
-  </defs>
-
-  <!-- Transparent background -->
-
-  <!-- Minimal flame — two triangles, clean and simple -->
-  <!-- Main triangle -->
-  <polygon points="44,31 58,68 30,68" fill="#ff4e00"/>
-  <!-- Small inner triangle cutout to suggest flame shape -->
-  <polygon points="44,44 53,68 35,68" fill="#ff7a00"/>
-
-  <!-- Wordmark — original letter spacing -->
-  <text
-    x="66" y="68"
-    font-family="'Helvetica Neue', Helvetica, Arial, sans-serif"
-    font-size="52"
-    font-weight="200"
-    letter-spacing="-1"
-    fill="#1a1a1a"
-  >tale<tspan font-weight="600" fill="#ff4e00">fire</tspan></text>
-
-</svg>

package/models/black-forest-labs__flux-2-pro.json

@@ -1,78 +0,0 @@
-{
-  "modelId": "black-forest-labs/flux-2-pro",
-  "provider": "replicate",
-  "displayName": "FLUX 2 Pro",
-  "category": "image-generation",
-  "pricingSourceUrl": "https://replicate.com/black-forest-labs/flux-2-pro",
-  "pricingNotes": "Replicate lists multi-property pricing for run and input/output megapixels; this model currently uses best-effort cost fallback when exact rule mapping is unavailable.",
-  "pricing": {
-    "usdPerSecond": null,
-    "usdPer1kInputTokens": null,
-    "usdPer1kOutputTokens": null
-  },
-  "inputOptions": {
-    "userConfigurable": [
-      "safety_tolerance",
-      "seed",
-      "output_format",
-      "output_quality"
-    ],
-    "pipelineManaged": [
-      "prompt",
-      "aspect_ratio",
-      "width",
-      "height"
-    ],
-    "fields": {
-      "safety_tolerance": {
-        "type": "integer",
-        "default": 2,
-        "minimum": 1,
-        "maximum": 5
-      },
-      "seed": {
-        "type": "integer",
-        "nullable": true
-      },
-      "output_format": {
-        "type": "string",
-        "default": "webp",
-        "enum": [
-          "webp",
-          "png",
-          "jpg",
-          "jpeg"
-        ]
-      },
-      "output_quality": {
-        "type": "integer",
-        "default": 80,
-        "minimum": 0,
-        "maximum": 100
-      },
-      "prompt": {
-        "type": "string",
-        "required": true
-      },
-      "aspect_ratio": {
-        "type": "string",
-        "required": true,
-        "enum": [
-          "custom"
-        ]
-      },
-      "width": {
-        "type": "integer",
-        "required": true,
-        "minimum": 256,
-        "maximum": 2048
-      },
-      "height": {
-        "type": "integer",
-        "required": true,
-        "minimum": 256,
-        "maximum": 2048
-      }
-    }
-  }
-}