NanoGPT: Add to image generation extension

77be125a9949dcd98d1d78ba1f79972c295f45d4

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

Parents: 649c3911eb458abdc40b3722ce6e0ce22d7c56a5

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

     stability: 'stability',
     blockentropy: 'blockentropy',
     huggingface: 'huggingface',
+    nanogpt: 'nanogpt',
 };
 const initiators = {

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

         case sources.huggingface:
             samplers = ['N/A'];
             break;
+        case sources.nanogpt:
+            samplers = ['N/A'];
+            break;
+    }
     for (const sampler of samplers) {

         case sources.huggingface:
             models = [{ value: '', text: '<Enter Model ID above>' }];
             break;
+        case sources.nanogpt:
+            models = await loadNanoGPTModels();
+            break;
+    }
     for (const model of models) {

     return [];
+}
+async function loadNanoGPTModels() {
+    if (!secret_state[SECRET_KEYS.NANOGPT]) {
+        console.debug('NanoGPT API key is not set.');
+        return [];
+    }
+    const result = await fetch('/api/sd/nanogpt/models', {
+        method: 'POST',
+        headers: getRequestHeaders(),
+    });
+    if (result.ok) {
+        const data = await result.json();
+        return data;
+    }
+    return [];
+}
 async function loadHordeModels() {
     const result = await fetch('/api/horde/sd-models', {
         method: 'POST',

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

         case sources.huggingface:
             vaes = ['N/A'];
             break;
+        case sources.nanogpt:
+            vaes = ['N/A'];
+            break;
+    }
     for (const vae of vaes) {

             case sources.huggingface:
                 result = await generateHuggingFaceImage(prefixedPrompt, signal);
                 break;
+            case sources.nanogpt:
+                result = await generateNanoGPTImage(prefixedPrompt, negativePrompt, signal);
+        }
         if (!result.data) {

+    }
+}
+/**
+ * Generates an image using the NanoGPT 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 generateNanoGPTImage(prompt, negativePrompt, signal) {
+    const result = await fetch('/api/sd/nanogpt/generate', {
+        method: 'POST',
+        headers: getRequestHeaders(),
+        signal: signal,
+        body: JSON.stringify({
+            model: extension_settings.sd.model,
+            prompt: prompt,
+            negative_prompt: negativePrompt,
+            num_steps: parseInt(extension_settings.sd.steps),
+            scale: parseFloat(extension_settings.sd.scale),
+            width: parseInt(extension_settings.sd.width),
+            height: parseInt(extension_settings.sd.height),
+            resolution: `${extension_settings.sd.width}x${extension_settings.sd.height}`,
+            showExplicitContent:  true,
+            nImages: 1,
+        }),
+    });
+    if (result.ok) {
+        const data = await result.json();
+        return { format: 'jpg', data: data.image };
+    } else {
+        const text = await result.text();
+        throw new Error(text);
+    }
+}
 async function onComfyOpenWorkflowEditorClick() {
     let workflow = await (await fetch('/api/sd/comfy/workflow', {

@@ -3591,6 +3660,8 @@ function isValidState() {
3591	return secret_state[SECRET_KEYS.BLOCKENTROPY];	3660	return secret_state[SECRET_KEYS.BLOCKENTROPY];
3592	case sources.huggingface:	3661	case sources.huggingface:
3593	return secret_state[SECRET_KEYS.HUGGINGFACE];	3662	return secret_state[SECRET_KEYS.HUGGINGFACE];
		3663	case sources.nanogpt:
		3664	return secret_state[SECRET_KEYS.NANOGPT];
3594	}	3665	}
3595	}	3666	}
3596		3667

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

                 <option value="drawthings">DrawThings HTTP API</option>
                 <option value="extras">Extras API (local / remote)</option>
                 <option value="huggingface">HuggingFace Inference API (serverless)</option>
+                <option value="nanogpt">NanoGPT</option>
                 <option value="novel">NovelAI Diffusion</option>
                 <option value="openai">OpenAI (DALL-E)</option>
                 <option value="pollinations">Pollinations</option>

                 <label for="sd_huggingface_model_id" data-i18n="Model ID">Model ID</label>
                 <input id="sd_huggingface_model_id" type="text" class="text_pole"  data-i18n="[placeholder]e.g. black-forest-labs/FLUX.1-dev" placeholder="e.g. black-forest-labs/FLUX.1-dev" value="" />
             </div>
+            <div data-sd-source="nanogpt">
+                <i>Hint: Save an API key in the NanoGPT (Chat Completion) API settings to use it here.</i>
+            </div>
             <div data-sd-source="vlad">
                 <label for="sd_vlad_url">SD.Next API URL</label>
                 <div class="flex-container flexnowrap">

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

+    }
 });
+const nanogpt = express.Router();
+nanogpt.post('/models', jsonParser, async (request, response) => {
+    try {
+        const key = readSecret(request.user.directories, SECRET_KEYS.NANOGPT);
+        if (!key) {
+            console.log('NanoGPT key not found.');
+            return response.sendStatus(400);
+        }
+        const modelsResponse = await fetch('https://nano-gpt.com/api/models', {
+            method: 'GET',
+            headers: {
+                'x-api-key': key,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!modelsResponse.ok) {
+            console.log('NanoGPT returned an error.');
+            return response.sendStatus(500);
+        }
+        /** @type {any} */
+        const data = await modelsResponse.json();
+        const imageModels = data?.models?.image;
+        if (!imageModels || typeof imageModels !== 'object') {
+            console.log('NanoGPT returned invalid data.');
+            return response.sendStatus(500);
+        }
+        const models = Object.values(imageModels).map(x => ({ value: x.model, text: x.name }));
+        return response.send(models);
+    }
+    catch (error) {
+        console.log(error);
+        return response.sendStatus(500);
+    }
+});
+nanogpt.post('/generate', jsonParser, async (request, response) => {
+    try {
+        const key = readSecret(request.user.directories, SECRET_KEYS.NANOGPT);
+        if (!key) {
+            console.log('NanoGPT key not found.');
+            return response.sendStatus(400);
+        }
+        console.log('NanoGPT request:', request.body);
+        const result = await fetch('https://nano-gpt.com/api/generate-image', {
+            method: 'POST',
+            body: JSON.stringify(request.body),
+            headers: {
+                'x-api-key': key,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!result.ok) {
+            console.log('NanoGPT returned an error.');
+            return response.sendStatus(500);
+        }
+        /** @type {any} */
+        const data = await result.json();
+        const image = data?.data?.[0]?.b64_json;
+        if (!image) {
+            console.log('NanoGPT returned invalid data.');
+            return response.sendStatus(500);
+        }
+        return response.send({ image });
+    }
+    catch (error) {
+        console.log(error);
+        return response.sendStatus(500);
+    }
+});
 router.use('/comfy', comfy);
 router.use('/together', together);

 router.use('/stability', stability);
 router.use('/blockentropy', blockentropy);
 router.use('/huggingface', huggingface);
+router.use('/nanogpt', nanogpt);