Stable diffusion.cpp server support (#5074) * feat: Add stable-diffusion.cpp server endpoints * feat: Add stable-diffusion.cpp server settings * feat: Add stable-diffusion.cpp server * Add debug log for sdcpp payload * feat: add loadSdcppSamplers and loadSdcppSchedulers for sdcpp backend * feat: add sdcpp to sampler and scheduler source lists --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

12452491cbf8b64f8f40ac93e2dd0dfb9054c2b4

Jay4242 <96741732+Jay4242@users.noreply.github.com>

Signed

Parents: 10e8e01a554d1f4fc6b0a358e03b65ab0e84bc76

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

     extras: 'extras',
     horde: 'horde',
     auto: 'auto',
+    sdcpp: 'sdcpp',
     novel: 'novel',
     vlad: 'vlad',
     openai: 'openai',

     auto_url: 'http://localhost:7860',
     auto_auth: '',
+    // stable-diffusion.cpp settings
+    sdcpp_url: 'http://127.0.0.1:1234',
     vlad_url: 'http://localhost:7860',
     vlad_auth: '',

     $('#sd_multimodal_captioning').prop('checked', extension_settings.sd.multimodal_captioning);
     $('#sd_auto_url').val(extension_settings.sd.auto_url);
     $('#sd_auto_auth').val(extension_settings.sd.auto_auth);
+    $('#sd_sdcpp_url').val(extension_settings.sd.sdcpp_url);
     $('#sd_vlad_url').val(extension_settings.sd.vlad_url);
     $('#sd_vlad_auth').val(extension_settings.sd.vlad_auth);
     $('#sd_drawthings_url').val(extension_settings.sd.drawthings_url);

     saveSettingsDebounced();
+}
+function onSdcppUrlInput() {
+    extension_settings.sd.sdcpp_url = $('#sd_sdcpp_url').val();
+    saveSettingsDebounced();
+}
 function onVladUrlInput() {
     extension_settings.sd.vlad_url = $('#sd_vlad_url').val();
     saveSettingsDebounced();

+    }
+}
+async function validateSdcppUrl() {
+    try {
+        if (!extension_settings.sd.sdcpp_url) {
+            throw new Error('URL is not set.');
+        }
+        const result = await fetch('/api/sd/sdcpp/ping', {
+            method: 'POST',
+            headers: getRequestHeaders(),
+            body: JSON.stringify({ url: extension_settings.sd.sdcpp_url }),
+        });
+        if (!result.ok) {
+            throw new Error('stable-diffusion.cpp server returned an error.');
+        }
+        await loadSettingOptions();
+        toastr.success('stable-diffusion.cpp server connected.');
+    } catch (error) {
+        toastr.error(`Could not validate stable-diffusion.cpp server: ${error.message}`);
+    }
+}
 async function validateDrawthingsUrl() {
     try {
         if (!extension_settings.sd.drawthings_url) {

         case sources.auto:
             samplers = await loadAutoSamplers();
             break;
+        case sources.sdcpp:
+            samplers = await loadSdcppSamplers();
+            break;
         case sources.drawthings:
             samplers = await loadDrawthingsSamplers();
             break;

@@ -1682,6 +1718,11 @@ async function loadAutoSamplers() {
1682	}	1718	}
1683	}	1719	}
1684		1720
		1721	async function loadSdcppSamplers() {
		1722	// The sdcpp server does not provide an API for samplers, so we return the known list.
		1723	return ['euler', 'euler_a', 'heun', 'dpm2', 'dpm++2s_a', 'dpm++2m', 'dpm++2mv2', 'ipndm', 'ipndm_v', 'lcm', 'ddim_trailing', 'tcd'];
		1724	}
		1725
1685	async function loadDrawthingsSamplers() {	1726	async function loadDrawthingsSamplers() {
1686	// The app developer doesn't provide an API to get these yet	1727	// The app developer doesn't provide an API to get these yet
1687	return [	1728	return [

         case sources.auto:
             models = await loadAutoModels();
             break;
+        case sources.sdcpp:
+            models = [{ value: '', text: 'N/A' }];
+            break;
         case sources.drawthings:
             models = await loadDrawthingsModels();
             break;

         case sources.auto:
             schedulers = await getAutoRemoteSchedulers();
             break;
+        case sources.sdcpp:
+            schedulers = await loadSdcppSchedulers();
+            break;
         case sources.novel:
             schedulers = loadNovelSchedulers();
             break;

@@ -2477,6 +2524,11 @@ async function loadComfySchedulers() {
2477	}	2524	}
2478	}	2525	}
2479		2526
		2527	async function loadSdcppSchedulers() {
		2528	// The sdcpp server does not provide an API for schedulers, so we return the known list.
		2529	return ['discrete', 'karras', 'exponential', 'ays', 'gits', 'smoothstep', 'sgm_uniform', 'simple', 'kl_optimal', 'lcm'];
		2530	}
		2531
2480	async function loadVaes() {	2532	async function loadVaes() {
2481	$('#sd_vae').empty();	2533	$('#sd_vae').empty();
2482	let vaes = [];	2534	let vaes = [];

         case sources.auto:
             vaes = await loadAutoVaes();
             break;
+        case sources.sdcpp:
+            vaes = ['N/A'];
+            break;
         case sources.novel:
             vaes = ['N/A'];
             break;

             case sources.auto:
                 result = await generateAutoImage(prefixedPrompt, negativePrompt, signal);
                 break;
+            case sources.sdcpp:
+                result = await generateSdcppImage(prefixedPrompt, negativePrompt, signal);
+                break;
             case sources.novel:
                 result = await generateNovelImage(prefixedPrompt, negativePrompt, signal);
                 break;

+}
 /**
+ * Generates an image using stable-diffusion.cpp server API.
+ *
+ * @param {string} prompt - The main instruction used to guide the image generation.
+ * @param {string} negativePrompt - The instruction used to restrict 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 generateSdcppImage(prompt, negativePrompt, signal) {
+    const payload = {
+        url: extension_settings.sd.sdcpp_url,
+        prompt: prompt,
+        negative_prompt: negativePrompt,
+        steps: extension_settings.sd.steps,
+        cfg_scale: extension_settings.sd.scale,
+        width: extension_settings.sd.width,
+        height: extension_settings.sd.height,
+        batch_size: 1,
+        seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
+    };
+    if (extension_settings.sd.sampler && extension_settings.sd.sampler !== 'N/A') {
+        payload.sampler_name = extension_settings.sd.sampler;
+    }
+    if (extension_settings.sd.scheduler && extension_settings.sd.scheduler !== 'N/A') {
+        payload.scheduler = extension_settings.sd.scheduler;
+    }
+    if (Number.isFinite(extension_settings.sd.clip_skip)) {
+        payload.clip_skip = extension_settings.sd.clip_skip;
+    }
+    const result = await fetch('/api/sd/sdcpp/generate', {
+        method: 'POST',
+        headers: getRequestHeaders(),
+        signal: signal,
+        body: JSON.stringify(payload),
+    });
+    if (result.ok) {
+        const data = await result.json();
+        return { format: 'png', data: data.images?.[0] };
+    } else {
+        const text = await result.text();
+        throw new Error(text);
+    }
+}
+/**
  * Generates an image in Drawthings API using the provided prompt and configuration settings.
+ *
  * @param {string} prompt - The main instruction used to guide the image generation.

             return true;
         case sources.auto:
             return !!extension_settings.sd.auto_url;
+        case sources.sdcpp:
+            return !!extension_settings.sd.sdcpp_url;
         case sources.drawthings:
             return !!extension_settings.sd.drawthings_url;
         case sources.vlad:

     $('#sd_auto_validate').on('click', validateAutoUrl);
     $('#sd_auto_url').on('input', onAutoUrlInput);
     $('#sd_auto_auth').on('input', onAutoAuthInput);
+    $('#sd_sdcpp_validate').on('click', validateSdcppUrl);
+    $('#sd_sdcpp_url').on('input', onSdcppUrlInput);
     $('#sd_drawthings_validate').on('click', validateDrawthingsUrl);
     $('#sd_drawthings_url').on('input', onDrawthingsUrlInput);
     $('#sd_drawthings_auth').on('input', onDrawthingsAuthInput);

public/scripts/extensions/stable-diffusion/settings.html+18 -4 Viewed

                 <option value="vlad">SD.Next (vladmandic)</option>
                 <option value="stability">Stability AI</option>
                 <option value="auto">Stable Diffusion Web UI (AUTOMATIC1111)</option>
+                <option value="sdcpp">stable-diffusion.cpp server</option>
                 <option value="horde">Stable Horde</option>
                 <option value="togetherai">TogetherAI</option>
                 <option value="xai">xAI (Grok)</option>

                 <!-- (Original Text)<b>Important:</b> run SD Web UI with the <tt>--api</tt> flag! The server must be accessible from the SillyTavern host machine. -->
                 <i><b data-i18n="Important:">Important:</b></i><i data-i18n="sd_auto_auth_warning_1"> run SD Web UI with the </i><i><tt>--api</tt></i><i data-i18n="sd_auto_auth_warning_2"> flag! The server must be accessible from the SillyTavern host machine.</i>
             </div>
+            <div data-sd-source="sdcpp">
+                <label for="sd_sdcpp_url">stable-diffusion.cpp URL</label>
+                <div class="flex-container flexnowrap">
+                    <input id="sd_sdcpp_url" type="text" class="text_pole" placeholder="Example: {{sdcpp_url}}" value="{{sdcpp_url}}" />
+                    <div id="sd_sdcpp_validate" class="menu_button menu_button_icon">
+                        <i class="fa-solid fa-check"></i>
+                        <span data-i18n="Connect">
+                            Connect
+                        </span>
+                    </div>
+                </div>
+                <i data-i18n="The server must be accessible from the SillyTavern host machine.">The server must be accessible from the SillyTavern host machine.</i>
+            </div>
             <div data-sd-source="drawthings">
                 <label for="sd_drawthings_url">DrawThings API URL</label>
                 <div class="flex-container flexnowrap">

             </div>
             <div class="flex-container">
-                <div class="flex1" data-sd-source="extras,horde,auto,drawthings,novel,vlad,comfy">
+                <div class="flex1" data-sd-source="extras,horde,auto,drawthings,novel,vlad,comfy,sdcpp">
                     <label for="sd_sampler" data-i18n="Sampling method">Sampling method</label>
                     <select id="sd_sampler"></select>
                 </div>
-                <div class="flex1" data-sd-source="comfy,auto,novel">
+                <div class="flex1" data-sd-source="comfy,auto,novel,sdcpp">
                     <label for="sd_scheduler" data-i18n="Scheduler">Scheduler</label>
                     <select id="sd_scheduler"></select>
                 </div>

                     <input class="neo-range-input" type="number" id="sd_hr_second_pass_steps_value" data-for="sd_hr_second_pass_steps" max="{{hr_second_pass_steps_max}}" step="{{hr_second_pass_steps_step}}" value="{{hr_second_pass_steps}}" >
                 </div>
-                <div class="alignitemscenter flex-container flexFlowColumn flexGrow flexShrink gap0 flexBasis48p" data-sd-source="auto,vlad,comfy,horde,drawthings,extras">
+                <div class="alignitemscenter flex-container flexFlowColumn flexGrow flexShrink gap0 flexBasis48p" data-sd-source="auto,vlad,comfy,horde,drawthings,extras,sdcpp">
                     <small>
                         <span data-i18n="CLIP Skip">CLIP Skip</span>
                     </small>

                 </label>
             </div>
-            <div data-sd-source="novel,togetherai,pollinations,comfy,drawthings,vlad,auto,horde,extras,stability,bfl" class="marginTop5">
+            <div data-sd-source="novel,togetherai,pollinations,comfy,drawthings,vlad,auto,horde,extras,stability,bfl,sdcpp" class="marginTop5">
                 <label for="sd_seed">
                     <span data-i18n="Seed">Seed</span>
                     <small data-i18n="(-1 for random)">(-1 for random)</small>

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

+    }
 });
+const sdcpp = express.Router();
+sdcpp.post('/ping', async (request, response) => {
+    try {
+        const url = new URL(request.body.url);
+        url.pathname = '/v1/images/generations';
+        const result = await fetch(url, { method: 'OPTIONS' });
+        if (!result.ok) {
+            throw new Error('stable-diffusion.cpp server returned an error.');
+        }
+        return response.sendStatus(200);
+    } catch (error) {
+        console.error(error);
+        return response.sendStatus(500);
+    }
+});
+sdcpp.post('/generate', async (request, response) => {
+    try {
+        const url = new URL(request.body.url);
+        url.pathname = '/sdapi/v1/txt2img';
+        const payload = {
+            prompt: request.body.prompt,
+            negative_prompt: request.body.negative_prompt,
+            width: request.body.width,
+            height: request.body.height,
+            steps: request.body.steps,
+            cfg_scale: request.body.cfg_scale,
+            seed: request.body.seed,
+            batch_size: request.body.batch_size,
+            sampler_name: request.body.sampler_name,
+            scheduler: request.body.scheduler,
+            clip_skip: request.body.clip_skip,
+        };
+        for (const [key, value] of Object.entries(payload)) {
+            if (value === undefined || value === null || value === '') {
+                delete payload[key];
+            }
+        }
+        console.debug('stable-diffusion.cpp request:', payload);
+        const result = await fetch(url, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!result.ok) {
+            const text = await result.text();
+            throw new Error('stable-diffusion.cpp server returned an error.', { cause: text });
+        }
+        const data = await result.json();
+        return response.send(data);
+    } catch (error) {
+        console.error(error);
+        return response.sendStatus(500);
+    }
+});
 const drawthings = express.Router();
 drawthings.post('/ping', async (request, response) => {

 router.use('/comfy', comfy);
 router.use('/comfyrunpod', comfyRunPod);
 router.use('/together', together);
+router.use('/sdcpp', sdcpp);
 router.use('/drawthings', drawthings);
 router.use('/pollinations', pollinations);
 router.use('/stability', stability);