a9c377c3 · permissionBRICK/SillyTavern

public/img/workers_ai.svg+9 -0 Viewed

+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="64" height="64">
+    <path d="M8.16 23h21.177v-5.86l-4.023-2.307-.694-.3-16.46.113z" fill="none" />
+    <path
+        d="M22.012 22.222c.197-.675.122-1.294-.206-1.754-.3-.422-.807-.666-1.416-.694l-11.545-.15c-.075 0-.14-.038-.178-.094s-.047-.13-.028-.206c.038-.113.15-.197.272-.206l11.648-.15c1.38-.066 2.88-1.182 3.404-2.55l.666-1.735a.38.38 0 0 0 .02-.225c-.75-3.395-3.78-5.927-7.4-5.927-3.34 0-6.17 2.157-7.184 5.15-.657-.488-1.5-.75-2.392-.666-1.604.16-2.9 1.444-3.048 3.048a3.58 3.58 0 0 0 .084 1.191A4.84 4.84 0 0 0 0 22.1c0 .234.02.47.047.703.02.113.113.197.225.197H21.58a.29.29 0 0 0 .272-.206l.16-.572z"
+        />
+    <path
+        d="M25.688 14.803l-.32.01c-.075 0-.14.056-.17.13l-.45 1.566c-.197.675-.122 1.294.206 1.754.3.422.807.666 1.416.694l2.457.15c.075 0 .14.038.178.094s.047.14.028.206c-.038.113-.15.197-.272.206l-2.56.15c-1.388.066-2.88 1.182-3.404 2.55l-.188.478c-.038.094.028.188.13.188h8.797a.23.23 0 0 0 .225-.169A6.41 6.41 0 0 0 32 21.106a6.32 6.32 0 0 0-6.312-6.302"
+         />
+</svg>
 \ No newline at end of file

public/scripts/extensions/caption/index.js+6 -2 Viewed

 import { appendMediaToMessage, chat_metadata, eventSource, event_types, getRequestHeaders, saveChatConditional, saveSettingsDebounced, substituteParamsExtended } from '../../../script.js';
 import { getMessageTimeStamp } from '../../RossAscends-mods.js';
 import { SECRET_KEYS, secret_state } from '../../secrets.js';
+import { oai_settings } from '../../openai.js';
 import { getMultimodalCaption } from '../shared.js';
 import { textgen_types, textgenerationwebui_settings } from '../../textgen-settings.js';
 import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';

                         'chutes': SECRET_KEYS.CHUTES,
                         'electronhub': SECRET_KEYS.ELECTRONHUB,
                         'pollinations': SECRET_KEYS.POLLINATIONS,
+                        'workers_ai': SECRET_KEYS.WORKERS_AI,
                     };
                     if (chatCompletionApis[api] && secret_state[chatCompletionApis[api]]) {

+    }
     async function addRemoteEndpointModels() {
-        async function processEndpoint(api, url) {
+        async function processEndpoint(api, url, additionalParams = {}) {
             const dropdown = document.getElementById('caption_multimodal_model');
             if (!(dropdown instanceof HTMLSelectElement)) {
                 return;

             const options = Array.from(dropdown.options);
             const response = await fetch(url, {
                 method: 'POST',
-                headers: getRequestHeaders({ omitContentType: true }),
+                headers: getRequestHeaders(),
+                body: JSON.stringify(additionalParams),
             });
             if (!response.ok) {
                 return;

         await processEndpoint('mistral', '/api/backends/chat-completions/multimodal-models/mistral');
         await processEndpoint('xai', '/api/backends/chat-completions/multimodal-models/xai');
         await processEndpoint('moonshot', '/api/backends/chat-completions/multimodal-models/moonshot');
+        await processEndpoint('workers_ai', '/api/backends/chat-completions/multimodal-models/workers_ai', { workers_ai_account_id: oai_settings.workers_ai_account_id });
+    }
     await addSettings();

public/scripts/extensions/caption/settings.html+1 -0 Viewed

                         <option value="aimlapi">AI/ML API</option>
                         <option value="chutes">Chutes</option>
                         <option value="anthropic">Claude</option>
+                        <option value="workers_ai">Cloudflare Workers AI</option>
                         <option value="cohere">Cohere</option>
                         <option value="custom" data-i18n="Custom (OpenAI-compatible)">Custom (OpenAI-compatible)</option>
                         <option value="electronhub">Electron Hub</option>

public/scripts/extensions/shared.js+8 -0 Viewed

         requestBody.zai_endpoint = oai_settings.zai_endpoint || ZAI_ENDPOINT.COMMON;
+    }
+    if (extension_settings.caption.multimodal_api === 'workers_ai') {
+        requestBody.workers_ai_account_id = oai_settings.workers_ai_account_id;
+    }
     function getEndpointUrl() {
         switch (extension_settings.caption.multimodal_api) {
             case 'google':

@@ -283,6 +287,10 @@ function throwIfInvalidModel(useReverseProxy) {
283	if (multimodalApi === 'pollinations' && !secret_state[SECRET_KEYS.POLLINATIONS]) {	287	if (multimodalApi === 'pollinations' && !secret_state[SECRET_KEYS.POLLINATIONS]) {
284	throw new Error('Pollinations API key is not set.');	288	throw new Error('Pollinations API key is not set.');
285	}	289	}
		290
		291	if (multimodalApi === 'workers_ai' && (!secret_state[SECRET_KEYS.WORKERS_AI] \|\| !oai_settings.workers_ai_account_id)) {
		292	throw new Error('Workers AI API key or account ID is not set.');
		293	}
286	}	294	}
287		295
288	/**	296	/**

public/scripts/extensions/vectors/index.js+59 -0 Viewed

                     return 'Extras API must provide an "embeddings" module.';
                 case 'webllm_not_supported':
                     return 'WebLLM extension is not installed or the model is not set.';
+                case 'account_id_missing':
+                    return 'Workers AI account ID is required. Save it in the "API Connections" panel.';
                 default:
                     return 'Check server console for more details';
+            }

             body.model = extension_settings.vectors.siliconflow_model;
             body.siliconflow_endpoint = oai_settings.siliconflow_endpoint;
             break;
+        case 'workers_ai':
+            body.model = extension_settings.vectors.workers_ai_model || '@cf/baai/bge-m3';
+            body.workers_ai_account_id = oai_settings.workers_ai_account_id;
+            break;
         default:
             break;
+    }

         settings.source === 'togetherai' && !secret_state[SECRET_KEYS.TOGETHERAI] ||
         settings.source === 'nomicai' && !secret_state[SECRET_KEYS.NOMICAI] ||
         settings.source === 'cohere' && !secret_state[SECRET_KEYS.COHERE] ||
+        settings.source === 'workers_ai' && !secret_state[SECRET_KEYS.WORKERS_AI] ||
         settings.source === 'siliconflow' && !secret_state[SECRET_KEYS.SILICONFLOW]) {
         throw new Error('Vectors: API key missing', { cause: 'api_key_missing' });
+    }

@@ -964,6 +971,10 @@ function throwIfSourceInvalid() {
964	if (settings.source === 'webllm' && (!isWebLlmSupported() \|\| !settings.webllm_model)) {	971	if (settings.source === 'webllm' && (!isWebLlmSupported() \|\| !settings.webllm_model)) {
965	throw new Error('Vectors: WebLLM is not supported', { cause: 'webllm_not_supported' });	972	throw new Error('Vectors: WebLLM is not supported', { cause: 'webllm_not_supported' });
966	}	973	}
		974
		975	if (settings.source === 'workers_ai' && !oai_settings.workers_ai_account_id) {
		976	throw new Error('Vectors: Workers AI account ID missing', { cause: 'account_id_missing' });
		977	}
967	}	978	}
968		979
969	/**	980	/**

     $('#koboldcpp_vectorsModel').toggle(settings.source === 'koboldcpp');
     $('#google_vectorsModel').toggle(settings.source === 'palm' || settings.source === 'vertexai');
     $('#siliconflow_vectorsModel').toggle(settings.source === 'siliconflow');
+    $('#workers_ai_vectorsModel').toggle(settings.source === 'workers_ai');
     $('#vector_altEndpointUrl').toggle(vectorApiRequiresUrl.includes(settings.source));
     switch (settings.source) {
         case 'webllm':

@@ -1175,6 +1187,9 @@ function toggleSettings() {
1175	case 'siliconflow':	1187	case 'siliconflow':
1176	loadSiliconFlowModels();	1188	loadSiliconFlowModels();
1177	break;	1189	break;
		1190	case 'workers_ai':
		1191	loadWorkersAIModels();
		1192	break;
1178	}	1193	}
1179	}	1194	}
1180		1195

     $('#vectors_siliconflow_model').val(settings.siliconflow_model);
+}
+async function loadWorkersAIModels() {
+    try {
+        const response = await fetch('/api/openai/workers-ai/models/embedding', {
+            method: 'POST',
+            headers: getRequestHeaders(),
+            body: JSON.stringify({
+                workers_ai_account_id: oai_settings.workers_ai_account_id,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        /** @type {Array<any>} */
+        const data = await response.json();
+        const models = Array.isArray(data) ? data : [];
+        populateWorkersAIModelSelect(models);
+    } catch (err) {
+        console.warn('Workers AI models fetch failed', err);
+        populateWorkersAIModelSelect([]);
+    }
+}
+function populateWorkersAIModelSelect(models) {
+    const select = $('#vectors_workers_ai_model');
+    select.empty();
+    for (const m of models) {
+        const option = document.createElement('option');
+        option.value = m.id;
+        option.text = m.id;
+        select.append(option);
+    }
+    if (!settings.workers_ai_model && models.length) {
+        settings.workers_ai_model = models[0].id;
+        Object.assign(extension_settings.vectors, settings);
+        saveSettingsDebounced();
+    }
+    $('#vectors_workers_ai_model').val(settings.workers_ai_model);
+}
 /**
  * Executes a function with WebLLM error handling.
  * @param {function(): Promise<T>} func Function to execute

         Object.assign(extension_settings.vectors, settings);
         saveSettingsDebounced();
     });
+    $('#vectors_workers_ai_model').val(settings.workers_ai_model).on('change', () => {
+        settings.workers_ai_model = String($('#vectors_workers_ai_model').val());
+        Object.assign(extension_settings.vectors, settings);
+        saveSettingsDebounced();
+    });
     $('#vectors_openrouter_model').val(settings.openrouter_model).on('change', () => {
         settings.openrouter_model = String($('#vectors_openrouter_model').val());
         Object.assign(extension_settings.vectors, settings);

public/scripts/extensions/vectors/settings.html+11 -0 Viewed

                 </label>
                 <select id="vectors_source" class="text_pole">
                     <option value="chutes">Chutes</option>
+                    <option value="workers_ai">Cloudflare Workers AI</option>
                     <option value="cohere">Cohere</option>
                     <option value="electronhub">Electron Hub</option>
                     <option value="extras">Extras (deprecated)</option>

                 </i>
             </div>
+            <div class="flex-container flexFlowColumn" id="workers_ai_vectorsModel">
+                <label for="vectors_workers_ai_model" data-i18n="Vectorization Model">
+                    Vectorization Model
+                </label>
+                <select id="vectors_workers_ai_model" class="text_pole"></select>
+                <i data-i18n="Hint: Set your Workers AI API key and Account ID in API Connections.">
+                    Hint: Set your Workers AI API key and Account ID in API Connections.
+                </i>
+            </div>
             <div class="flex-container marginTopBot5">
                 <div class="flex-container flex1 flexFlowColumn" title="How many last messages will be matched for relevance.">
                     <label for="vectors_query">

src/endpoints/backends/chat-completions.js+33 -0 Viewed

+    }
 });
+multimodalModels.post('/workers_ai', async (req, res) => {
+    try {
+        const key = readSecret(req.user.directories, SECRET_KEYS.WORKERS_AI);
+        const accountId = String(req.body.workers_ai_account_id || '').trim();
+        if (!key || !accountId) {
+            return res.json([]);
+        }
+        const apiUrl = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/models/search?task=Text+Generation&per_page=1000`;
+        const response = await fetch(apiUrl, {
+            method: 'GET',
+            headers: { 'Authorization': 'Bearer ' + key },
+        });
+        if (!response.ok) {
+            return res.json([]);
+        }
+        /** @type {any} */
+        const data = await response.json();
+        const models = Array.isArray(data?.result)
+            ? data.result
+                .filter(m => Array.isArray(m.properties) && m.properties.some(p => p.property_id === 'vision' && p.value === 'true'))
+                .map(m => m.name)
+            : [];
+        return res.json(models);
+    } catch (error) {
+        console.error(error);
+        return res.sendStatus(500);
+    }
+});
 router.use('/multimodal-models', multimodalModels);
 router.post('/process', async function (request, response) {

src/endpoints/openai.js+56 -0 Viewed

             bodyParams.seed = Math.floor(Math.random() * Math.pow(2, 32));
+        }
+        if (request.body.api === 'workers_ai') {
+            key = readSecret(request.user.directories, SECRET_KEYS.WORKERS_AI);
+        }
         const noKeyTypes = ['custom', 'ooba', 'koboldcpp', 'vllm', 'llamacpp'];
         if (!key && !request.body.reverse_proxy && !noKeyTypes.includes(request.body.api)) {
             console.warn('No key found for API', request.body.api);

@@ -216,6 +220,14 @@ router.post('/caption-image', async (request, response) => {
216	}	220	}
217	}	221	}
218		222
		223	if (request.body.api === 'workers_ai') {
		224	const accountId = String(request.body.workers_ai_account_id \|\| '').trim();
		225	if (!accountId) {
		226	return response.status(400).send({ error: 'Cloudflare Workers AI Account ID is required' });
		227	}
		228	apiUrl = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/v1/chat/completions`;
		229	}
		230
219	if (['koboldcpp', 'vllm', 'llamacpp', 'ooba'].includes(request.body.api)) {	231	if (['koboldcpp', 'vllm', 'llamacpp', 'ooba'].includes(request.body.api)) {
220	apiUrl = `${trimV1(request.body.server_url)}/v1/chat/completions`;	232	apiUrl = `${trimV1(request.body.server_url)}/v1/chat/completions`;
221	}	233	}

+    }
 });
+router.post('/workers-ai/models/embedding', async (request, response) => {
+    try {
+        const key = readSecret(request.user.directories, SECRET_KEYS.WORKERS_AI);
+        if (!key) {
+            console.warn('No Workers AI key found');
+            return response.sendStatus(400);
+        }
+        const accountId = String(request.body.workers_ai_account_id || '').trim();
+        if (!accountId) {
+            console.warn('No Workers AI account ID found');
+            return response.sendStatus(400);
+        }
+        const apiUrl = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/models/search?task=Text+Embeddings&per_page=100`;
+        const result = await fetch(apiUrl, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${key}`,
+            },
+        });
+        if (!result.ok) {
+            const text = await result.text();
+            console.warn('Workers AI embedding models request failed', result.statusText, text);
+            return response.status(500).send(text);
+        }
+        /** @type {any} */
+        const data = await result.json();
+        if (!Array.isArray(data?.result)) {
+            console.warn('Workers AI embedding models response invalid', data);
+            return response.sendStatus(500);
+        }
+        return response.json(data.result.map(m => ({ ...m, id: m.name })));
+    } catch (error) {
+        console.error('Workers AI embedding models fetch failed', error);
+        response.sendStatus(500);
+    }
+});
 router.post('/generate-image', async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);

src/endpoints/vectors.js+15 -0 Viewed

     'chutes',
     'nanogpt',
     'siliconflow',
+    'workers_ai',
 ];
 /**

             return getOpenAIVector(text, source, directories, sourceSettings.model);
         case 'siliconflow':
             return getOpenAIVector(text, source, directories, sourceSettings.model, sourceSettings.urlOverride);
+        case 'workers_ai':
+            return getOpenAIVector(text, source, directories, sourceSettings.model, sourceSettings.urlOverride);
+    }
     throw new Error(`Unknown vector source ${source}`);

             case 'siliconflow':
                 results.push(...await getOpenAIBatchVector(batch, source, directories, sourceSettings.model, sourceSettings.urlOverride));
                 break;
+            case 'workers_ai':
+                results.push(...await getOpenAIBatchVector(batch, source, directories, sourceSettings.model, sourceSettings.urlOverride));
+                break;
             default:
                 throw new Error(`Unknown vector source ${source}`);
+        }

                 urlOverride: request.body.siliconflow_endpoint === 'cn'
                     ? 'https://api.siliconflow.cn/v1' : null,
             };
+        case 'workers_ai': {
+            const accountId = String(request.body.workers_ai_account_id || '').trim();
+            return {
+                model: String(request.body.model || '@cf/baai/bge-m3'),
+                urlOverride: accountId
+                    ? `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/v1`
+                    : null,
+            };
+        }
         default:
             return {};
+    }

src/vectors/openai-vectors.js+13 -1 Viewed

         headers: {},
         processBody: () => {},
     },
+    'workers_ai': {
+        secretKey: SECRET_KEYS.WORKERS_AI,
+        url: '', // Constructed at runtime from account ID via urlOverride
+        model: '@cf/baai/bge-m3',
+        headers: {},
+        processBody: () => {},
+    },
 };
 /**

+    }
     const modelName = model || config.model;
-    const url = urlOverride || config.url.replace('{{MODEL}}', modelName);
+    const url = urlOverride || config.url?.replace('{{MODEL}}', modelName);
+    if (!url) {
+        throw new Error(`No API URL configured for source ${source}`);
+    }
     const body = {
         input: texts,
         model: modelName,