open-swarm 0.1.1743070217__py3-none-any.whl → 0.1.1743364176__py3-none-any.whl

swarm/static/rest_mode/js/messengerLogic.js

@@ -0,0 +1,355 @@
+async function fetchBlueprints() {
+    console.log('Fetching blueprints from /v1/models/ at:', new Date().toISOString());
+    try {
+        const response = await fetch('/v1/models/');
+        if (!response.ok) throw new Error(`HTTP error! Status: ${response.status}`);
+        const data = await response.json();
+        console.log('Raw response from /v1/models/:', data); // Print the raw response
+        const blueprints = data.data.filter(model => model.object === 'model');
+        console.log('Filtered blueprints:', blueprints);
+        return blueprints;
+    } catch (error) {
+        console.error('Error fetching blueprints:', error);
+        return [];
+    }
+}
+
+function populateChannelList(blueprints) {
+    console.log('Populating channel list with blueprints:', blueprints);
+    const list = document.getElementById('channelList');
+    if (!list) {
+        console.error('Channel list element not found!');
+        return;
+    }
+    console.log('Channel list found, initial HTML:', list.innerHTML);
+    list.innerHTML = ''; // Clear to ensure test data
+    // Preserve or add pseudo-channel
+    const existingPseudo = list.querySelector('li[data-blueprint-id="welcome"]');
+    if (!existingPseudo) {
+        list.innerHTML += '<li data-blueprint-id="welcome">#Welcome to Open-Swarm</li>';
+        console.log('Added pseudo-channel');
+    }
+    // Force test data
+    const testData = [
+        { id: 'test1', title: 'Test Channel 1' },
+        { id: 'test2', title: 'Test Channel 2' }
+    ];
+    testData.forEach(bp => {
+        if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+            const li = document.createElement('li');
+            li.textContent = `# ${bp.title}`;
+            li.dataset.blueprintId = bp.id;
+            li.addEventListener('click', () => switchChannel(bp.id));
+            list.appendChild(li);
+            console.log('Added test channel:', bp.title);
+        }
+    });
+    blueprints.forEach(bp => {
+        if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+            const li = document.createElement('li');
+            li.textContent = `# ${bp.title}`;
+            li.dataset.blueprintId = bp.id;
+            li.addEventListener('click', () => switchChannel(bp.id));
+            list.appendChild(li);
+            console.log('Added blueprint:', bp.title);
+        }
+    });
+    console.log('Channel list updated:', list.innerHTML);
+}
+
+let currentBlueprint = null;
+function switchChannel(blueprintId) {
+    currentBlueprint = blueprintId;
+    document.getElementById('messageHistory').innerHTML = '';
+    document.getElementById('blueprintTitle').textContent = blueprintId;
+    console.log(`Switched to channel: ${blueprintId}`);
+}
+
+async function handleSubmit(event) {
+    event.preventDefault();
+    const input = document.getElementById('userInput');
+    const message = input.value.trim();
+    if (!message || !currentBlueprint) {
+        console.log('No message or blueprint selected, skipping submission');
+        return;
+    }
+    input.value = '';
+    const history = document.getElementById('messageHistory');
+    history.innerHTML += `<div class="user-message">${message}</div>`;
+    try {
+        const response = await fetch('/v1/chat/completions/', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRFToken': document.querySelector('meta[name="csrf-token"]').content
+            },
+            body: JSON.stringify({
+                model: currentBlueprint,
+                messages: [{ role: 'user', content: message }]
+            })
+        });
+        const data = await response.json();
+        history.innerHTML += `<div class="assistant-message">${data.choices[0].message.content}</div>`;
+        history.scrollTop = history.scrollHeight;
+    } catch (error) {
+        console.error('Error submitting message:', error);
+        history.innerHTML += `<div class="error-message">Error: ${error.message}</div>`;
+    }
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    console.log('DOM fully loaded, initializing Messenger at:', new Date().toISOString());
+    const blueprints = []; // Disable fetch to test DOM with test data
+    populateChannelList(blueprints);
+    if (blueprints.length > 0) {
+        switchChannel(blueprints[0].id);
+    } else {
+        console.log('No blueprints available, using test data at:', new Date().toISOString());
+    }
+    document.getElementById('sendButton').addEventListener('click', handleSubmit);
+    document.getElementById('userInput').addEventListener('keypress', (e) => {
+        if (e.key === 'Enter') handleSubmit(e);
+    });
+});
+// Append debugging and test data
+console.log('Appending debug at:', new Date().toISOString());
+const originalPopulate = populateChannelList;
+populateChannelList = function(blueprints) {
+    console.log('Original populate called with:', blueprints);
+    originalPopulate(blueprints); // Call your original function
+    // Force test data
+    const testData = [
+        { id: 'test1', title: 'Test Channel 1' },
+        { id: 'test2', title: 'Test Channel 2' }
+    ];
+    const list = document.getElementById('channelList');
+    if (list) {
+        testData.forEach(bp => {
+            if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+                const li = document.createElement('li');
+                li.textContent = `# ${bp.title}`;
+                li.dataset.blueprintId = bp.id;
+                li.addEventListener('click', () => switchChannel(bp.id));
+                list.appendChild(li);
+                console.log('Added test channel:', bp.title, 'at:', new Date().toISOString());
+            }
+        });
+        console.log('Channel list updated with test data:', list.innerHTML);
+    } else {
+        console.error('Channel list not found during test data append!');
+    }
+};
+// Append debug and test data
+console.log('Appending debug at:', new Date().toISOString());
+const originalFetch = fetchBlueprints;
+fetchBlueprints = async function() {
+    console.log('Fetching blueprints with debug at:', new Date().toISOString());
+    const blueprints = await originalFetch();
+    console.log('Fetch result:', blueprints);
+    return blueprints;
+};
+const originalPopulate = populateChannelList;
+populateChannelList = function(blueprints) {
+    console.log('Populating with debug:', blueprints);
+    originalPopulate(blueprints);
+    if (blueprints.length === 0) {
+        const testData = [
+            { id: 'test1', title: 'Test Channel 1' },
+            { id: 'test2', title: 'Test Channel 2' }
+        ];
+        const list = document.getElementById('channelList');
+        if (list) {
+            testData.forEach(bp => {
+                if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+                    const li = document.createElement('li');
+                    li.textContent = `# ${bp.title}`;
+                    li.dataset.blueprintId = bp.id;
+                    li.addEventListener('click', () => switchChannel(bp.id));
+                    list.appendChild(li);
+                    console.log('Added test channel:', bp.title);
+                }
+            });
+            console.log('Updated with test data:', list.innerHTML);
+        }
+    }
+};
+// Append debug and test data
+console.log('Debug append at:', new Date().toISOString());
+const originalPopulate = populateChannelList;
+populateChannelList = function(blueprints) {
+    console.log('Populating with:', blueprints);
+    originalPopulate(blueprints);
+    const testData = [
+        { id: 'test1', title: 'Test Channel 1' },
+        { id: 'test2', title: 'Test Channel 2' }
+    ];
+    const list = document.getElementById('channelList');
+    if (list) {
+        testData.forEach(bp => {
+            if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+                const li = document.createElement('li');
+                li.textContent = `# ${bp.title}`;
+                li.dataset.blueprintId = bp.id;
+                li.addEventListener('click', () => switchChannel(bp.id));
+                list.appendChild(li);
+                console.log('Added test:', bp.title);
+            }
+        });
+        console.log('List after test:', list.innerHTML);
+    } else {
+        console.error('No channel list found!');
+    }
+};
+// Append debug and test data
+console.log('MessengerLogic debug append at:', new Date().toISOString());
+const originalFetch = fetchBlueprints;
+fetchBlueprints = async function() {
+    console.log('Executing fetchBlueprints at:', new Date().toISOString());
+    const response = await originalFetch();
+    console.log('Fetch result from /v1/models/:', response);
+    return response;
+};
+const originalPopulate = populateChannelList;
+populateChannelList = function(blueprints) {
+    console.log('Executing populateChannelList with:', blueprints);
+    originalPopulate(blueprints);
+    if (blueprints.length === 0 || !blueprints) {
+        console.log('No blueprints, forcing test data at:', new Date().toISOString());
+        const testData = [
+            { id: 'test1', title: 'Test Channel 1' },
+            { id: 'test2', title: 'Test Channel 2' }
+        ];
+        const list = document.getElementById('channelList');
+        if (list) {
+            testData.forEach(bp => {
+                if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+                    const li = document.createElement('li');
+                    li.textContent = `# ${bp.title}`;
+                    li.dataset.blueprintId = bp.id;
+                    li.addEventListener('click', () => switchChannel(bp.id));
+                    list.appendChild(li);
+                    console.log('Populated test channel:', bp.title);
+                }
+            });
+            console.log('Channel list after population:', list.innerHTML);
+        } else {
+            console.error('Channel list not found!');
+        }
+    }
+};
+// Append debug and test data
+console.log('MessengerLogic debug append at:', new Date().toISOString());
+const originalFetch = fetchBlueprints;
+fetchBlueprints = async function() {
+    console.log('Executing fetchBlueprints at:', new Date().toISOString());
+    const response = await originalFetch();
+    console.log('Fetch result from /v1/models/:', response);
+    return response;
+};
+const originalPopulate = populateChannelList;
+populateChannelList = function(blueprints) {
+    console.log('Executing populateChannelList with:', blueprints);
+    originalPopulate(blueprints);
+    if (blueprints.length === 0 || !blueprints) {
+        console.log('No blueprints, forcing test data at:', new Date().toISOString());
+        const testData = [
+            { id: 'test1', title: 'Test Channel 1' },
+            { id: 'test2', title: 'Test Channel 2' }
+        ];
+        const list = document.getElementById('channelList');
+        if (list) {
+            testData.forEach(bp => {
+                if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+                    const li = document.createElement('li');
+                    li.textContent = `# ${bp.title}`;
+                    li.dataset.blueprintId = bp.id;
+                    li.addEventListener('click', () => switchChannel(bp.id));
+                    list.appendChild(li);
+                    console.log('Populated test channel:', bp.title);
+                }
+            });
+            console.log('Channel list after population:', list.innerHTML);
+        } else {
+            console.error('Channel list not found!');
+        }
+    }
+};
+// Append load check and test data
+console.log('MessengerLogic loaded at:', new Date().toISOString());
+const originalPopulate = populateChannelList;
+populateChannelList = function(blueprints) {
+    console.log('Populating with blueprints at:', new Date().toISOString(), blueprints);
+    originalPopulate(blueprints);
+    if (!blueprints || blueprints.length === 0) {
+        console.log('No blueprints, adding test data at:', new Date().toISOString());
+        const testData = [
+            { id: 'test1', title: 'Test Channel 1' },
+            { id: 'test2', title: 'Test Channel 2' }
+        ];
+        const list = document.getElementById('channelList');
+        if (list) {
+            testData.forEach(bp => {
+                if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+                    const li = document.createElement('li');
+                    li.textContent = `# ${bp.title}`;
+                    li.dataset.blueprintId = bp.id;
+                    li.addEventListener('click', () => switchChannel(bp.id));
+                    list.appendChild(li);
+                    console.log('Added test channel:', bp.title);
+                }
+            });
+            console.log('Channel list updated:', list.innerHTML);
+        } else {
+            console.error('Channel list not found!');
+        }
+    }
+};
+// Append debug and combine ideas
+console.log('Debug append at:', new Date().toISOString());
+const originalFetch = fetchBlueprints;
+fetchBlueprints = async function() {
+    console.log('Fetching blueprints like dropdown at:', new Date().toISOString());
+    const blueprints = await originalFetch();
+    console.log('Fetch result (like Chatbot dropdown):', blueprints);
+    return blueprints;
+};
+const originalPopulate = populateChannelList;
+populateChannelList = function(blueprints) {
+    console.log('Populating like pseudo-channel with:', blueprints);
+    originalPopulate(blueprints); // Your logic
+    if (!blueprints || blueprints.length === 0) {
+        console.log('No blueprints, adding test channels at:', new Date().toISOString());
+        const testData = [
+            { id: 'test1', title: 'Test Channel 1' },
+            { id: 'test2', title: 'Test Channel 2' }
+        ];
+        const list = document.getElementById('channelList');
+        if (list) {
+            testData.forEach(bp => {
+                if (!list.querySelector(`li[data-blueprint-id="${bp.id}"]`)) {
+                    const li = document.createElement('li');
+                    li.textContent = `# ${bp.title}`;
+                    li.dataset.blueprintId = bp.id;
+                    li.addEventListener('click', () => switchChannel(bp.id));
+                    list.appendChild(li);
+                    console.log('Added test channel (like pseudo):', bp.title);
+                }
+            });
+            console.log('Channel list updated:', list.innerHTML);
+        }
+    }
+};
+// Append fetch debug
+console.log('Debug append at:', new Date().toISOString());
+const originalFetch = fetchBlueprints;
+fetchBlueprints = async function() {
+    console.log('Fetching blueprints at:', new Date().toISOString());
+    try {
+        const response = await originalFetch();
+        console.log('Fetch result from /v1/models/:', response);
+        return response;
+    } catch (error) {
+        console.error('Fetch error:', error);
+        return [];
+    }
+};

swarm/static/rest_mode/js/modules/apiService.js

@@ -0,0 +1,84 @@
+// src/swarm/static/rest_mode/js/modules/apiService.js
+
+import { showToast } from '../toast.js';
+import { debugLog } from './debugLogger.js';
+
+/**
+ * Handles all API interactions.
+ */
+
+/**
+ * Fetches blueprint metadata from the server.
+ * @returns {Promise<Array>} - Returns a promise that resolves to the list of blueprints.
+ */
+export async function fetchBlueprintMetadata() {
+    try {
+        const response = await fetch('/v1/models/');
+        if (!response.ok) throw new Error('Failed to fetch metadata.');
+
+        const data = await response.json();
+        showToast('Retrieved blueprint metadata.', 'info');
+        return data.data || [];
+    } catch (error) {
+        debugLog('Error fetching blueprint metadata:', error);
+        showToast('❌ Could not retrieve blueprint metadata.', 'error');
+        return [];
+    }
+}
+
+/**
+ * Submits a user message to the server and retrieves the assistant's response.
+ * @param {string} modelName - The model to use for generating responses.
+ * @param {Array} messages - The chat history messages.
+ * @param {Object} contextVariables - Context variables for the chat.
+ * @returns {Promise<Object>} - Returns a promise that resolves to the server's response.
+ */
+export async function submitMessage(modelName, messages, contextVariables) {
+    try {
+        const response = await fetch('/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRFToken': document.querySelector('meta[name="csrf-token"]')?.getAttribute('content') || '',
+            },
+            body: JSON.stringify({
+                model: modelName,
+                messages: messages,
+                context_variables: contextVariables,
+            }),
+        });
+
+        if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
+
+        const data = await response.json();
+        return data;
+    } catch (error) {
+        debugLog('Error submitting message:', error);
+        showToast('⚠️ Error submitting message. Please try again.', 'error');
+        throw error;
+    }
+}
+
+/**
+ * Deletes a chat by its ID.
+ * @param {string} chatId - The ID of the chat to delete.
+ * @returns {Promise<boolean>} - Returns true if deletion was successful.
+ */
+export async function deleteChat(chatId) {
+    try {
+        const response = await fetch(`/v1/chat/delete/${chatId}`, {
+            method: 'DELETE',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRFToken': document.querySelector('meta[name="csrf-token"]')?.getAttribute('content') || '',
+            },
+        });
+
+        if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
+        return true;
+    } catch (error) {
+        debugLog('Error deleting chat:', error);
+        showToast('❌ Error deleting chat. Please try again.', 'error');
+        return false;
+    }
+}

swarm/static/rest_mode/js/modules/blueprintManager.js

@@ -0,0 +1,162 @@
+// src/swarm/static/rest_mode/js/modules/blueprintManager.js
+
+import { fetchBlueprintMetadata as fetchMetadataAPI } from './apiService.js';
+import { showToast } from '../toast.js';
+import { appendRawMessage } from '../messages.js';
+import { debugLog } from './debugLogger.js';
+import { createChatHistoryEntry } from './chatHistory.js';
+
+/**
+ * Populates the blueprint selection dialog and dropdown.
+ * @param {Array} blueprints - The list of blueprints fetched from the API.
+ */
+function populateBlueprintDialog(blueprints) {
+    const blueprintDialogElement = document.getElementById('blueprintDialog');
+    const blueprintDropdown = document.getElementById('blueprintDropdown');
+    const currentPath = window.location.pathname; // Get the current URL path
+
+    if (!blueprintDialogElement) {
+        debugLog('Blueprint dialog not found.');
+        return;
+    }
+
+    // Populate dialog
+    blueprintDialogElement.innerHTML = blueprints
+        .map(
+            (bp) => `
+        <div class="blueprint-option" data-id="${bp.id}">
+            <p class="blueprint-title">${bp.title}</p>
+            <p class="blueprint-description">${bp.description}</p>
+        </div>`
+        )
+        .join('');
+
+    if (!blueprintDropdown) {
+        debugLog('Blueprint dropdown element not found.');
+        return;
+    }
+
+    // Populate dropdown
+    blueprintDropdown.innerHTML = blueprints
+        .map(
+            (bp) => `
+        <option value="${bp.id}">${bp.title}</option>`
+        )
+        .join('');
+
+    // Add click event for each dialog option
+    blueprintDialogElement.querySelectorAll('.blueprint-option').forEach((option) => {
+        option.addEventListener('click', () => {
+            const selectedId = option.getAttribute('data-id');
+            const selectedBlueprint = blueprints.find((bp) => bp.id === selectedId);
+            if (selectedBlueprint) {
+                selectBlueprint(selectedBlueprint, true); // User-initiated selection
+            }
+        });
+    });
+
+    // Add change event for dropdown
+    blueprintDropdown.addEventListener('change', (event) => {
+        const selectedId = event.target.value;
+        const selectedBlueprint = blueprints.find((bp) => bp.id === selectedId);
+        if (selectedBlueprint) {
+            selectBlueprint(selectedBlueprint, true); // User-initiated selection
+        }
+    });
+}
+
+/**
+ * Updates the UI and metadata when a blueprint is selected.
+ * @param {Object} blueprint - The selected blueprint.
+ * @param {boolean} isUserInitiated - Indicates if the selection was made by the user.
+ */
+export function selectBlueprint(blueprint, isUserInitiated = false) {
+    const blueprintMetadataElement = document.getElementById('blueprintMetadata');
+    const blueprintTitleElement = document.getElementById('blueprintTitle');
+    const blueprintDialogElement = document.getElementById('blueprintDialog');
+    const blueprintDropdown = document.getElementById('blueprintDropdown');
+
+    if (!blueprintMetadataElement || !blueprintTitleElement || !blueprintDropdown) {
+        debugLog('Required elements for blueprint selection not found.');
+        return;
+    }
+
+    const blueprintName = blueprint.title;
+    const blueprintDescription = blueprint.description;
+
+    // Update UI
+    blueprintMetadataElement.innerHTML = `<h2>${blueprintName}</h2><p>${blueprintDescription}</p>`;
+    blueprintTitleElement.textContent = blueprintName;
+
+    // Update Dropdown Value
+    blueprintDropdown.value = blueprint.id;
+
+    // Hide the blueprint dialog
+    if (blueprintDialogElement) {
+        blueprintDialogElement.classList.add('hidden');
+    }
+
+    // Optionally, show the dropdown if in advanced mode
+    // For simple chat mode, keep it hidden
+    // blueprintDropdown.classList.remove('hidden'); // Uncomment if needed
+
+    // Notify user about blueprint change only if it's user-initiated
+    if (isUserInitiated) {
+        appendRawMessage(
+            'assistant',
+            {
+                content: `Blueprint loaded: ${blueprintName}`,
+            },
+            'Assistant'
+        );
+    }
+
+    debugLog('Blueprint selected and UI updated.', blueprint);
+}
+
+/**
+ * Initializes blueprint management by fetching metadata and populating the UI.
+ */
+export async function initializeBlueprints() {
+    debugLog('Initializing blueprint management.');
+    try {
+        const blueprints = await fetchMetadataAPI();
+        if (blueprints.length === 0) throw new Error('No blueprints available.');
+
+        // Populate blueprint dialog and dropdown
+        populateBlueprintDialog(blueprints);
+
+        // Extract blueprint ID from the current path
+        const currentPath = window.location.pathname;
+        const pathSegments = currentPath.split('/').filter(segment => segment.length > 0);
+        const blueprintId = pathSegments.length > 0 ? pathSegments[pathSegments.length - 1] : null;
+
+        debugLog('Current Path:', currentPath);
+        debugLog('Extracted Blueprint ID:', blueprintId);
+
+        // Find the blueprint with the extracted ID
+        const matchedBlueprint = blueprints.find(bp => bp.id === blueprintId);
+
+        if (matchedBlueprint) {
+            debugLog('Matched Blueprint:', matchedBlueprint);
+            selectBlueprint(matchedBlueprint, false); // Programmatic selection
+        } else {
+            debugLog('No matched blueprint found. Selecting default blueprint:', blueprints[0]);
+            // If no matching blueprint, select the first blueprint as default
+            const defaultBlueprint = blueprints[0];
+            selectBlueprint(defaultBlueprint, false); // Programmatic selection
+        }
+    } catch (error) {
+        debugLog('Error fetching blueprint metadata:', error);
+        console.error('Error initializing blueprints:', error);
+
+        appendRawMessage(
+            'assistant',
+            {
+                content:
+                    'Could not retrieve blueprint metadata. Check out the troubleshooting guide at <a href="https://github.com/matthewhand/open-swarm/TROUBLESHOOTING.md">Troubleshooting Guide</a>.',
+            },
+            'Assistant'
+        );
+    }
+}