agent-orcha 0.0.7 → 0.0.8

package/dist/public/src/services/ApiService.js

@@ -48,11 +48,21 @@ export class ApiService {
         return res.json();
     }
 
-    async startWorkflowStream(name, input) {
+    async startWorkflowStream(name, input, signal) {
         return this._fetch(`/api/workflows/${name}/stream`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ input })
+            body: JSON.stringify({ input }),
+            signal,
+        });
+    }
+
+    async resumeWorkflowStream(name, threadId, answer, signal) {
+        return this._fetch(`/api/workflows/${name}/resume`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ threadId, answer }),
+            signal,
         });
     }
 
@@ -98,6 +108,36 @@ export class ApiService {
         return res.json();
     }
 
+    async getLlmConfig() {
+        const res = await this._fetch('/api/llm/config');
+        return res.json();
+    }
+
+    async saveLlmModel(name, config) {
+        const res = await this._fetch(`/api/llm/config/models/${encodeURIComponent(name)}`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(config),
+        });
+        return res.json();
+    }
+
+    async deleteLlmModel(name) {
+        const res = await this._fetch(`/api/llm/config/models/${encodeURIComponent(name)}`, {
+            method: 'DELETE',
+        });
+        return res.json();
+    }
+
+    async saveLlmEmbedding(name, config) {
+        const res = await this._fetch(`/api/llm/config/embeddings/${encodeURIComponent(name)}`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(config),
+        });
+        return res.json();
+    }
+
     async chatLLM(name, message) {
         const res = await this._fetch(`/api/llm/${name}/chat`, {
             method: 'POST',
@@ -263,6 +303,160 @@ export class ApiService {
         return new EventSource(`/api/tasks/${id}/stream`);
     }
 
+    // Local LLM
+    async getLocalLlmStatus() {
+        const res = await this._fetch('/api/local-llm/status');
+        return res.json();
+    }
+
+    async getLocalLlmModels() {
+        const res = await this._fetch('/api/local-llm/models');
+        return res.json();
+    }
+
+    async activateLocalModel(id) {
+        const res = await this._fetch(`/api/local-llm/models/${encodeURIComponent(id)}/activate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({}),
+        });
+        return res.json();
+    }
+
+    async deleteLocalModel(id) {
+        const res = await this._fetch(`/api/local-llm/models/${encodeURIComponent(id)}`, {
+            method: 'DELETE',
+        });
+        return res.json();
+    }
+
+    browseHuggingFace(query, limit = 10, format = 'gguf') {
+        return this._fetch(`/api/local-llm/browse?q=${encodeURIComponent(query)}&limit=${limit}&format=${format}`)
+            .then(r => r.json());
+    }
+
+    downloadLocalModel(repo, fileName, type = 'gguf') {
+        const params = new URLSearchParams({ repo });
+        if (type === 'mlx') {
+            params.set('type', 'mlx');
+        } else {
+            params.set('fileName', fileName);
+        }
+        return new EventSource(`/api/local-llm/models/download?${params.toString()}`);
+    }
+
+    async getActiveDownloads() {
+        const res = await this._fetch('/api/local-llm/models/downloads');
+        return res.json();
+    }
+
+    async getInterruptedDownloads() {
+        const res = await this._fetch('/api/local-llm/models/interrupted');
+        return res.json();
+    }
+
+    async deleteInterruptedDownload(fileName) {
+        const res = await this._fetch(`/api/local-llm/models/interrupted/${encodeURIComponent(fileName)}`, {
+            method: 'DELETE',
+        });
+        return res.json();
+    }
+
+    async activateLocalEmbedding(id) {
+        const res = await this._fetch(`/api/local-llm/models/${encodeURIComponent(id)}/activate-embedding`, {
+            method: 'POST',
+        });
+        return res.json();
+    }
+
+    async stopLocalLlm(engine) {
+        const res = await this._fetch('/api/local-llm/stop', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(engine ? { engine } : {}),
+        });
+        return res.json();
+    }
+
+    async stopLocalEmbedding(engine) {
+        const res = await this._fetch('/api/local-llm/stop-embedding', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(engine ? { engine } : {}),
+        });
+        return res.json();
+    }
+
+    async checkLlamaUpdate() {
+        const res = await this._fetch('/api/local-llm/check-update');
+        return res.json();
+    }
+
+    async updateLlamaBinary() {
+        const res = await this._fetch('/api/local-llm/update-binary', { method: 'POST' });
+        return res.json();
+    }
+
+    async getEngines() {
+        const res = await this._fetch('/api/local-llm/engines');
+        return res.json();
+    }
+
+    async activateEngine(engine, model, role = 'chat') {
+        const res = await this._fetch('/api/local-llm/engines/activate', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ engine, model, role }),
+        });
+        return res.json();
+    }
+
+    async unloadEngineModel(engine, model, instanceId) {
+        const res = await this._fetch('/api/local-llm/engines/unload', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ engine, model, ...(instanceId ? { instanceId } : {}) }),
+        });
+        return res.json();
+    }
+
+    async getEngineUrls() {
+        const res = await this._fetch('/api/local-llm/engines/urls');
+        return res.json();
+    }
+
+    async setEngineUrl(engine, url) {
+        const res = await this._fetch('/api/local-llm/engines/urls', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ engine, url }),
+        });
+        return res.json();
+    }
+
+    async setEngineContext(contextSize) {
+        const res = await this._fetch('/api/local-llm/engines/context', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ contextSize }),
+        });
+        return res.json();
+    }
+
+    async checkMlxUpdate() {
+        const res = await this._fetch('/api/local-llm/check-mlx-update');
+        return res.json();
+    }
+
+    async updateMlxBinary() {
+        const res = await this._fetch('/api/local-llm/update-mlx-binary', { method: 'POST' });
+        return res.json();
+    }
+
+    streamLogs() {
+        return new EventSource('/api/logs/stream');
+    }
+
     async getGraphConfig() {
         const res = await this._fetch('/api/graph/config');
         return res.json();

package/dist/public/src/services/SessionStore.js

@@ -14,13 +14,14 @@ class SessionStore {
         return this.getAll().find(s => s.id === id) || null;
     }
 
-    create({ agentName, agentType, llmName }) {
+    create({ agentName, agentType, llmName, workflowName }) {
         const sessions = this.getAll();
         const session = {
             id: 'session-' + Date.now() + '-' + Math.random().toString(36).substring(2, 9),
             agentName: agentName || null,
             agentType: agentType || 'agent',
             llmName: llmName || null,
+            workflowName: workflowName || null,
             title: 'New conversation',
             messages: [],
             createdAt: Date.now(),
@@ -39,12 +40,14 @@ class SessionStore {
         return session;
     }
 
-    addMessage(sessionId, role, content) {
+    addMessage(sessionId, role, content, meta) {
         const sessions = this.getAll();
         const session = sessions.find(s => s.id === sessionId);
         if (!session) return;
 
-        session.messages.push({ role, content });
+        const msg = { role, content };
+        if (meta) msg.meta = meta;
+        session.messages.push(msg);
         session.updatedAt = Date.now();
 
         // Set title from first user message

package/dist/public/src/services/StreamManager.js

@@ -0,0 +1,183 @@
+
+import { sessionStore } from './SessionStore.js';
+
+class StreamManager {
+    constructor() {
+        this.streams = new Map();
+    }
+
+    start(sessionId, { response, abortController, streamType, inputMessage, responseId }) {
+        const existing = this.streams.get(sessionId);
+        if (existing?.abortController) {
+            try { existing.abortController.abort(); } catch {}
+        }
+
+        const state = {
+            streamType,
+            abortController,
+            inputMessage,
+            responseId,
+            content: '',
+            events: [],
+            status: 'streaming',
+            startTime: Date.now(),
+            usageData: null,
+            error: null,
+            listeners: new Set(),
+            taskId: null,
+        };
+
+        this.streams.set(sessionId, state);
+        this._process(sessionId, response, state);
+        return state;
+    }
+
+    getState(sessionId) {
+        return this.streams.get(sessionId) || null;
+    }
+
+    isActive(sessionId) {
+        const s = this.streams.get(sessionId);
+        return s?.status === 'streaming';
+    }
+
+    subscribe(sessionId, callback) {
+        const state = this.streams.get(sessionId);
+        if (!state) return () => {};
+        state.listeners.add(callback);
+        return () => state.listeners.delete(callback);
+    }
+
+    cancel(sessionId) {
+        const state = this.streams.get(sessionId);
+        if (state?.abortController) state.abortController.abort();
+    }
+
+    _buildMeta(state) {
+        const thinking = [];
+        const tools = [];
+        let currentThinking = '';
+        let lastWasThinking = false;
+
+        for (const event of state.events) {
+            if (event.type === 'thinking') {
+                currentThinking += event.content;
+                lastWasThinking = true;
+            } else {
+                if (lastWasThinking && currentThinking) {
+                    thinking.push(currentThinking);
+                    currentThinking = '';
+                }
+                lastWasThinking = false;
+            }
+
+            if (event.type === 'tool_start') {
+                tools.push({ runId: event.runId, tool: event.tool, input: event.input });
+            }
+            if (event.type === 'tool_end') {
+                const t = tools.find(t => t.runId === event.runId);
+                if (t) t.output = event.output;
+            }
+        }
+        if (currentThinking) thinking.push(currentThinking);
+
+        const elapsed = state.startTime ? Date.now() - state.startTime : 0;
+        const hasRealUsage = state.usageData && (state.usageData.input_tokens > 0 || state.usageData.output_tokens > 0);
+        const stats = {
+            elapsed,
+            inputTokens: hasRealUsage ? state.usageData.input_tokens : Math.round((state.inputMessage || '').length / 4),
+            outputTokens: hasRealUsage ? state.usageData.output_tokens : Math.round((state.content || '').length / 4),
+            cancelled: state.status === 'cancelled',
+            estimated: !hasRealUsage,
+        };
+
+        if (thinking.length === 0 && tools.length === 0 && !stats.elapsed) return null;
+        return { thinking, tools, stats };
+    }
+
+    async _process(sessionId, response, state) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+
+                for (const line of lines) {
+                    if (!line.trim() || !line.startsWith('data: ')) continue;
+                    const data = line.slice(6);
+                    if (data === '[DONE]') continue;
+
+                    try {
+                        const event = JSON.parse(data);
+
+                        // Capture task ID from server (first event)
+                        if (event.type === 'task_id') {
+                            state.taskId = event.taskId;
+                            continue;
+                        }
+
+                        state.events.push(event);
+
+                        if (state.streamType === 'agent') {
+                            if (event.type === 'content') state.content += event.content;
+                            if (event.type === 'usage') {
+                                state.usageData = {
+                                    input_tokens: event.input_tokens || 0,
+                                    output_tokens: event.output_tokens || 0,
+                                    total_tokens: event.total_tokens || 0,
+                                };
+                            }
+                            if (event.error) state.error = event.error;
+                        } else {
+                            if (event.type === 'usage') {
+                                state.usageData = {
+                                    input_tokens: event.input_tokens || 0,
+                                    output_tokens: event.output_tokens || 0,
+                                    total_tokens: event.total_tokens || 0,
+                                };
+                            } else if (event.type === 'thinking') {
+                                // thinking events are passed through to listeners, not accumulated into content
+                            } else if (event.error) {
+                                state.error = event.error;
+                            } else if (event.content) {
+                                state.content += event.content;
+                            }
+                        }
+
+                        for (const cb of state.listeners) cb(event);
+                    } catch (e) {
+                        console.error('StreamManager parse error:', e);
+                    }
+                }
+            }
+            state.status = 'done';
+        } catch (e) {
+            state.status = e.name === 'AbortError' ? 'cancelled' : 'error';
+            if (e.name !== 'AbortError') state.error = e.message;
+        }
+
+        if (state.content || state.events.length > 0) {
+            const meta = this._buildMeta(state);
+            sessionStore.addMessage(sessionId, 'assistant', state.content || '', meta);
+        }
+
+        for (const cb of state.listeners) {
+            cb({ type: '_stream_end', status: state.status });
+        }
+
+        setTimeout(() => {
+            if (this.streams.get(sessionId) === state) {
+                this.streams.delete(sessionId);
+            }
+        }, 10000);
+    }
+}
+
+export const streamManager = new StreamManager();

package/dist/public/src/store.js

@@ -2,7 +2,7 @@
 class Store extends EventTarget {
     constructor() {
         super();
-        const validTabs = ['agents', 'workflows', 'knowledge', 'mcp', 'skills', 'monitor', 'ide'];
+        const validTabs = ['agents', 'workflows', 'knowledge', 'graph', 'mcp', 'skills', 'monitor', 'llm', 'ide'];
         const hashTab = window.location.hash.replace('#', '');
         const initialTab = validTabs.includes(hashTab) ? hashTab : 'agents';
 

package/dist/public/src/utils/card.js

@@ -0,0 +1,21 @@
+/**
+ * Shared card utilities for consistent UI across views.
+ */
+
+export function escapeHtml(text) {
+    if (!text) return '';
+    return String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+export function resourceCard({ id, selected, content, className = '' }) {
+    const cls = selected ? 'card active' : 'card';
+    return `<div class="${cls} ${className}" data-name="${escapeHtml(id)}">${content}</div>`;
+}
+
+export function badge(text, variant = 'accent') {
+    return `<span class="badge badge-${variant}">${escapeHtml(text)}</span>`;
+}
+
+export function statusDot(status) {
+    return `<span class="status-dot status-dot-${status}"></span>`;
+}

package/dist/public/src/utils/markdown.js

@@ -6,8 +6,7 @@ export class MarkdownRenderer {
     // Configure marked for streaming-friendly rendering
     if (typeof marked !== 'undefined') {
       const renderer = new marked.Renderer();
-      renderer.link = ({ href, title, tokens }) => {
-        const text = this.#parseInlineTokens(tokens);
+      renderer.link = (href, title, text) => {
         const titleAttr = title ? ` title="${title}"` : '';
         return `<a href="${href}"${titleAttr} target="_blank" rel="noopener noreferrer">${text}</a>`;
       };
@@ -24,11 +23,6 @@ export class MarkdownRenderer {
 
   }
 
-  #parseInlineTokens(tokens) {
-    if (!tokens) return '';
-    return tokens.map(t => t.raw || t.text || '').join('');
-  }
-
   /**
    * Render markdown string to sanitized HTML
    * @param {string} markdown - Raw markdown text