libre-webui 0.7.1 → 0.8.0

package/backend/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAkBA,OAAO,UAAU,CAAC;AA6ElB,QAAA,MAAM,GAAG,6CAAY,CAAC;AA4jCtB,eAAe,GAAG,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAkBA,OAAO,UAAU,CAAC;AAkFlB,QAAA,MAAM,GAAG,6CAAY,CAAC;AAkgDtB,eAAe,GAAG,CAAC"}

package/backend/dist/index.js

@@ -76,6 +76,7 @@ import { HuggingFaceOAuthService } from './services/simpleHuggingFaceOAuth.js';
 import pluginService from './services/pluginService.js';
 import preferencesService from './services/preferencesService.js';
 import documentService from './services/documentService.js';
+import openclawSessionService, { extractTextFromMessage, } from './services/openclawSessionService.js';
 import { mergeGenerationOptions } from './utils/generationUtils.js';
 import { verifyToken } from './utils/jwt.js';
 const app = express();
@@ -564,48 +565,224 @@ wss.on('connection', (ws, req) => {
                 console.log(`[WebSocket] Found plugin:`, activePlugin ? activePlugin.id : 'none');
                 if (activePlugin) {
                     console.log(`[WebSocket] Using plugin ${activePlugin.id} for model ${actualModelName}`);
-                    try {
-                        // Get user's preferred generation options
-                        const userGenerationOptions = preferencesService.getGenerationOptions();
-                        // Merge user preferences with request options
-                        const mergedOptions = mergeGenerationOptions(userGenerationOptions, options);
-                        // Get messages for context
-                        const contextMessages = chatService.getMessagesForContext(sessionId);
-                        // Use plugin for generation (non-streaming for now)
-                        // For regenerations, the user message is already in context; for new messages, we need to add it
-                        const messagesForPlugin = regenerate
-                            ? contextMessages
-                            : contextMessages.concat([userMessage]);
-                        const pluginResponse = await pluginService.executePluginRequest(actualModelName, messagesForPlugin, mergedOptions);
-                        // Get the content from plugin response
-                        assistantContent =
-                            pluginResponse.choices[0]?.message?.content || '';
-                        // Send the complete response as chunks to simulate streaming
-                        const words = assistantContent.split(' ');
-                        const BATCH_SIZE = 3; // Send 3 words at a time to reduce message frequency
-                        for (let i = 0; i < words.length; i += BATCH_SIZE) {
-                            const batch = words.slice(i, i + BATCH_SIZE);
-                            const chunk = words.slice(0, i + batch.length).join(' ');
-                            const isLast = i + BATCH_SIZE >= words.length;
+                    // Load plugin variables early — needed for session mode check
+                    const pluginVars = pluginService.getPluginVariables(activePlugin);
+                    // ---------------------------------------------------------------
+                    // OpenClaw Session Mode — route through WebSocket gateway
+                    // ---------------------------------------------------------------
+                    // OpenClaw session routing now handled via x-openclaw-session-key HTTP header
+                    // in pluginService — no WebSocket needed
+                    const isOpenClawSession = false; // Disabled: WS approach replaced by HTTP header
+                    if (isOpenClawSession) {
+                        console.log('[WebSocket] OpenClaw session mode: routing through gateway WS');
+                        try {
+                            // Ensure the gateway WS connection is established
+                            const endpoint = pluginVars.endpoint ||
+                                activePlugin.endpoint ||
+                                'http://127.0.0.1:18789/v1/chat/completions';
+                            const apiKey = pluginService.getApiKey(activePlugin) || '';
+                            const ocSessionKey = pluginVars.session_key || 'main';
+                            if (!openclawSessionService.isConnected) {
+                                openclawSessionService.connect({
+                                    gatewayUrl: endpoint,
+                                    token: apiKey,
+                                    sessionKey: ocSessionKey,
+                                });
+                                // Wait a bit for connection
+                                await new Promise(resolve => {
+                                    const maxWait = 8000;
+                                    const start = Date.now();
+                                    const check = () => {
+                                        if (openclawSessionService.isConnected) {
+                                            resolve();
+                                        }
+                                        else if (Date.now() - start > maxWait) {
+                                            resolve(); // proceed anyway, will error on send
+                                        }
+                                        else {
+                                            setTimeout(check, 200);
+                                        }
+                                    };
+                                    check();
+                                });
+                            }
+                            if (!openclawSessionService.isConnected) {
+                                throw new Error('Failed to connect to OpenClaw gateway WebSocket');
+                            }
+                            // Build the message to send
+                            const messageText = userMessage?.content || content;
+                            // Set up event listener for this run
+                            let totalContent = '';
+                            let currentRunId = null;
+                            let runDone = false;
+                            const toolCalls = [];
+                            const cleanup = openclawSessionService.subscribe((type, data) => {
+                                if (runDone)
+                                    return;
+                                if (type === 'chat') {
+                                    const chatEvent = data;
+                                    if (currentRunId &&
+                                        chatEvent.runId &&
+                                        chatEvent.runId !== currentRunId)
+                                        return;
+                                    if (chatEvent.state === 'delta') {
+                                        const text = extractTextFromMessage(chatEvent.message);
+                                        if (typeof text === 'string' &&
+                                            text.length > totalContent.length) {
+                                            // Send incremental delta
+                                            const newContent = text.slice(totalContent.length);
+                                            totalContent = text;
+                                            try {
+                                                ws.send(JSON.stringify({
+                                                    type: 'assistant_chunk',
+                                                    data: {
+                                                        content: newContent,
+                                                        total: totalContent,
+                                                        done: false,
+                                                        messageId: assistantMessageId,
+                                                    },
+                                                }));
+                                            }
+                                            catch {
+                                                /* ws closed */
+                                            }
+                                        }
+                                    }
+                                    else if (chatEvent.state === 'final' ||
+                                        chatEvent.state === 'aborted' ||
+                                        chatEvent.state === 'error') {
+                                        runDone = true;
+                                        if (chatEvent.state === 'error') {
+                                            const errMsg = chatEvent.errorMessage || 'Agent error';
+                                            if (!totalContent)
+                                                totalContent = `Error: ${errMsg}`;
+                                        }
+                                        // Append tool call summaries
+                                        if (toolCalls.length > 0) {
+                                            let toolContent = '\n\n---\n**🔧 Tools Used:**\n';
+                                            for (const tc of toolCalls) {
+                                                const statusIcon = tc.phase === 'result' ? '✅' : '⏳';
+                                                toolContent += `\n${statusIcon} **${tc.name}**`;
+                                                if (tc.result) {
+                                                    const resultStr = typeof tc.result === 'string'
+                                                        ? tc.result
+                                                        : JSON.stringify(tc.result);
+                                                    if (resultStr.length <= 500) {
+                                                        toolContent += `\n<details><summary>Result</summary>\n\n\`\`\`\n${resultStr}\n\`\`\`\n</details>\n`;
+                                                    }
+                                                    else {
+                                                        toolContent += `\n<details><summary>Result (${resultStr.length} chars)</summary>\n\n\`\`\`\n${resultStr.slice(0, 500)}…\n\`\`\`\n</details>\n`;
+                                                    }
+                                                }
+                                            }
+                                            totalContent += toolContent;
+                                        }
+                                        // Send final chunk
+                                        try {
+                                            ws.send(JSON.stringify({
+                                                type: 'assistant_chunk',
+                                                data: {
+                                                    content: '',
+                                                    total: totalContent,
+                                                    done: true,
+                                                    messageId: assistantMessageId,
+                                                },
+                                            }));
+                                        }
+                                        catch {
+                                            /* ws closed */
+                                        }
+                                    }
+                                }
+                                else if (type === 'tool') {
+                                    const toolEvent = data;
+                                    // Track tool calls
+                                    const existing = toolCalls.find(t => t.id === toolEvent.toolCallId);
+                                    if (existing) {
+                                        existing.phase = toolEvent.phase;
+                                        if (toolEvent.result)
+                                            existing.result =
+                                                typeof toolEvent.result === 'string'
+                                                    ? toolEvent.result
+                                                    : JSON.stringify(toolEvent.result);
+                                    }
+                                    else {
+                                        toolCalls.push({
+                                            id: toolEvent.toolCallId,
+                                            name: toolEvent.name,
+                                            phase: toolEvent.phase,
+                                            args: toolEvent.args
+                                                ? JSON.stringify(toolEvent.args)
+                                                : undefined,
+                                            result: toolEvent.result
+                                                ? typeof toolEvent.result === 'string'
+                                                    ? toolEvent.result
+                                                    : JSON.stringify(toolEvent.result)
+                                                : undefined,
+                                        });
+                                    }
+                                    // Send tool status to frontend
+                                    try {
+                                        const toolStatusMsg = toolEvent.phase === 'start'
+                                            ? `\n\n🔧 *Using tool: ${toolEvent.name}…*\n`
+                                            : '';
+                                        if (toolStatusMsg) {
+                                            totalContent += toolStatusMsg;
+                                            ws.send(JSON.stringify({
+                                                type: 'assistant_chunk',
+                                                data: {
+                                                    content: toolStatusMsg,
+                                                    total: totalContent,
+                                                    done: false,
+                                                    messageId: assistantMessageId,
+                                                },
+                                            }));
+                                        }
+                                    }
+                                    catch {
+                                        /* ws closed */
+                                    }
+                                }
+                            });
+                            // Send the message
+                            const result = await openclawSessionService.sendMessage(messageText, ocSessionKey);
+                            currentRunId = result.runId;
+                            // Wait for completion (max 5 minutes)
+                            await new Promise(resolve => {
+                                const timeout = setTimeout(() => {
+                                    runDone = true;
+                                    resolve();
+                                }, 300000);
+                                const checkDone = setInterval(() => {
+                                    if (runDone) {
+                                        clearInterval(checkDone);
+                                        clearTimeout(timeout);
+                                        resolve();
+                                    }
+                                }, 100);
+                            });
+                            // Clean up listener
+                            cleanup();
+                            // Save the assistant message
+                            assistantContent = totalContent;
+                        }
+                        catch (error) {
+                            console.error('[WebSocket] OpenClaw session error:', error);
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            assistantContent = `Error: ${errorMsg}`;
                             ws.send(JSON.stringify({
                                 type: 'assistant_chunk',
                                 data: {
-                                    content: batch.join(' ') + (isLast ? '' : ' '),
-                                    total: chunk,
-                                    done: isLast,
+                                    content: assistantContent,
+                                    total: assistantContent,
+                                    done: true,
                                     messageId: assistantMessageId,
                                 },
                             }));
-                            // Small delay to simulate streaming but with better batching
-                            if (!isLast) {
-                                await new Promise(resolve => setTimeout(resolve, 100));
-                            }
                         }
-                        // Save the complete assistant message (skip for private sessions)
+                        // Save assistant message from session mode
                         if (assistantContent && assistantMessageId) {
                             if (isPrivate) {
-                                // For private sessions, just send completion without saving
-                                console.log('Backend: Private session - skipping message save');
                                 ws.send(JSON.stringify({
                                     type: 'assistant_complete',
                                     data: {
@@ -618,43 +795,235 @@ wss.on('connection', (ws, req) => {
                                 }));
                             }
                             else {
-                                console.log('Backend: Saving complete assistant message with ID:', assistantMessageId, 'regenerate:', !!regenerate);
-                                // Calculate branching fields if this is a regeneration
-                                let branchingFields = {};
-                                if (regenerate && originalMessageId) {
-                                    // Find the original message to get its parentId or use its ID as parent
-                                    const originalMsg = session.messages.find(m => m.id === originalMessageId);
-                                    const parentId = originalMsg?.parentId || originalMessageId;
-                                    // Count existing siblings to determine branch index
-                                    const siblingCount = session.messages.filter(m => m.id === parentId || m.parentId === parentId).length;
-                                    branchingFields = {
-                                        parentId,
-                                        branchIndex: siblingCount, // New branch gets next index
-                                        isActive: true,
-                                    };
-                                    console.log('Backend: Setting branching fields:', branchingFields);
-                                }
                                 const assistantMessage = chatService.addMessage(sessionId, {
                                     role: 'assistant',
                                     content: assistantContent,
                                     model: session.model,
                                     id: assistantMessageId,
-                                    ...branchingFields,
                                 }, userId);
-                                console.log('Backend: Assistant message saved:', !!assistantMessage);
-                                // Send completion signal
                                 ws.send(JSON.stringify({
                                     type: 'assistant_complete',
                                     data: assistantMessage,
                                 }));
                             }
                         }
-                        return; // Exit early since we handled the request via plugin
-                    }
-                    catch (pluginError) {
-                        console.error('Plugin failed, falling back to Ollama:', pluginError);
-                        // Continue to Ollama fallback below
+                        return; // Exit early — handled via OpenClaw session
                     }
+                    else {
+                        // ---------------------------------------------------------------
+                        // Standard plugin path (stateless HTTP completions)
+                        // ---------------------------------------------------------------
+                        try {
+                            // Get user's preferred generation options
+                            const userGenerationOptions = preferencesService.getGenerationOptions();
+                            // Merge user preferences with request options
+                            const mergedOptions = mergeGenerationOptions(userGenerationOptions, options);
+                            // Get messages for context
+                            const contextMessages = chatService.getMessagesForContext(sessionId);
+                            // For regenerations, the user message is already in context; for new messages, we need to add it
+                            let messagesForPlugin = regenerate
+                                ? contextMessages
+                                : contextMessages.concat([userMessage]);
+                            const systemPromptPrefix = pluginVars.system_prompt_prefix || '';
+                            const userName = pluginVars.user_name || '';
+                            // Prepend identity system message if configured
+                            if (systemPromptPrefix || userName) {
+                                let identityMsg = systemPromptPrefix;
+                                if (userName) {
+                                    identityMsg = identityMsg
+                                        ? `${identityMsg}\n\nThe user's name is: ${userName}`
+                                        : `The user's name is: ${userName}`;
+                                }
+                                messagesForPlugin = [
+                                    {
+                                        id: 'system-identity',
+                                        role: 'system',
+                                        content: identityMsg,
+                                        timestamp: Date.now(),
+                                    },
+                                    ...messagesForPlugin,
+                                ];
+                            }
+                            const shouldStream = pluginVars.stream ?? false;
+                            if (shouldStream) {
+                                // Real SSE streaming from plugin
+                                let totalContent = '';
+                                const toolCalls = [];
+                                for await (const chunk of pluginService.executePluginStreamRequest(actualModelName, messagesForPlugin, mergedOptions)) {
+                                    if (chunk.type === 'content' && chunk.content) {
+                                        totalContent += chunk.content;
+                                        ws.send(JSON.stringify({
+                                            type: 'assistant_chunk',
+                                            data: {
+                                                content: chunk.content,
+                                                total: totalContent,
+                                                done: false,
+                                                messageId: assistantMessageId,
+                                            },
+                                        }));
+                                    }
+                                    else if (chunk.type === 'tool_call' && chunk.toolCall) {
+                                        toolCalls.push(chunk.toolCall);
+                                    }
+                                    else if (chunk.type === 'done') {
+                                        // Append tool call info to content if present
+                                        if (toolCalls.length > 0) {
+                                            let toolContent = '\n\n---\n**🔧 Tool Calls:**\n';
+                                            for (const tc of toolCalls) {
+                                                let argsFormatted = tc.arguments;
+                                                try {
+                                                    argsFormatted = JSON.stringify(JSON.parse(tc.arguments), null, 2);
+                                                }
+                                                catch {
+                                                    /* keep raw */
+                                                }
+                                                toolContent += `\n**${tc.name}** (\`${tc.id}\`)\n\`\`\`json\n${argsFormatted}\n\`\`\`\n`;
+                                            }
+                                            totalContent += toolContent;
+                                        }
+                                        // Send final chunk
+                                        ws.send(JSON.stringify({
+                                            type: 'assistant_chunk',
+                                            data: {
+                                                content: '',
+                                                total: totalContent,
+                                                done: true,
+                                                messageId: assistantMessageId,
+                                            },
+                                        }));
+                                    }
+                                }
+                                assistantContent = totalContent;
+                            }
+                            else {
+                                // Non-streaming: use original request method
+                                const pluginResponse = await pluginService.executePluginRequest(actualModelName, messagesForPlugin, mergedOptions);
+                                if (!pluginResponse?.choices?.length) {
+                                    throw new Error('Plugin returned empty or invalid response');
+                                }
+                                const choice = pluginResponse.choices[0];
+                                // Handle content that may be a string or array of content blocks
+                                const rawContent = choice?.message?.content;
+                                if (Array.isArray(rawContent)) {
+                                    // Multimodal response: convert content blocks to markdown
+                                    const parts = [];
+                                    for (const block of rawContent) {
+                                        if (block.type === 'text' && block.text) {
+                                            parts.push(block.text);
+                                        }
+                                        else if (block.type === 'image_url' &&
+                                            block.image_url?.url) {
+                                            parts.push(`![image](${block.image_url.url})`);
+                                        }
+                                    }
+                                    assistantContent = parts.join('\n\n');
+                                }
+                                else {
+                                    assistantContent = rawContent || '';
+                                }
+                                // Render tool_calls from non-streaming response
+                                const msgAny = choice?.message;
+                                if (msgAny?.tool_calls &&
+                                    Array.isArray(msgAny.tool_calls) &&
+                                    msgAny.tool_calls.length > 0) {
+                                    let toolContent = '\n\n---\n**🔧 Tool Calls:**\n';
+                                    for (const tc of msgAny.tool_calls) {
+                                        const name = tc.function?.name || 'unknown';
+                                        const id = tc.id || '';
+                                        let args = tc.function?.arguments || '';
+                                        try {
+                                            args = JSON.stringify(JSON.parse(args), null, 2);
+                                        }
+                                        catch {
+                                            /* keep raw */
+                                        }
+                                        toolContent += `\n**${name}** (\`${id}\`)\n\`\`\`json\n${args}\n\`\`\`\n`;
+                                    }
+                                    assistantContent += toolContent;
+                                }
+                                // Send the complete response as chunks to simulate streaming
+                                const words = assistantContent.split(' ');
+                                const BATCH_SIZE = 3;
+                                for (let i = 0; i < words.length; i += BATCH_SIZE) {
+                                    const batch = words.slice(i, i + BATCH_SIZE);
+                                    const chunk = words.slice(0, i + batch.length).join(' ');
+                                    const isLast = i + BATCH_SIZE >= words.length;
+                                    ws.send(JSON.stringify({
+                                        type: 'assistant_chunk',
+                                        data: {
+                                            content: batch.join(' ') + (isLast ? '' : ' '),
+                                            total: chunk,
+                                            done: isLast,
+                                            messageId: assistantMessageId,
+                                        },
+                                    }));
+                                    if (!isLast) {
+                                        await new Promise(resolve => setTimeout(resolve, 100));
+                                    }
+                                }
+                            }
+                            // Save the complete assistant message (skip for private sessions)
+                            if (assistantContent && assistantMessageId) {
+                                if (isPrivate) {
+                                    // For private sessions, just send completion without saving
+                                    console.log('Backend: Private session - skipping message save');
+                                    ws.send(JSON.stringify({
+                                        type: 'assistant_complete',
+                                        data: {
+                                            id: assistantMessageId,
+                                            role: 'assistant',
+                                            content: assistantContent,
+                                            model: session.model,
+                                            timestamp: Date.now(),
+                                        },
+                                    }));
+                                }
+                                else {
+                                    console.log('Backend: Saving complete assistant message with ID:', assistantMessageId, 'regenerate:', !!regenerate);
+                                    // Calculate branching fields if this is a regeneration
+                                    let branchingFields = {};
+                                    if (regenerate && originalMessageId) {
+                                        // Find the original message to get its parentId or use its ID as parent
+                                        const originalMsg = session.messages.find(m => m.id === originalMessageId);
+                                        const parentId = originalMsg?.parentId || originalMessageId;
+                                        // Count existing siblings to determine branch index
+                                        const siblingCount = session.messages.filter(m => m.id === parentId || m.parentId === parentId).length;
+                                        branchingFields = {
+                                            parentId,
+                                            branchIndex: siblingCount, // New branch gets next index
+                                            isActive: true,
+                                        };
+                                        console.log('Backend: Setting branching fields:', branchingFields);
+                                    }
+                                    const assistantMessage = chatService.addMessage(sessionId, {
+                                        role: 'assistant',
+                                        content: assistantContent,
+                                        model: session.model,
+                                        id: assistantMessageId,
+                                        ...branchingFields,
+                                    }, userId);
+                                    console.log('Backend: Assistant message saved:', !!assistantMessage);
+                                    // Send completion signal
+                                    ws.send(JSON.stringify({
+                                        type: 'assistant_complete',
+                                        data: assistantMessage,
+                                    }));
+                                }
+                            }
+                            return; // Exit early since we handled the request via plugin
+                        }
+                        catch (pluginError) {
+                            console.error('Plugin failed, falling back to Ollama:', pluginError?.message || pluginError);
+                            if (pluginError?.response) {
+                                console.error('Plugin HTTP response status:', pluginError.response.status);
+                                console.error('Plugin HTTP response data:', JSON.stringify(pluginError.response.data));
+                            }
+                            if (pluginError?.cause) {
+                                console.error('Plugin error cause:', pluginError.cause);
+                            }
+                            // Continue to Ollama fallback below
+                        }
+                    } // close else (standard plugin path)
                 }
                 console.log(`[WebSocket] No plugin found or plugin failed, using Ollama for model: ${actualModelName}`);
                 // Reuse the actualModelName variable that was already resolved above