Vectors: Don't use headers for source-specific fields in requests

058c86f3c1e7eba81029236f9d695196f1668e2a

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

Parents: a771dd54780fb2b3e84bb7f5f4a583c78c251735

public/scripts/extensions/vectors/index.js+56 -62 Viewed

+}
 /**
- * Gets the saved hashes for a collection
+ * Gets common body parameters for vector requests.
-* @param {string} collectionId
+ * @returns {object}
-* @returns {Promise<number[]>} Saved hashes
  */
-async function getSavedHashes(collectionId) {
+function getVectorsRequestBody() {
-    const response = await fetch('/api/vector/list', {
+    const body = {};
-        method: 'POST',
-        headers: getVectorHeaders(),
-        body: JSON.stringify({
-            collectionId: collectionId,
-            source: settings.source,
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to get saved hashes for collection ${collectionId}`);
-    }
-    const hashes = await response.json();
-    return hashes;
-}
-function getVectorHeaders() {
-    const headers = getRequestHeaders();
     switch (settings.source) {
         case 'extras':
-            Object.assign(headers, {
+            body.extrasUrl =  extension_settings.apiUrl;
-                'X-Extras-Url': extension_settings.apiUrl,
+            body.extrasKey =  extension_settings.apiKey;
-                'X-Extras-Key': extension_settings.apiKey,
-            });
             break;
         case 'togetherai':
-            Object.assign(headers, {
+            body.model = extension_settings.vectors.togetherai_model;
-                'X-Togetherai-Model': extension_settings.vectors.togetherai_model,
-            });
             break;
         case 'openai':
-            Object.assign(headers, {
+            body.model = extension_settings.vectors.openai_model;
-                'X-OpenAI-Model': extension_settings.vectors.openai_model,
-            });
             break;
         case 'cohere':
-            Object.assign(headers, {
+            body.model = extension_settings.vectors.cohere_model;
-                'X-Cohere-Model': extension_settings.vectors.cohere_model,
-            });
             break;
         case 'ollama':
-            Object.assign(headers, {
+            body.model = extension_settings.vectors.ollama_model;
-                'X-Ollama-Model': extension_settings.vectors.ollama_model,
+            body.apiUrl = textgenerationwebui_settings.server_urls[textgen_types.OLLAMA];
-                'X-Ollama-URL': textgenerationwebui_settings.server_urls[textgen_types.OLLAMA],
+            body.keep = !!extension_settings.vectors.ollama_keep;
-                'X-Ollama-Keep': !!extension_settings.vectors.ollama_keep,
-            });
             break;
         case 'llamacpp':
-            Object.assign(headers, {
+            body.apiUrl = textgenerationwebui_settings.server_urls[textgen_types.LLAMACPP];
-                'X-LlamaCpp-URL': textgenerationwebui_settings.server_urls[textgen_types.LLAMACPP],
-            });
             break;
         case 'vllm':
-            Object.assign(headers, {
+            body.apiUrl = textgenerationwebui_settings.server_urls[textgen_types.VLLM];
-                'X-Vllm-URL': textgenerationwebui_settings.server_urls[textgen_types.VLLM],
+            body.model = extension_settings.vectors.vllm_model;
-                'X-Vllm-Model': extension_settings.vectors.vllm_model,
-            });
             break;
         default:
             break;
+    }
-    return headers;
+    return body;
+}
+/**
+ * Gets the saved hashes for a collection
+* @param {string} collectionId
+* @returns {Promise<number[]>} Saved hashes
+*/
+async function getSavedHashes(collectionId) {
+    const response = await fetch('/api/vector/list', {
+        method: 'POST',
+        headers: getRequestHeaders(),
+        body: JSON.stringify({
+            ...getVectorsRequestBody(),
+            collectionId: collectionId,
+            source: settings.source,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get saved hashes for collection ${collectionId}`);
+    }
+    const hashes = await response.json();
+    return hashes;
+}
 /**

 async function insertVectorItems(collectionId, items) {
     throwIfSourceInvalid();
-    const headers = getVectorHeaders();
     const response = await fetch('/api/vector/insert', {
         method: 'POST',
-        headers: headers,
+        headers: getRequestHeaders(),
         body: JSON.stringify({
+            ...getVectorsRequestBody(),
             collectionId: collectionId,
             items: items,
             source: settings.source,

 async function deleteVectorItems(collectionId, hashes) {
     const response = await fetch('/api/vector/delete', {
         method: 'POST',
-        headers: getVectorHeaders(),
+        headers: getRequestHeaders(),
         body: JSON.stringify({
+            ...getVectorsRequestBody(),
             collectionId: collectionId,
             hashes: hashes,
             source: settings.source,

  * @returns {Promise<{ hashes: number[], metadata: object[]}>} - Hashes of the results
  */
 async function queryCollection(collectionId, searchText, topK) {
-    const headers = getVectorHeaders();
     const response = await fetch('/api/vector/query', {
         method: 'POST',
-        headers: headers,
+        headers: getRequestHeaders(),
         body: JSON.stringify({
+            ...getVectorsRequestBody(),
             collectionId: collectionId,
             searchText: searchText,
             topK: topK,

  * @returns {Promise<Record<string, { hashes: number[], metadata: object[] }>>} - Results mapped to collection IDs
  */
 async function queryMultipleCollections(collectionIds, searchText, topK, threshold) {
-    const headers = getVectorHeaders();
     const response = await fetch('/api/vector/query-multi', {
         method: 'POST',
-        headers: headers,
+        headers: getRequestHeaders(),
         body: JSON.stringify({
+            ...getVectorsRequestBody(),
             collectionIds: collectionIds,
             searchText: searchText,
             topK: topK,

         const response = await fetch('/api/vector/purge', {
             method: 'POST',
-            headers: getVectorHeaders(),
+            headers: getRequestHeaders(),
             body: JSON.stringify({
+                ...getVectorsRequestBody(),
                 collectionId: collectionId,
             }),
         });

         const response = await fetch('/api/vector/purge', {
             method: 'POST',
-            headers: getVectorHeaders(),
+            headers: getRequestHeaders(),
             body: JSON.stringify({
+                ...getVectorsRequestBody(),
                 collectionId: collectionId,
             }),
         });

     try {
         const response = await fetch('/api/vector/purge-all', {
             method: 'POST',
-            headers: getVectorHeaders(),
+            headers: getRequestHeaders(),
+            body: JSON.stringify({
+                ...getVectorsRequestBody(),
+            }),
         });
         if (!response.ok) {

src/endpoints/vectors.js+11 -11 Viewed

     switch (source) {
         case 'togetherai':
             return {
-                model: String(request.headers['x-togetherai-model']),
+                model: String(request.body.model),
             };
         case 'openai':
             return {
-                model: String(request.headers['x-openai-model']),
+                model: String(request.body.model),
             };
         case 'cohere':
             return {
-                model: String(request.headers['x-cohere-model']),
+                model: String(request.body.model),
             };
         case 'llamacpp':
             return {
-                apiUrl: String(request.headers['x-llamacpp-url']),
+                apiUrl: String(request.body.apiUrl),
             };
         case 'vllm':
             return {
-                apiUrl: String(request.headers['x-vllm-url']),
+                apiUrl: String(request.body.apiUrl),
-                model: String(request.headers['x-vllm-model']),
+                model: String(request.body.model),
             };
         case 'ollama':
             return {
-                apiUrl: String(request.headers['x-ollama-url']),
+                apiUrl: String(request.body.apiUrl),
-                model: String(request.headers['x-ollama-model']),
+                model: String(request.body.model),
-                keep: Boolean(request.headers['x-ollama-keep']),
+                keep: Boolean(request.body.keep),
             };
         case 'extras':
             return {
-                extrasUrl: String(request.headers['x-extras-url']),
+                extrasUrl: String(request.body.extrasUrl),
-                extrasKey: String(request.headers['x-extras-key']),
+                extrasKey: String(request.body.extrasKey),
             };
         case 'transformers':
             return {