agent-orcha 0.0.5 → 0.0.8

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

@@ -24,6 +24,11 @@ export class ApiService {
         return res.json();
     }
 
+    async checkSession(sessionId) {
+        const res = await this._fetch(`/api/agents/sessions/${sessionId}`);
+        return res.ok;
+    }
+
     async streamAgent(name, input, sessionId, { signal } = {}) {
         return this._fetch(`/api/agents/${name}/stream`, {
             method: 'POST',
@@ -43,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,
         });
     }
 
@@ -93,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',
@@ -102,11 +147,11 @@ export class ApiService {
         return res.json();
     }
 
-    async streamLLM(name, message, { signal } = {}) {
+    async streamLLM(name, message, sessionId, attachments, { signal } = {}) {
         return this._fetch(`/api/llm/${name}/stream`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ message }),
+            body: JSON.stringify({ message, sessionId, ...(attachments ? { attachments } : {}) }),
             signal
         });
     }
@@ -258,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

@@ -0,0 +1,86 @@
+
+const SESSIONS_KEY = 'orcha-sessions';
+const ACTIVE_KEY = 'orcha-active-session-id';
+const MAX_SESSIONS = 50;
+
+class SessionStore {
+    getAll() {
+        const raw = localStorage.getItem(SESSIONS_KEY);
+        const sessions = raw ? JSON.parse(raw) : [];
+        return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+
+    get(id) {
+        return this.getAll().find(s => s.id === id) || null;
+    }
+
+    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(),
+            updatedAt: Date.now()
+        };
+
+        sessions.unshift(session);
+
+        // Enforce max sessions — remove oldest
+        if (sessions.length > MAX_SESSIONS) {
+            sessions.length = MAX_SESSIONS;
+        }
+
+        this._save(sessions);
+        this.setActiveId(session.id);
+        return session;
+    }
+
+    addMessage(sessionId, role, content, meta) {
+        const sessions = this.getAll();
+        const session = sessions.find(s => s.id === sessionId);
+        if (!session) return;
+
+        const msg = { role, content };
+        if (meta) msg.meta = meta;
+        session.messages.push(msg);
+        session.updatedAt = Date.now();
+
+        // Set title from first user message
+        if (role === 'user' && session.title === 'New conversation') {
+            session.title = content.length > 50 ? content.substring(0, 50) + '...' : content;
+        }
+
+        this._save(sessions);
+    }
+
+    delete(sessionId) {
+        const sessions = this.getAll().filter(s => s.id !== sessionId);
+        this._save(sessions);
+        if (this.getActiveId() === sessionId) {
+            this.clearActiveId();
+        }
+    }
+
+    getActiveId() {
+        return localStorage.getItem(ACTIVE_KEY);
+    }
+
+    setActiveId(id) {
+        localStorage.setItem(ACTIVE_KEY, id);
+    }
+
+    clearActiveId() {
+        localStorage.removeItem(ACTIVE_KEY);
+    }
+
+    _save(sessions) {
+        localStorage.setItem(SESSIONS_KEY, JSON.stringify(sessions));
+    }
+}
+
+export const sessionStore = new SessionStore();

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';
 
@@ -10,8 +10,6 @@ class Store extends EventTarget {
             activeTab: initialTab,
             agents: [],
             selectedAgent: null,
-            chatHistory: [],
-            sessionId: 'session-' + Date.now() + '-' + Math.random().toString(36).substring(2, 9),
             workflows: [],
             knowledgeStores: [],
             llms: [],

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

@@ -5,12 +5,19 @@ export class MarkdownRenderer {
   constructor() {
     // Configure marked for streaming-friendly rendering
     if (typeof marked !== 'undefined') {
+      const renderer = new marked.Renderer();
+      renderer.link = (href, title, text) => {
+        const titleAttr = title ? ` title="${title}"` : '';
+        return `<a href="${href}"${titleAttr} target="_blank" rel="noopener noreferrer">${text}</a>`;
+      };
+
       marked.setOptions({
         gfm: true,              // GitHub Flavored Markdown
         breaks: true,           // Convert \n to <br>
         headerIds: false,       // Disable header IDs (not needed for chat)
         mangle: false,          // Don't mangle email addresses
         sanitize: false,        // We'll use DOMPurify instead
+        renderer,
       });
     }