Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { useCallback, useEffect, useRef, useState } from 'react';
import { useNavigate, useSearchParams } from 'react-router';
import { composeStyledPrompt, stylePromptAdditions } from '../lib/composeStyledPrompt';
import {
FAL_IMAGE_MODEL_IDS, RUNWAY_IMAGE_MODEL_IDS,
IMAGE_GEN_MODE,
isCloudCliMode,
modeLabel,
} from '../lib/imageGenBackends';
import { clampImageEdge } from '../lib/imageGenResolutions';
import { useImageGenForm } from './useImageGenForm';
import { useImageGenGallery } from './useImageGenGallery';
import { useSocketResource } from './useSocketResource';
import { useFederatedMediaTarget } from './useFederatedMediaTarget';
import { useImageGenProgress } from './useImageGenProgress';
import { useMediaCompletionRefresh } from './useMediaCompletionRefresh';
import { useMediaJobSse, isMediaRunEnded } from './useMediaJobSse';
import { useModelDownloadStatus } from './useModelDownloadStatus';
import { useHfTokenStatus } from './useHfTokenStatus';
import { useAgyModels } from './useAgyModels';
import { useModelInputPreview } from './useModelInputPreview';
import toast from '../components/ui/Toast';
import {
buildFormData,
cancelImageGen,
generateImage,
generateImageMultipart,
getActiveImageJob,
getFlux2Status,
getImageGenStatus,
getRegenAvailability,
listMediaJobs,
previewImagePrompt,
regenerateGalleryImage,
} from '../services/api';
import { musicVideoFilingFields } from '../lib/musicVideoFiling';
// The style presets folded into the prompt, recorded beside it on the render (#11317).
const promptAdditionsField = (presets) => {
const additions = stylePromptAdditions(presets);
return additions.length ? { promptAdditions: additions } : {};
};
const IMAGE_QUEUE_EVENTS = ['media-jobs:changed'];
const STAGE_LABELS = {
starting: 'Starting…',
'download-tokenizer': 'Loading tokenizer…',
'download-pipeline': 'Downloading model weights (~8 GB on first run)…',
'download-snapshot': 'Downloading model weights…',
'download-int8-snapshot': 'Downloading model weights (~16 GB on first run)…',
'load-transformer': 'Loading transformer…',
'load-text-encoder': 'Loading text encoder…',
'move-to-device': 'Moving model to GPU…',
inference: 'Running diffusion…',
};
function useImageGenBackendRuntime() {
const [status, setStatus] = useState(null);
const [statusLoading, setStatusLoading] = useState(true);
const [selectedMode, setSelectedMode] = useState(null);
const [availableBackends, setAvailableBackends] = useState([]);
const selectedModeRef = useRef(null);
selectedModeRef.current = selectedMode;
const statusRequestToken = useRef(0);
const effectiveMode = selectedMode || status?.mode || IMAGE_GEN_MODE.EXTERNAL;
const isLocalMode = effectiveMode === IMAGE_GEN_MODE.LOCAL;
const isCloudMode = isCloudCliMode(effectiveMode);
const cloudModeLabel = modeLabel(effectiveMode);
const isAgyMode = effectiveMode === IMAGE_GEN_MODE.AGY;
const isRunwayMode = effectiveMode === IMAGE_GEN_MODE.RUNWAY;
const isFalMode = effectiveMode === IMAGE_GEN_MODE.FAL;
const remoteTarget = useFederatedMediaTarget('image');
const remoteTargetActive = effectiveMode !== IMAGE_GEN_MODE.GROK && remoteTarget.isRemote;
const localBackendPending = statusLoading && !remoteTargetActive;
const agy = useAgyModels(isAgyMode);
const refreshStatus = useCallback((mode, localModelId) => {
const requestToken = ++statusRequestToken.current;
setStatusLoading(true);
getImageGenStatus(mode, mode === IMAGE_GEN_MODE.LOCAL ? localModelId : undefined)
.then((nextStatus) => {
if (requestToken !== statusRequestToken.current) return;
setStatus(nextStatus);
})
.catch(() => {
if (requestToken !== statusRequestToken.current) return;
setStatus({ connected: false, reason: 'Status check failed' });
})
.finally(() => {
if (requestToken === statusRequestToken.current) setStatusLoading(false);
});
}, []);
const configureBackends = useCallback((backends, savedMode) => {
const previous = selectedModeRef.current;
const next = (previous && backends.find((backend) => backend.id === previous)) ? previous
: backends.find((backend) => backend.id === savedMode) ? savedMode
: backends.length ? backends[0].id
: savedMode;
setAvailableBackends(backends);
setSelectedMode(next);
return next;
}, []);
return {
status,
statusLoading,
availableBackends,
effectiveMode,
isLocalMode,
isCloudMode,
cloudModeLabel,
isAgyMode,
isRunwayMode,
isFalMode,
remoteTarget,
remoteTargetActive,
localBackendPending,
agy,
refreshStatus,
setSelectedMode,
configureBackends,
};
}
export function useImageGenPageRuntime() {
const navigate = useNavigate();
const [searchParams, setSearchParams] = useSearchParams();
const settingsOpen = searchParams.get('settings') === '1';
const openSettings = () => setSearchParams((previous) => {
const next = new URLSearchParams(previous);
next.set('settings', '1');
return next;
});
const closeSettings = () => setSearchParams((previous) => {
const next = new URLSearchParams(previous);
next.delete('settings');
return next;
});
const backend = useImageGenBackendRuntime();
const form = useImageGenForm({ searchParams, setSearchParams, backend });
const gallery = useImageGenGallery({ previewParam: searchParams.get('preview') });
const [flux2Status, setFlux2Status] = useState(null);
const [flux2InstallOpen, setFlux2InstallOpen] = useState(false);
const [generating, setGenerating] = useState(false);
const [statusMsg, setStatusMsg] = useState('');
const [errorMeta, setErrorMeta] = useState(null);
const [localProgress, setLocalProgress] = useState(null);
const [stage, setStage] = useState(null);
const [result, setResult] = useState(null);
const [error, setError] = useState(null);
const [regenInfo, setRegenInfo] = useState(null);
// One run owner for the displayed render: Cancel targets exactly its job, and
// unmount detaches the stream without cancelling accepted durable work.
const { start: startRun, cancel: cancelRun } = useMediaJobSse('image', {
cancelJob: (jobId) => cancelImageGen({ jobId }),
});
const { progress: externalProgress, begin: beginGenerate, end: endGenerate, resume: resumeGenerate } = useImageGenProgress();
useMediaCompletionRefresh({ onImageCompleted: gallery.refreshRecent });
const modelDownload = useModelDownloadStatus({ kind: 'image' });
const { present: hfTokenPresent, refresh: refreshHfTokenStatus } = useHfTokenStatus({ enabled: form.derived.needsHfTokenGate });
const progress = externalProgress || localProgress;
const progressPct = progress?.progress != null ? Math.round(progress.progress * 100) : null;
const { fields, derived, images, actions } = form;
const { effectiveMode, isCloudMode, remoteTargetActive } = backend;
const effectiveAgyModel = backend.agy.models.includes(fields.agyModel) ? fields.agyModel : '';
// Only a catalog id is ever sent — the server refuses anything else.
const effectiveFalModel = FAL_IMAGE_MODEL_IDS.includes(fields.falModel) ? fields.falModel : '';
const effectiveRunwayModel = RUNWAY_IMAGE_MODEL_IDS.includes(fields.runwayModel) ? fields.runwayModel : '';
const effectiveCloudModel = backend.isAgyMode ? effectiveAgyModel : backend.isFalMode ? effectiveFalModel : backend.isRunwayMode ? effectiveRunwayModel : '';
useEffect(() => {
if (!effectiveMode) return;
backend.refreshStatus(effectiveMode, fields.modelId);
}, [effectiveMode, fields.modelId, backend.refreshStatus]);
const refreshFlux2Status = useCallback((signal) => getFlux2Status({ modelId: fields.modelId, signal })
.then((status) => { if (status) setFlux2Status(status); })
.catch(() => {}), [fields.modelId]);
const handleFlux2ModalClose = useCallback(() => setFlux2InstallOpen(false), []);
const handleFlux2InstallComplete = useCallback(() => {
refreshFlux2Status();
backend.refreshStatus(effectiveMode, fields.modelId);
toast.success('FLUX.2 runtime installed');
}, [refreshFlux2Status, backend.refreshStatus, effectiveMode, fields.modelId]);
useEffect(() => {
if (!derived.sharesFlux2Venv) {
setFlux2Status(null);
return;
}
const controller = new AbortController();
refreshFlux2Status(controller.signal);
return () => controller.abort();
}, [derived.sharesFlux2Venv, fields.modelId, refreshFlux2Status]);
useEffect(() => {
// Adopt the job still running server-side after a reload. `ifIdle` yields to
// a render this tab already owns; the owner creates no stream (or
// presentation) when the page unmounts before the read resolves.
startRun(
() => getActiveImageJob().then(({ activeJob }) => activeJob),
{
onAcknowledged: (activeJob) => {
actions.restoreActiveJob(activeJob);
setGenerating(true);
setStatusMsg('Resuming…');
resumeGenerate(activeJob);
},
onStatus: (message) => setStatusMsg(message.message),
onProgress: (message) => setLocalProgress({ progress: message.progress }),
onComplete: () => setGenerating(false),
onError: () => setGenerating(false),
onCanceled: () => setGenerating(false),
onConnectionError: () => setGenerating(false),
},
{ ifIdle: true, jobIdOf: (activeJob) => activeJob?.generationId },
).catch(() => {});
}, [actions.restoreActiveJob, startRun, resumeGenerate]);
const regenAvailable = !!regenInfo?.available;
const refreshRegenAvailability = useCallback(() => {
getRegenAvailability().then((availability) => setRegenInfo(availability || null)).catch(() => {});
}, []);
useEffect(() => { refreshRegenAvailability(); }, [refreshRegenAvailability]);
const wasSettingsOpenRef = useRef(false);
useEffect(() => {
if (wasSettingsOpenRef.current && !settingsOpen) {
refreshRegenAvailability();
form.settings.reloadBackends();
}
wasSettingsOpenRef.current = settingsOpen;
}, [settingsOpen, refreshRegenAvailability, form.settings.reloadBackends]);
const { data: queueJobs, updateData: updateQueueJobs } = useSocketResource(
() => listMediaJobs({ kind: 'image' }),
{ events: IMAGE_QUEUE_EVENTS },
);
const previousQueueRef = useRef(null);
useEffect(() => {
if (!queueJobs) return;
const previous = previousQueueRef.current;
previousQueueRef.current = queueJobs;
if (!previous) return;
const activeIds = new Set(queueJobs
.filter((job) => job.status === 'queued' || job.status === 'running')
.map((job) => job.id));
// Recover gallery output when a terminal event was missed while offline.
// Compare identities, not just counts: another enqueue can replace a job.
if (previous.some((job) => ['queued', 'running'].includes(job.status) && !activeIds.has(job.id))) {
gallery.refreshRecent();
}
}, [queueJobs, gallery.refreshRecent]);
const pendingQueued = Math.max(0, (queueJobs || [])
.filter((job) => job.status === 'queued' || job.status === 'running').length - (generating ? 1 : 0));
const rememberQueuedJob = (ack) => {
const id = ack?.jobId || ack?.generationId;
if (!id) return;
// The queue event may beat the HTTP acknowledgement. Merge by id so the
// response cannot double-count a job or revive an already completed one.
updateQueueJobs((previous) => (previous || []).some((job) => job.id === id)
? previous : [...(previous || []), { id, status: ack.status || 'queued' }]);
};
const buildGenerationPayload = () => {
const composed = composeStyledPrompt(fields.prompt, fields.negativePrompt, derived.activeStylePresets);
const width = clampImageEdge(fields.width);
const height = clampImageEdge(fields.height);
const payload = remoteTargetActive ? {
prompt: composed.prompt,
negativePrompt: composed.negativePrompt || undefined,
width,
height,
steps: fields.steps ? Number(fields.steps) : undefined,
guidance: fields.guidance ? Number(fields.guidance) : undefined,
seed: fields.seed && Number(fields.seed) >= 0 ? Number(fields.seed) : undefined,
...backend.remoteTarget.submissionFields,
} : isCloudMode ? {
prompt: composed.prompt,
negativePrompt: composed.negativePrompt || undefined,
width,
height,
mode: effectiveMode,
...(effectiveCloudModel ? { cloudModel: effectiveCloudModel } : {}),
cleanC2PA: fields.cleanC2PA,
denoise: fields.denoise,
} : {
prompt: composed.prompt,
negativePrompt: composed.negativePrompt || undefined,
modelId: fields.modelId || undefined,
width,
height,
steps: fields.steps ? Number(fields.steps) : undefined,
guidance: fields.guidance ? Number(fields.guidance) : undefined,
seed: fields.seed && Number(fields.seed) >= 0 ? Number(fields.seed) : undefined,
quantize: derived.currentModel?.runner === 'moss-swift' ? undefined : fields.quantize,
loraFilenames: fields.selectedLoras.map((lora) => lora.filename),
loraScales: fields.selectedLoras.map((lora) => lora.scale),
mode: IMAGE_GEN_MODE.LOCAL,
cleanC2PA: fields.cleanC2PA,
denoise: fields.denoise,
};
Object.assign(payload, musicVideoFilingFields(searchParams), promptAdditionsField(derived.activeStylePresets));
const hasInitImage = derived.i2iCapable && images.initImage.source != null;
const hasReferenceImages = derived.populatedRefs.length > 0;
const initFields = hasInitImage ? {
...(images.initImage.source === 'upload'
? { initImage: images.initImage.file }
: { initImageFile: images.initImage.name }),
initImageStrength: images.initImageStrength,
} : {};
const referenceFields = hasReferenceImages ? {
...Object.fromEntries(derived.populatedRefs.map((slot, index) => [`referenceImage${index + 1}`, slot.file])),
referenceStrengths: derived.populatedRefs.map((slot) => slot.strength),
} : {};
return { payload, initFields, referenceFields, hasInputImages: hasInitImage || hasReferenceImages };
};
// The same request as Generate, with uploads named by count (#11317).
const previewBody = (() => {
if (!derived.isAsyncMode) {
const composed = composeStyledPrompt(fields.prompt, fields.negativePrompt, derived.activeStylePresets);
return {
prompt: composed.prompt, negativePrompt: composed.negativePrompt || undefined,
width: clampImageEdge(fields.width), height: clampImageEdge(fields.height), mode: IMAGE_GEN_MODE.EXTERNAL,
...promptAdditionsField(derived.activeStylePresets),
};
}
const { payload, initFields, referenceFields } = buildGenerationPayload();
const { initImage, ...initRest } = initFields;
const { referenceStrengths, ...referenceUploads } = referenceFields;
const uploadedReferenceCount = Object.keys(referenceUploads).length;
return {
...payload, ...initRest,
...(initImage ? { uploadedInitImage: true } : {}),
...(uploadedReferenceCount ? { uploadedReferenceCount, referenceStrengths } : {}),
};
})();
const modelInputPreview = useModelInputPreview(previewImagePrompt, previewBody, {
enabled: !form.remix.pending && !derived.cloudNeedsPrompt && !derived.editImageMissing,
});
const submitGenerationPayload = async () => {
const { payload, initFields, referenceFields, hasInputImages } = buildGenerationPayload();
if (hasInputImages) {
const formData = buildFormData({ ...payload, ...initFields, ...referenceFields });
const data = await generateImageMultipart(formData, { silent: true });
rememberQueuedJob(data);
return { payload, data };
}
const data = await generateImage(payload, { silent: true });
rememberQueuedJob(data);
return { payload, data };
};
const startLocalGeneration = () => {
setLocalProgress({ progress: 0 });
let submitted;
return startRun(async () => {
submitted = await submitGenerationPayload();
return submitted.data;
}, (data) => ({
onStage: (message) => setStage({ name: message.stage, detail: message.detail }),
onStatus: (message) => setStatusMsg(message.message),
onProgress: (message) => {
setLocalProgress({ progress: message.progress, phase: message.phase });
setStatusMsg(message.message);
},
onComplete: (message) => {
const { payload } = submitted;
const localOnlyMeta = isCloudMode ? {} : {
steps: payload.steps ?? derived.currentModel?.steps,
guidance: payload.guidance ?? derived.currentModel?.guidance,
};
setResult({
...data,
...message.result,
prompt: payload.prompt,
negativePrompt: payload.negativePrompt,
width: payload.width,
height: payload.height,
...localOnlyMeta,
});
return message.result;
},
onError: (message) => {
const generationError = new Error(message.error);
if (message.kind) generationError.kind = message.kind;
if (message.repo) generationError.repo = message.repo;
return generationError;
},
}));
};
const queueAdditional = async (count = 1) => {
if (count < 1) return;
const submissions = Array.from({ length: count }, () => (
submitGenerationPayload().then(({ data }) => data).catch((generationError) => generationError)
));
const results = await Promise.all(submissions);
const queued = results.filter((result) => result && !(result instanceof Error)).length;
const failed = results.length - queued;
if (queued > 0) toast.success(count === 1 ? 'Queued' : `Queued ${queued}`);
if (failed > 0) toast.error(`${failed} job(s) failed to queue`);
};
const handleGenerate = async (event) => {
event?.preventDefault?.();
if (form.remix.pending || derived.loraHandoffBlocked || derived.unsupportedLocalInputs) return;
if (derived.editImageMissing || derived.cloudNeedsPrompt) return;
if (derived.localBackendPending || (!remoteTargetActive && derived.notConnected)) return;
if (remoteTargetActive) {
if (derived.remoteUnsupportedInputs) {
toast.error(derived.remoteUnsupportedInputs);
return;
}
const fresh = backend.remoteTarget.verify();
if (!fresh.ok) {
toast.error(fresh.message);
return;
}
}
const batch = derived.isAsyncMode ? Math.max(1, fields.batchCount) : 1;
if (generating) return queueAdditional(batch);
const width = clampImageEdge(fields.width);
const height = clampImageEdge(fields.height);
if (width !== fields.width) fields.setWidth(width);
if (height !== fields.height) fields.setHeight(height);
setGenerating(true);
setStatusMsg('Starting...');
setError(null);
setErrorMeta(null);
setResult(null);
setStage(null);
beginGenerate();
try {
if (derived.isAsyncMode) {
const extras = batch > 1 ? queueAdditional(batch - 1) : Promise.resolve();
await startLocalGeneration();
await extras;
} else {
const composed = composeStyledPrompt(fields.prompt, fields.negativePrompt, derived.activeStylePresets);
const payload = {
prompt: composed.prompt,
negativePrompt: composed.negativePrompt || undefined,
width,
height,
steps: fields.steps ? Number(fields.steps) : 25,
cfgScale: fields.cfgScale,
mode: IMAGE_GEN_MODE.EXTERNAL,
cleanC2PA: fields.cleanC2PA,
denoise: fields.denoise,
};
if (fields.seed && Number(fields.seed) >= 0) payload.seed = Number(fields.seed);
Object.assign(payload, musicVideoFilingFields(searchParams), promptAdditionsField(derived.activeStylePresets));
const data = await generateImage(payload, { silent: true });
setResult({
...data,
prompt: payload.prompt,
negativePrompt: payload.negativePrompt,
width,
height,
steps: payload.steps,
cfgScale: payload.cfgScale,
});
}
toast.success('Image generated');
gallery.refreshRecent();
} catch (generationError) {
// Cancelled / detached runs are not failures: Cancel already did the
// presentation, and an unmounted page has nothing to present.
if (isMediaRunEnded(generationError)) return;
setError(generationError.message || 'Image generation failed');
if (generationError.kind) setErrorMeta({ kind: generationError.kind, repo: generationError.repo });
const firstLine = String(generationError.message || 'Image generation failed').split('\n')[0];
toast.error(firstLine);
} finally {
setGenerating(false);
setLocalProgress(null);
setStage(null);
endGenerate();
}
};
const handleCancel = async () => {
// Cancel exactly the render this page owns. Only a render with no owned job
// (a synchronous external-service call) falls back to the legacy
// "most recent job" cancel.
const owned = await cancelRun();
if (!owned) await cancelImageGen().catch(() => {});
setGenerating(false);
setStatusMsg('Cancelled');
};
const handleRegenerate = async (image, options = {}) => {
if (!image?.filename) throw new Error('Missing filename');
if (options.method === 'light') {
const variant = await regenerateGalleryImage(image.filename, { method: 'light' }).catch((generationError) => {
toast.error(generationError.message || 'Failed to run light regen');
throw generationError;
});
gallery.actions.prependVariant(variant);
toast.success(`Light regen → ${variant.filename}`);
return;
}
const ack = await regenerateGalleryImage(image.filename, { strength: options.strength, prompt: options.prompt }).catch((generationError) => {
toast.error(generationError.message || 'Failed to start regeneration');
throw generationError;
});
rememberQueuedJob(ack);
toast.success('Regenerating — the new image will appear when it finishes');
};
const sendToVideo = useCallback((item) => {
const image = item?.raw || item;
if (!image?.filename) return;
const params = new URLSearchParams({ sourceImageFile: image.filename });
const sourcePrompt = image.prompt || image.metadata?.prompt;
const sourceNegative = image.negativePrompt || image.negative_prompt || image.metadata?.negativePrompt;
if (sourcePrompt) params.set('prompt', sourcePrompt);
if (sourceNegative) params.set('negativePrompt', sourceNegative);
navigate(`/media/video?${params}`);
}, [navigate]);
const handleSendToImage = useCallback((item) => {
const image = item?.raw || item;
if (!image?.filename) return;
actions.handleRemix(image, { applyModel: false });
fields.setPrompt(image.prompt || '');
actions.ensureI2iCapableMode();
actions.setGalleryInitImage(image.filename);
}, [actions.ensureI2iCapableMode, actions.handleRemix, actions.setGalleryInitImage, fields.setPrompt]);
const handleSendTo3d = useCallback((item) => {
const image = item?.raw || item;
if (!image?.filename) return;
navigate(`/3d?image=${encodeURIComponent(image.filename)}`);
}, [navigate]);
return {
form,
backend: { ...backend, effectiveAgyModel, effectiveFalModel, effectiveRunwayModel },
generation: {
handleGenerate,
handleCancel,
generating,
statusMsg,
errorMeta,
progress,
progressPct,
pendingQueued,
stage,
stageLabel: stage ? (STAGE_LABELS[stage.name] || stage.name) : null,
result,
error,
modelDownload,
hfTokenPresent,
refreshHfTokenStatus,
flux2Status,
refreshFlux2Status,
needsFlux2Token: derived.isFlux2Model && !!flux2Status && flux2Status.venvInstalled && !flux2Status.hfTokenPresent,
handleRegenerate,
modelInputPreview,
},
gallery: {
view: gallery.view,
cards: {
setPreview: gallery.preview.set,
handleRemix: actions.handleRemix,
handleSendToImage,
sendToVideo,
handleSendTo3d,
handleDelete: gallery.actions.delete,
handleToggleHidden: gallery.actions.toggleHidden,
getCardProps: gallery.getCardProps,
toggleGalleryStar: gallery.actions.toggleStar,
},
overlay: {
value: gallery.preview.value,
set: gallery.preview.set,
items: gallery.preview.items,
annotations: gallery.preview.annotations,
updateAnnotation: gallery.preview.updateAnnotation,
onPromptSaved: gallery.actions.promptSaved,
onRemix: (item) => item?.raw && actions.handleRemix(item.raw),
onSendToImage: (item) => item?.raw?.filename && handleSendToImage(item.raw),
onSendToVideo: (item) => item?.raw?.filename && sendToVideo(item.raw),
onSendTo3d: (item) => item?.raw?.filename && handleSendTo3d(item.raw),
onClean: (item) => gallery.actions.clean(item?.raw),
onRegenerate: (item, options) => handleRegenerate(item?.raw, options),
onRemoveWatermark: (item) => gallery.actions.removeWatermark(item?.raw),
regenAvailable,
regenBounds: regenInfo,
},
picker: {
value: images.galleryPicker,
onClose: () => images.setGalleryPicker(null),
onSelect: images.handleGallerySelect,
},
},
header: {
status: {
loading: backend.statusLoading,
value: backend.status,
ready: derived.statusReady,
unknown: derived.statusUnknown,
mode: effectiveMode,
},
backends: {
available: backend.availableBackends,
value: effectiveMode,
onChange: actions.switchMode,
},
remix: form.remix,
actions: {
onRefresh: () => backend.refreshStatus(effectiveMode, fields.modelId),
onOpenSettings: openSettings,
onInstallRuntime: () => setFlux2InstallOpen(true),
},
},
settings: {
open: settingsOpen,
onClose: closeSettings,
},
flux2: {
open: flux2InstallOpen,
onClose: handleFlux2ModalClose,
onComplete: handleFlux2InstallComplete,
modelId: fields.modelId,
},
};
}