Merge pull request #3476 from Dakraid/feature/fal-integration Feature: FAL.AI Integration

5477586ce46a99039bf5bda329ffff596e9b0a9a

Cohee <18619528+Cohee1207@users.noreply.github.com>

Signed

Parents: f101dd571fc283f009e72c38619f4aa2f09b3f50 76becb43ae0fbbf4842fbc1ea5104ac851de5d7c

public/scripts/extensions/stable-diffusion/index.js+67 -0 Viewed

     huggingface: 'huggingface',
     nanogpt: 'nanogpt',
     bfl: 'bfl',
 +    falai: 'falai',
 };
 const initiators = {

     return onApiKeyClick('BFL API Key:', SECRET_KEYS.BFL);
+}
 +async function onFalaiKeyClick() {
 +    return onApiKeyClick('FALAI API Key:', SECRET_KEYS.FALAI);
 +}
++
 function onBflUpsamplingInput() {
     extension_settings.sd.bfl_upsampling = !!$('#sd_bfl_upsampling').prop('checked');
     saveSettingsDebounced();

         sources.huggingface,
         sources.nanogpt,
         sources.bfl,
 +        sources.falai,
     ];
     if (cloudSources.includes(extension_settings.sd.source)) {

         case sources.bfl:
             models = await loadBflModels();
             break;
 +        case sources.falai:
 +            models = await loadFalaiModels();
 +            break;
+    }
     for (const model of models) {

     ];
+}
 +async function loadFalaiModels() {
 +    $('#sd_falai_key').toggleClass('success', !!secret_state[SECRET_KEYS.FALAI]);
++
 +    const result = await fetch('/api/sd/falai/models', {
 +        method: 'POST',
 +        headers: getRequestHeaders(),
 +    });
++
 +    if (result.ok) {
 +        return await result.json();
 +    }
++
 +    return [];
 +}
++
 async function loadPollinationsModels() {
     const result = await fetch('/api/sd/pollinations/models', {
         method: 'POST',

         case sources.bfl:
             schedulers = ['N/A'];
             break;
 +        case sources.falai:
 +            schedulers = ['N/A'];
 +            break;
+    }
     for (const scheduler of schedulers) {

             case sources.bfl:
                 result = await generateBflImage(prefixedPrompt, signal);
                 break;
 +            case sources.falai:
 +                result = await generateFalaiImage(prefixedPrompt, negativePrompt, signal);
 +                break;
+        }
         if (!result.data) {

+    }
+}
 +/**
 + * Generates an image using the FAL.AI API.
 + * @param {string} prompt - The main instruction used to guide the image generation.
 + * @param {string} negativePrompt - The negative prompt used to guide the image generation.
 + * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
 + * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
 + */
 +async function generateFalaiImage(prompt, negativePrompt, signal) {
 +    const result = await fetch('/api/sd/falai/generate', {
 +        method: 'POST',
 +        headers: getRequestHeaders(),
 +        signal: signal,
 +        body: JSON.stringify({
 +            prompt: prompt,
 +            negative_prompt: negativePrompt,
 +            model: extension_settings.sd.model,
 +            steps: clamp(extension_settings.sd.steps, 1, 50),
 +            guidance: clamp(extension_settings.sd.scale, 1.5, 5),
 +            width: clamp(extension_settings.sd.width, 256, 1440),
 +            height: clamp(extension_settings.sd.height, 256, 1440),
 +            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
 +        }),
 +    });
++
 +    if (result.ok) {
 +        const data = await result.json();
 +        return { format: 'jpg', data: data.image };
 +    } else {
 +        const text = await result.text();
 +        console.log(text);
 +        throw new Error(text);
 +    }
 +}
++
 async function onComfyOpenWorkflowEditorClick() {
     let workflow = await (await fetch('/api/sd/comfy/workflow', {
         method: 'POST',

@@ -3782,6 +3846,8 @@ function isValidState() {
3782	3846	return secret_state[SECRET_KEYS.NANOGPT];
3783	3847	case sources.bfl:
3784	3848	return secret_state[SECRET_KEYS.BFL];
	3849	+ case sources.falai:
	3850	+ return secret_state[SECRET_KEYS.FALAI];
3785	3851	}
3786	3852	}
3787	3853

     $('#sd_function_tool').on('input', onFunctionToolInput);
     $('#sd_bfl_key').on('click', onBflKeyClick);
     $('#sd_bfl_upsampling').on('input', onBflUpsamplingInput);
 +    $('#sd_falai_key').on('click', onFalaiKeyClick);
     if (!CSS.supports('field-sizing', 'content')) {
         $('.sd_settings .inline-drawer-toggle').on('click', function () {

public/scripts/extensions/stable-diffusion/settings.html+15 -0 Viewed

                 <option value="comfy">ComfyUI</option>
                 <option value="drawthings">DrawThings HTTP API</option>
                 <option value="extras">Extras API (deprecated)</option>
 +                <option value="falai">FAL.AI</option>
                 <option value="huggingface">HuggingFace Inference API (serverless)</option>
                 <option value="nanogpt">NanoGPT</option>
                 <option value="novel">NovelAI Diffusion</option>

                 </label>
             </div>
 +            <div data-sd-source="falai">
 +                <div class="flex-container flexnowrap alignItemsBaseline marginBot5">
 +                    <a href="https://fal.ai/dashboard" target="_blank" rel="noopener noreferrer">
 +                        <strong data-i18n="API Key">API Key</strong>
 +                        <i class="fa-solid fa-share-from-square"></i>
 +                    </a>
 +                    <span class="expander"></span>
 +                    <div id="sd_falai_key" class="menu_button menu_button_icon">
 +                        <i class="fa-fw fa-solid fa-key"></i>
 +                        <span data-i18n="Click to set">Click to set</span>
 +                    </div>
 +                </div>
 +            </div>
++
             <div class="flex-container">
                 <div class="flex1">
                     <label for="sd_model" data-i18n="Model">Model</label>

public/scripts/secrets.js+1 -0 Viewed

     GENERIC: 'api_key_generic',
     DEEPSEEK: 'api_key_deepseek',
     SERPER: 'api_key_serper',
 +    FALAI: 'api_key_falai',
 };
 const INPUT_MAP = {

src/endpoints/secrets.js+1 -0 Viewed

     TAVILY: 'api_key_tavily',
     NANOGPT: 'api_key_nanogpt',
     BFL: 'api_key_bfl',
 +    FALAI: 'api_key_falai',
     GENERIC: 'api_key_generic',
     DEEPSEEK: 'api_key_deepseek',
     SERPER: 'api_key_serper',

src/endpoints/stable-diffusion.js+126 -0 Viewed

+    }
 });
 +const falai = express.Router();
++
 +falai.post('/models', jsonParser, async (_request, response) => {
 +    try {
 +        const modelsUrl = new URL('https://fal.ai/api/models?categories=text-to-image');
 +        const result = await fetch(modelsUrl);
++
 +        if (!result.ok) {
 +            console.warn('FAL.AI returned an error.', result.status, result.statusText);
 +            throw new Error('FAL.AI request failed.');
 +        }
++
 +        const data = await result.json();
++
 +        if (!Array.isArray(data)) {
 +            console.warn('FAL.AI returned invalid data.');
 +            throw new Error('FAL.AI request failed.');
 +        }
++
 +        const models = data
 +            .filter(x => !x.title.toLowerCase().includes('inpainting') &&
 +                !x.title.toLowerCase().includes('control') &&
 +                !x.title.toLowerCase().includes('upscale'))
 +            .sort((a, b) => a.title.localeCompare(b.title))
 +            .map(x => ({ value: x.modelUrl.split('fal-ai/')[1], text: x.title }));
 +        return response.send(models);
 +    } catch (error) {
 +        console.error(error);
 +        return response.sendStatus(500);
 +    }
 +});
++
 +falai.post('/generate', jsonParser, async (request, response) => {
 +    try {
 +        const key = readSecret(request.user.directories, SECRET_KEYS.FALAI);
++
 +        if (!key) {
 +            console.warn('FAL.AI key not found.');
 +            return response.sendStatus(400);
 +        }
++
 +        const requestBody = {
 +            prompt: request.body.prompt,
 +            image_size: { 'width': request.body.width, 'height': request.body.height },
 +            num_inference_steps: request.body.steps,
 +            seed: request.body.seed ?? null,
 +            guidance_scale: request.body.guidance,
 +            enable_safety_checker: false,
 +        };
++
 +        console.debug('FAL.AI request:', requestBody);
++
 +        const result = await fetch(`https://queue.fal.run/fal-ai/${request.body.model}`, {
 +            method: 'POST',
 +            body: JSON.stringify(requestBody),
 +            headers: {
 +                'Content-Type': 'application/json',
 +                'Authorization': `Key ${key}`,
 +            },
 +        });
++
 +        if (!result.ok) {
 +            console.warn('FAL.AI returned an error.');
 +            return response.sendStatus(500);
 +        }
++
 +        /** @type {any} */
 +        const taskData = await result.json();
 +        const { status_url } = taskData;
++
 +        const MAX_ATTEMPTS = 100;
 +        for (let i = 0; i < MAX_ATTEMPTS; i++) {
 +            await delay(2500);
++
 +            const statusResult = await fetch(status_url, {
 +                headers: {
 +                    'Authorization': `Key ${key}`,
 +                },
 +            });
++
 +            if (!statusResult.ok) {
 +                const text = await statusResult.text();
 +                console.warn('FAL.AI returned an error.', text);
 +                return response.sendStatus(500);
 +            }
++
 +            /** @type {any} */
 +            const statusData = await statusResult.json();
++
 +            if (statusData?.status === 'IN_QUEUE' || statusData?.status === 'IN_PROGRESS') {
 +                continue;
 +            }
++
 +            if (statusData?.status === 'COMPLETED') {
 +                const resultFetch = await fetch(statusData?.response_url, {
 +                    method: 'GET',
 +                    headers: {
 +                        'Authorization': `Key ${key}`,
 +                    },
 +                });
 +                const resultData = await resultFetch.json();
++
 +                if (resultData.detail !== null && resultData.detail !== undefined) {
 +                    throw new Error('FAL.AI failed to generate image.', { cause: `${resultData.detail[0].loc[1]}: ${resultData.detail[0].msg}` });
 +                }
++
 +                const imageFetch = await fetch(resultData?.images[0].url, {
 +                    headers: {
 +                        'Authorization': `Key ${key}`,
 +                    },
 +                });
++
 +                const fetchData = await imageFetch.arrayBuffer();
 +                const image = Buffer.from(fetchData).toString('base64');
 +                return response.send({ image: image });
 +            }
++
 +            throw new Error('FAL.AI failed to generate image.', { cause: statusData });
 +        }
 +    } catch (error) {
 +        console.error(error);
 +        return response.status(500).send(error.cause || error.message);
 +    }
 +});
++
 router.use('/comfy', comfy);
 router.use('/together', together);
 router.use('/drawthings', drawthings);

 router.use('/huggingface', huggingface);
 router.use('/nanogpt', nanogpt);
 router.use('/bfl', bfl);
 +router.use('/falai', falai);