@kafca/agentdock 0.1.46 → 0.1.47

package/dist-electron/services/local-ai-core/src/runtime/server.js

@@ -3,456 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalAiCoreServer = void 0;
 const node_http_1 = require("node:http");
 const server_routes_js_1 = require("./server-routes.js");
-const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
-class OpenAiChatCompletionStreamAdapter {
-    options;
-    created = Math.floor(Date.now() / 1000);
-    completionId;
-    assistantPreviewContentByHandle = new Map();
-    thoughtContentByHandle = new Map();
-    emittedMessageIds = new Set();
-    closed = false;
-    roleSent = false;
-    constructor(options) {
-        this.options = options;
-        this.completionId = `chatcmpl_${sanitizeOpenAiId(options.runId)}`;
-    }
-    start() {
-        this.options.response.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache, no-transform',
-            Connection: 'keep-alive',
-        });
-        this.sendChunk({ role: 'assistant' }, {
-            event: 'run_started',
-            kind: 'assistant',
-            run_id: this.options.runId,
-        });
-        this.roleSent = true;
-    }
-    handleBridgeEvent(event) {
-        if (this.closed || String(event.replyCtx || '') !== this.options.runId) {
-            return;
-        }
-        if (!this.roleSent) {
-            this.start();
-        }
-        if (event.type === 'typing_stop') {
-            this.finish('stop', { event: 'run_finished', kind: 'status' });
-            return;
-        }
-        if ((event.type === 'status' || event.type === 'card') && event.error) {
-            this.error(event.error, 'runtime_error');
-            return;
-        }
-        if (event.type === 'buttons' && event.bridgeKind === 'permission') {
-            this.error('Unexpected permission request for yolo OpenAI chat run.', 'unexpected_permission_request');
-            return;
-        }
-        if (event.type === 'preview_start' || event.type === 'update_message') {
-            this.handlePreviewEvent(event);
-            return;
-        }
-        if (event.type === 'reply') {
-            this.handleReplyEvent(event);
-            return;
-        }
-        if (event.type === 'status' || event.type === 'card') {
-            this.sendChunk({}, {
-                event: event.type,
-                kind: event.bridgeKind || 'status',
-                run_id: this.options.runId,
-                content: event.content,
-                ok: event.ok,
-                card: event.card,
-            });
-        }
-    }
-    replayMessage(input) {
-        if (this.closed || this.emittedMessageIds.has(input.id)) {
-            return;
-        }
-        this.emittedMessageIds.add(input.id);
-        const event = {
-            type: 'reply',
-            replyCtx: this.options.runId,
-            messageId: input.id,
-            content: input.content,
-            bridgeKind: input.bridgeKind,
-            bridgeStatus: input.bridgeStatus,
-            toolCall: input.toolCall,
-        };
-        this.handleReplyEvent(event);
-    }
-    finish(finishReason = 'stop', agentdock = {}) {
-        if (this.closed) {
-            return;
-        }
-        const chunk = this.baseChunk({}, {
-            run_id: this.options.runId,
-            ...agentdock,
-        }, finishReason);
-        this.options.response.write(createOpenAiSseData(chunk));
-        this.options.response.write(createOpenAiDone());
-        this.closed = true;
-        this.options.onClose();
-        this.options.response.end();
-    }
-    error(message, code = 'runtime_error') {
-        if (this.closed) {
-            return;
-        }
-        const chunk = this.baseChunk({}, {
-            run_id: this.options.runId,
-            event: 'error',
-            kind: 'status',
-        });
-        chunk.error = {
-            message,
-            type: code,
-            code,
-        };
-        this.options.response.write(createOpenAiSseData(chunk));
-        this.options.response.write(createOpenAiDone());
-        this.closed = true;
-        this.options.onClose();
-        this.options.response.end();
-    }
-    handlePreviewEvent(event) {
-        const content = String(event.content || '');
-        const handle = String(event.previewHandle || event.messageId || event.replyCtx || '');
-        if (!content || !handle) {
-            return;
-        }
-        if (event.bridgeKind === 'thought') {
-            const prior = this.thoughtContentByHandle.get(handle) || '';
-            const delta = diffAccumulatedText(prior, content);
-            this.thoughtContentByHandle.set(handle, content);
-            if (!delta) {
-                return;
-            }
-            this.sendProgressChunk(this.progressText('thinking', delta), {
-                event: 'thought_delta',
-                kind: 'thought',
-                run_id: this.options.runId,
-                thought: {
-                    content,
-                    delta,
-                    preview_handle: handle,
-                },
-            });
-            return;
-        }
-        if (event.bridgeKind && event.bridgeKind !== 'assistant') {
-            return;
-        }
-        const prior = this.assistantPreviewContentByHandle.get(handle) || '';
-        const delta = diffAccumulatedText(prior, content);
-        this.assistantPreviewContentByHandle.set(handle, content);
-        if (!delta) {
-            return;
-        }
-        this.sendChunk({ content: delta }, {
-            event: 'assistant_delta',
-            kind: 'assistant',
-            run_id: this.options.runId,
-            preview_handle: handle,
-        });
-    }
-    handleReplyEvent(event) {
-        const content = String(event.content || '');
-        if (event.messageId) {
-            if (this.emittedMessageIds.has(event.messageId)) {
-                return;
-            }
-            this.emittedMessageIds.add(event.messageId);
-        }
-        if (event.bridgeKind === 'tool') {
-            this.sendProgressChunk(this.formatToolProgressContent(event), {
-                event: 'tool_update',
-                kind: 'tool',
-                run_id: this.options.runId,
-                message_id: event.messageId,
-                tool: event.toolCall || {
-                    output: content,
-                },
-            });
-            return;
-        }
-        if (event.bridgeKind === 'plan') {
-            this.sendProgressChunk(this.progressText('plan', content), {
-                event: 'plan_update',
-                kind: 'plan',
-                run_id: this.options.runId,
-                message_id: event.messageId,
-                plan: {
-                    content,
-                },
-            });
-            return;
-        }
-        if (event.bridgeKind === 'thought') {
-            this.sendProgressChunk(this.progressText('thinking', content), {
-                event: 'thought_message',
-                kind: 'thought',
-                run_id: this.options.runId,
-                message_id: event.messageId,
-                thought: {
-                    content,
-                    delta: content,
-                },
-            });
-            return;
-        }
-        if (event.bridgeKind === 'status' || event.bridgeKind === 'permission') {
-            this.sendProgressChunk(this.progressText(event.bridgeKind, content), {
-                event: event.bridgeKind === 'permission' ? 'permission_required' : 'status',
-                kind: event.bridgeKind,
-                run_id: this.options.runId,
-                message_id: event.messageId,
-                content,
-                bridge_status: event.bridgeStatus,
-            });
-            return;
-        }
-        if (content) {
-            this.sendChunk({ content }, {
-                event: 'assistant_message',
-                kind: 'assistant',
-                run_id: this.options.runId,
-                message_id: event.messageId,
-            });
-        }
-    }
-    sendProgressChunk(content, agentdock) {
-        this.sendChunk(this.options.progressMode === 'content' && content ? { content } : {}, agentdock);
-    }
-    sendChunk(delta, agentdock, finishReason = null) {
-        if (this.closed) {
-            return;
-        }
-        this.options.response.write(createOpenAiSseData(this.baseChunk(delta, agentdock, finishReason)));
-    }
-    baseChunk(delta, agentdock, finishReason = null) {
-        return {
-            id: this.completionId,
-            object: 'chat.completion.chunk',
-            created: this.created,
-            model: this.options.model,
-            choices: [
-                {
-                    index: 0,
-                    delta,
-                    finish_reason: finishReason,
-                },
-            ],
-            agentdock,
-        };
-    }
-    progressText(kind, content) {
-        return content ? `\n\n[${kind}]\n${content}` : '';
-    }
-    formatToolProgressContent(event) {
-        const tool = event.toolCall;
-        const name = tool?.name || tool?.label || 'tool';
-        const status = tool?.status || '';
-        const output = tool?.output || tool?.detail || event.content || '';
-        return output ? `\n\n[tool:${name}${status ? ` ${status}` : ''}]\n${output}` : '';
-    }
-}
-function json(res, statusCode, data, ok = true, error) {
-    res.statusCode = statusCode;
-    res.setHeader('Content-Type', 'application/json; charset=utf-8');
-    res.end(JSON.stringify(ok ? { ok: true, data } : { ok: false, error }));
-}
-function rawJson(res, statusCode, data) {
-    res.statusCode = statusCode;
-    res.setHeader('Content-Type', 'application/json; charset=utf-8');
-    res.end(JSON.stringify(data));
-}
-function openAiJsonError(res, statusCode, message, code = 'invalid_request_error') {
-    rawJson(res, statusCode, {
-        error: {
-            message,
-            type: code,
-            code,
-        },
-    });
-}
-function jsonError(res, statusCode, error) {
-    const info = (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error);
-    res.statusCode = statusCode;
-    res.setHeader('Content-Type', 'application/json; charset=utf-8');
-    res.end(JSON.stringify((0, local_core_errors_js_1.errorInfoToHttpBody)(info)));
-}
-async function readJsonBody(req) {
-    const body = await readRawBody(req);
-    if (!body.length) {
-        return {};
-    }
-    return JSON.parse(Buffer.from(body).toString('utf8'));
-}
-async function readRawBody(req) {
-    const chunks = [];
-    for await (const chunk of req) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks);
-}
-function setCorsHeaders(req, res) {
-    const origin = String(req.headers.origin || '');
-    if (origin === 'null' || origin.startsWith('http://127.0.0.1:') || origin.startsWith('http://localhost:')) {
-        res.setHeader('Access-Control-Allow-Origin', origin);
-        res.setHeader('Vary', 'Origin');
-    }
-    res.setHeader('Access-Control-Allow-Methods', 'GET,POST,PATCH,DELETE,OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-}
-function createSseEvent(name, payload) {
-    return `event: ${name}\ndata: ${JSON.stringify(payload)}\n\n`;
-}
-function createOpenAiSseData(payload) {
-    return `data: ${JSON.stringify(payload)}\n\n`;
-}
-function createOpenAiDone() {
-    return 'data: [DONE]\n\n';
-}
-function sanitizeOpenAiId(value) {
-    return String(value || '')
-        .replace(/[^A-Za-z0-9_-]/g, '_')
-        .slice(0, 120) || 'run';
-}
-function diffAccumulatedText(previous, next) {
-    if (!next) {
-        return '';
-    }
-    if (!previous) {
-        return next;
-    }
-    if (next.startsWith(previous)) {
-        return next.slice(previous.length);
-    }
-    if (previous === next) {
-        return '';
-    }
-    return next;
-}
-function isTerminalAgentTaskStatus(status) {
-    return status === 'completed' || status === 'failed' || status === 'cancelled';
-}
-function extractMetadataValue(metadata, key) {
-    const value = metadata[key];
-    return String(value === undefined || value === null ? '' : value).trim();
-}
-function parseOpenAiChatCompletionRequest(input) {
-    const metadata = input.metadata && typeof input.metadata === 'object' && !Array.isArray(input.metadata)
-        ? input.metadata
-        : {};
-    const userId = extractMetadataValue(metadata, 'user_id') || String(input.user || '').trim();
-    const projectId = extractMetadataValue(metadata, 'project_id');
-    if (!userId) {
-        throw new Error('metadata.user_id is required.');
-    }
-    if (!projectId) {
-        throw new Error('metadata.project_id is required.');
-    }
-    const unsupported = [
-        input.tools !== undefined ? 'tools' : '',
-        input.tool_choice !== undefined ? 'tool_choice' : '',
-        input.response_format !== undefined ? 'response_format' : '',
-        input.audio !== undefined ? 'audio' : '',
-        input.logprobs !== undefined ? 'logprobs' : '',
-    ].filter(Boolean);
-    if (unsupported.length > 0) {
-        throw new Error(`Unsupported OpenAI chat field(s): ${unsupported.join(', ')}.`);
-    }
-    if (input.n !== undefined && Number(input.n) !== 1) {
-        throw new Error('Only n=1 is supported.');
-    }
-    const messages = Array.isArray(input.messages) ? input.messages : [];
-    if (messages.length === 0) {
-        throw new Error('messages must contain at least one text message.');
-    }
-    const prompt = messages
-        .map((message) => formatOpenAiMessage(message))
-        .filter(Boolean)
-        .join('\n\n');
-    if (!prompt.trim()) {
-        throw new Error('messages must contain text content.');
-    }
-    const progressMode = extractMetadataValue(metadata, 'agentdock_progress_mode') === 'content'
-        ? 'content'
-        : 'extension';
-    const model = String(input.model || extractMetadataValue(metadata, 'model') || '').trim();
-    const externalRun = {
-        user_id: userId,
-        external_project_id: projectId,
-        external_thread_id: extractMetadataValue(metadata, 'thread_id') || undefined,
-        display_name: extractMetadataValue(metadata, 'display_name') || undefined,
-        agent_type: extractMetadataValue(metadata, 'agent_type') || 'pi',
-        provider_id: extractMetadataValue(metadata, 'provider_id') || undefined,
-        model: model || undefined,
-        title: extractMetadataValue(metadata, 'title') || undefined,
-        metadata: {
-            ...metadata,
-            openai_compatible: true,
-        },
-        prompt,
-        permission_mode: 'bypassPermissions',
-        runtime_env: {
-            AGENTDOCK_OPENAI_COMPAT: '1',
-        },
-    };
-    return {
-        externalRun,
-        model: model || externalRun.agent_type || 'agentdock',
-        stream: Boolean(input.stream),
-        progressMode,
-    };
-}
-function formatOpenAiMessage(message) {
-    const role = String(message?.role || 'user').trim() || 'user';
-    const content = extractOpenAiMessageText(message?.content);
-    if (!content.trim()) {
-        return '';
-    }
-    if (role === 'user') {
-        return content;
-    }
-    return `[${role}]\n${content}`;
-}
-function extractOpenAiMessageText(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (content === null || content === undefined) {
-        return '';
-    }
-    if (!Array.isArray(content)) {
-        throw new Error('Only text message content is supported.');
-    }
-    return content.map((part) => {
-        const type = String(part?.type || 'text');
-        if (type !== 'text') {
-            throw new Error(`Only text message parts are supported; received ${type}.`);
-        }
-        return String(part?.text || '');
-    }).join('');
-}
-function collectAssistantMessagesForRun(snapshot) {
-    const thread = snapshot.thread;
-    const startedAt = Date.parse(snapshot.task?.startedAt || snapshot.task?.createdAt || '');
-    if (!thread || !Number.isFinite(startedAt)) {
-        return [];
-    }
-    return (thread.messages || []).filter((message) => {
-        if (message.role !== 'assistant') {
-            return false;
-        }
-        const messageAt = Date.parse(message.timestamp || '');
-        return Number.isFinite(messageAt) && messageAt >= startedAt;
-    });
-}
+const server_helpers_js_1 = require("./server-helpers.js");
+const runtime_handler_js_1 = require("./handlers/runtime-handler.js");
+const runtimes_handler_js_1 = require("./handlers/runtimes-handler.js");
+const thread_handler_js_1 = require("./handlers/thread-handler.js");
+const workspace_handler_js_1 = require("./handlers/workspace-handler.js");
+const security_handler_js_1 = require("./handlers/security-handler.js");
+const task_handler_js_1 = require("./handlers/task-handler.js");
+const scheduler_handler_js_1 = require("./handlers/scheduler-handler.js");
+const automation_handler_js_1 = require("./handlers/automation-handler.js");
+const knowledge_handler_js_1 = require("./handlers/knowledge-handler.js");
+const capabilities_handler_js_1 = require("./handlers/capabilities-handler.js");
+const provider_handler_js_1 = require("./handlers/provider-handler.js");
+const channel_handler_js_1 = require("./handlers/channel-handler.js");
+const external_handler_js_1 = require("./handlers/external-handler.js");
+const openai_handler_js_1 = require("./handlers/openai-handler.js");
 class LocalAiCoreServer {
     bindings;
     host;
@@ -462,6 +27,7 @@ class LocalAiCoreServer {
     externalReplayTimers = new Map();
     externalRunSseClients = new Map();
     openAiRunStreams = new Map();
+    handlers = new Map();
     server = (0, node_http_1.createServer)((req, res) => {
         void this.handleRequest(req, res);
     });
@@ -469,44 +35,8 @@ class LocalAiCoreServer {
         this.bindings = bindings;
         this.host = options.host || '127.0.0.1';
         this.port = options.port ?? 9831;
-        this.bindings.on('runtime', (runtime) => {
-            this.broadcast({ type: 'runtime.updated', runtime });
-        });
-        this.bindings.on('bridge', (bridge) => {
-            this.broadcast({ type: 'stream.updated', stream: bridge });
-            if (bridge.replyCtx) {
-                const runId = String(bridge.replyCtx);
-                this.broadcastExternalRunStream(runId, bridge);
-                this.broadcastOpenAiRunStream(runId, bridge);
-            }
-            if (bridge.sessionKey) {
-                const threadId = this.findThreadIdFromSessionKey(bridge.sessionKey);
-                this.broadcast({
-                    type: 'presence.updated',
-                    threadId,
-                    live: bridge.type !== 'typing_stop',
-                    stream: bridge,
-                });
-            }
-        });
-        this.bindings.on('thread-session-activated', (event) => {
-            this.broadcast({ type: 'thread.session.activated', ...event });
-        });
-        this.bindings.on('scheduler-job', (job) => {
-            this.broadcast({ type: 'scheduler.job.updated', job });
-        });
-        this.bindings.on('scheduler-run', (run) => {
-            this.broadcast({ type: 'scheduler.run.updated', run });
-        });
-        this.bindings.on('automation-monitor', (monitor) => {
-            this.broadcast({ type: 'automation.monitor.updated', monitor });
-        });
-        this.bindings.on('automation-monitor-run', (run) => {
-            this.broadcast({ type: 'automation.monitor.run.updated', run });
-        });
-        this.bindings.on('runtime-detection', (event) => {
-            this.broadcast(event);
-        });
+        this.registerHandlers();
+        this.wireEvents();
     }
     async start() {
         await new Promise((resolve, reject) => {
@@ -552,8 +82,82 @@ class LocalAiCoreServer {
             });
         });
     }
+    registerHandlers() {
+        const b = this.bindings;
+        (0, runtime_handler_js_1.registerRuntimeHandlers)(this.handlers, b.controller, b.errorReporter, (res) => this.attachSseClient(res));
+        (0, runtimes_handler_js_1.registerRuntimesHandlers)(this.handlers, b.runtimeDetection);
+        (0, thread_handler_js_1.registerThreadHandlers)(this.handlers, b.workspaceRouter);
+        (0, workspace_handler_js_1.registerWorkspaceHandlers)(this.handlers, b.workspaceRouter);
+        (0, security_handler_js_1.registerSecurityHandlers)(this.handlers, b.workspaceRouter);
+        (0, task_handler_js_1.registerTaskHandlers)(this.handlers, b.workspaceRouter);
+        (0, scheduler_handler_js_1.registerSchedulerHandlers)(this.handlers, b.scheduledJobs);
+        (0, automation_handler_js_1.registerAutomationHandlers)(this.handlers, b.automationMonitors);
+        (0, knowledge_handler_js_1.registerKnowledgeHandlers)(this.handlers, b.knowledgeProvider);
+        (0, capabilities_handler_js_1.registerCapabilitiesHandlers)(this.handlers, b.kernel);
+        (0, provider_handler_js_1.registerProviderHandlers)(this.handlers, b.store);
+        (0, channel_handler_js_1.registerChannelHandlers)(this.handlers, b.channelService);
+        (0, external_handler_js_1.registerExternalHandlers)(this.handlers, b.externalService, (runId, res) => this.attachExternalRunSseClient(runId, res));
+        const openAiReg = {
+            addAdapter: (runId, adapter) => {
+                const adapters = this.openAiRunStreams.get(runId) || new Set();
+                adapters.add(adapter);
+                this.openAiRunStreams.set(runId, adapters);
+            },
+            removeAdapter: (runId, adapter) => {
+                const adapters = this.openAiRunStreams.get(runId);
+                if (adapters) {
+                    adapters.delete(adapter);
+                    if (adapters.size === 0) {
+                        this.openAiRunStreams.delete(runId);
+                    }
+                }
+            },
+        };
+        (0, openai_handler_js_1.registerOpenAiHandler)(this.handlers, b.externalService, openAiReg);
+    }
+    wireEvents() {
+        const b = this.bindings;
+        b.controller.on('runtime', (runtime) => {
+            this.broadcast({ type: 'runtime.updated', runtime });
+        });
+        b.controller.on('bridge', (bridge) => {
+            this.broadcast({ type: 'stream.updated', stream: bridge });
+            if (bridge.replyCtx) {
+                const runId = String(bridge.replyCtx);
+                this.broadcastExternalRunStream(runId, bridge);
+                this.broadcastOpenAiRunStream(runId, bridge);
+            }
+            if (bridge.sessionKey) {
+                const threadId = this.findThreadIdFromSessionKey(bridge.sessionKey);
+                this.broadcast({
+                    type: 'presence.updated',
+                    threadId,
+                    live: bridge.type !== 'typing_stop',
+                    stream: bridge,
+                });
+            }
+        });
+        b.controller.on('thread-session-activated', (event) => {
+            this.broadcast({ type: 'thread.session.activated', ...event });
+        });
+        b.controller.on('scheduler-job', (job) => {
+            this.broadcast({ type: 'scheduler.job.updated', job });
+        });
+        b.controller.on('scheduler-run', (run) => {
+            this.broadcast({ type: 'scheduler.run.updated', run });
+        });
+        b.controller.on('automation-monitor', (monitor) => {
+            this.broadcast({ type: 'automation.monitor.updated', monitor });
+        });
+        b.controller.on('automation-monitor-run', (run) => {
+            this.broadcast({ type: 'automation.monitor.run.updated', run });
+        });
+        b.controller.on('runtime-detection', (event) => {
+            this.broadcast(event);
+        });
+    }
     async handleRequest(req, res) {
-        setCorsHeaders(req, res);
+        (0, server_helpers_js_1.setCorsHeaders)(req, res);
         if (req.method === 'OPTIONS') {
             res.statusCode = 204;
             res.end();
@@ -564,467 +168,19 @@ class LocalAiCoreServer {
         try {
             const route = (0, server_routes_js_1.parseLocalAiCoreRoute)(req.method, path);
             if (route) {
-                await this.handleParsedRoute(route, req, res, url);
-                return;
-            }
-            jsonError(res, 404, new Error(`Unknown route: ${path}`));
-        }
-        catch (error) {
-            jsonError(res, 500, error);
-        }
-    }
-    async handleParsedRoute(route, req, res, url) {
-        switch (route.name) {
-            case 'health':
-                json(res, 200, { name: 'local-ai-core', version: '0.1.0' });
-                return;
-            case 'runtime.status':
-                json(res, 200, await this.bindings.getRuntimeStatus());
-                return;
-            case 'runtime.service.start':
-                json(res, 200, await this.bindings.startService());
-                return;
-            case 'runtime.service.stop':
-                json(res, 200, await this.bindings.stopService());
-                return;
-            case 'runtime.service.restart':
-                json(res, 200, await this.bindings.restartService());
-                return;
-            case 'runtime.logs': {
-                const limit = Number(url.searchParams.get('limit') || '200');
-                json(res, 200, this.bindings.getLogs(limit));
-                return;
-            }
-            case 'logs.list': {
-                const level = url.searchParams.get('level') || 'sys';
-                const limit = Number(url.searchParams.get('limit') || '200');
-                json(res, 200, {
-                    entries: this.bindings.getLogEntries(level, limit).map((entry) => ({
-                        time: entry.ts,
-                        level: entry.level,
-                        scope: entry.scope,
-                        message: entry.message,
-                        meta: entry.meta,
-                    })),
-                });
-                return;
-            }
-            case 'runtime.agent-runtimes':
-            case 'runtimes.list':
-                json(res, 200, await this.runtimeDetectionResponse());
-                return;
-            case 'runtimes.detail': {
-                const runtimes = await this.bindings.listInstalledAgentRuntimes();
-                const runtime = runtimes.find((entry) => entry.runtimeId === route.runtimeId || entry.agentType === route.runtimeId);
-                if (!runtime) {
-                    json(res, 404, null, false, 'Runtime not found');
+                const handler = this.handlers.get(route.name);
+                if (handler) {
+                    await handler(route, req, res, url);
                     return;
                 }
-                json(res, 200, runtime);
-                return;
-            }
-            case 'runtimes.refresh': {
-                const runtimes = await this.bindings.refreshInstalledAgentRuntimes();
-                json(res, 200, { runtimes, checking: this.bindings.isRuntimeDetectionRunning() });
-                return;
-            }
-            case 'runtimes.refresh-one': {
-                const runtimes = await this.bindings.refreshInstalledAgentRuntimes(route.runtimeId);
-                json(res, 200, { runtimes, checking: this.bindings.isRuntimeDetectionRunning(route.runtimeId) });
-                return;
-            }
-            case 'runtime.config.read':
-                json(res, 200, await this.bindings.readConfigFile());
-                return;
-            case 'runtime.config.save-raw': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.saveRawConfigFile(String(body.raw || '')));
-                return;
-            }
-            case 'runtime.config.save-structured': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.saveStructuredConfigFile((body.config || {})));
-                return;
-            }
-            case 'runtime.settings.save': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.saveSettings(body));
-                return;
-            }
-            case 'scheduler.jobs.list': {
-                const workspaceId = String(url.searchParams.get('workspace_id') || '');
-                json(res, 200, { jobs: await this.bindings.listScheduledJobs(workspaceId || undefined) });
-                return;
-            }
-            case 'scheduler.jobs.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createScheduledJob(body));
-                return;
-            }
-            case 'scheduler.job.get':
-                json(res, 200, await this.bindings.getScheduledJob(route.jobId));
-                return;
-            case 'scheduler.job.runs':
-                json(res, 200, { runs: await this.bindings.listScheduledJobRuns(route.jobId) });
-                return;
-            case 'scheduler.job.run':
-                json(res, 200, await this.bindings.runScheduledJob(route.jobId));
-                return;
-            case 'scheduler.job.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateScheduledJob(route.jobId, body));
-                return;
-            }
-            case 'scheduler.job.delete':
-                json(res, 200, await this.bindings.deleteScheduledJob(route.jobId));
-                return;
-            case 'automation.monitors.list': {
-                const workspaceId = String(url.searchParams.get('workspace_id') || '');
-                json(res, 200, { monitors: await this.bindings.listAutomationMonitors(workspaceId || undefined) });
-                return;
-            }
-            case 'automation.monitors.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createAutomationMonitor(body));
-                return;
-            }
-            case 'automation.monitor.get':
-                json(res, 200, await this.bindings.getAutomationMonitor(route.monitorId));
-                return;
-            case 'automation.monitor.runs':
-                json(res, 200, { runs: await this.bindings.listAutomationMonitorRuns(route.monitorId) });
-                return;
-            case 'automation.monitor.run':
-                json(res, 200, await this.bindings.runAutomationMonitor(route.monitorId));
-                return;
-            case 'automation.monitor.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateAutomationMonitor(route.monitorId, body));
-                return;
-            }
-            case 'automation.monitor.delete':
-                json(res, 200, await this.bindings.deleteAutomationMonitor(route.monitorId));
-                return;
-            case 'threads.list': {
-                const workspaceId = String(url.searchParams.get('workspace_id') || '');
-                json(res, 200, { threads: workspaceId ? await this.bindings.listThreads(workspaceId) : [] });
-                return;
-            }
-            case 'threads.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createThread(String(body.workspaceId || ''), String(body.title || '') || undefined));
-                return;
-            }
-            case 'thread.get':
-                json(res, 200, await this.bindings.getThread(route.threadId));
-                return;
-            case 'thread.update-knowledge-bases': {
-                const body = await readJsonBody(req);
-                const knowledgeBaseIds = Array.isArray(body.knowledgeBaseIds)
-                    ? body.knowledgeBaseIds.map((value) => String(value || ''))
-                    : [];
-                json(res, 200, await this.bindings.updateThreadKnowledgeBases(route.threadId, knowledgeBaseIds));
-                return;
-            }
-            case 'thread.rename': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.renameThread(route.threadId, String(body.title || '')));
+                (0, server_helpers_js_1.jsonError)(res, 404, new Error(`No handler for route: ${route.name}`));
                 return;
             }
-            case 'thread.delete':
-                json(res, 200, await this.bindings.deleteThread(route.threadId));
-                return;
-            case 'thread.messages.send': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.sendThreadMessage(route.threadId, String(body.content || '')));
-                return;
-            }
-            case 'thread.actions.send': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.sendThreadAction(route.threadId, String(body.content || '')));
-                return;
-            }
-            case 'run.interrupt':
-                json(res, 200, await this.bindings.interruptRun(route.runId));
-                return;
-            case 'workspaces.list':
-                json(res, 200, { workspaces: await this.bindings.listWorkspaces() });
-                return;
-            case 'workspace.streaming-probe':
-                json(res, 200, await this.bindings.probeWorkspaceStreaming(route.workspaceId));
-                return;
-            case 'workspace-registry.list':
-                json(res, 200, { workspaces: await this.bindings.listWorkspaceRegistry() });
-                return;
-            case 'workspace-registry.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createWorkspaceRegistryEntry(body));
-                return;
-            }
-            case 'workspace-registry.get':
-                json(res, 200, await this.bindings.getWorkspaceRegistryEntry(route.workspaceId));
-                return;
-            case 'workspace-registry.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateWorkspaceRegistryEntry(route.workspaceId, body));
-                return;
-            }
-            case 'workspace-registry.delete':
-                json(res, 200, await this.bindings.deleteWorkspaceRegistryEntry(route.workspaceId));
-                return;
-            case 'providers.list':
-                json(res, 200, await this.bindings.listModelProviders());
-                return;
-            case 'providers.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createModelProvider(body));
-                return;
-            }
-            case 'provider.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateModelProvider(route.providerId, body));
-                return;
-            }
-            case 'provider.delete':
-                json(res, 200, await this.bindings.deleteModelProvider(route.providerId));
-                return;
-            case 'external.project.ensure': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.ensureExternalProject(body));
-                return;
-            }
-            case 'external.run.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createExternalRun(body));
-                return;
-            }
-            case 'external.run.events':
-                await this.attachExternalRunSseClient(route.runId, res);
-                return;
-            case 'openai.chat.completions':
-                await this.handleOpenAiChatCompletions(req, res);
-                return;
-            case 'workspace-security.get':
-                json(res, 200, await this.bindings.getWorkspaceSecuritySettings(route.workspaceId));
-                return;
-            case 'workspace-security.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateWorkspaceSecuritySettings(route.workspaceId, body));
-                return;
-            }
-            case 'security.command-risk.classify': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.classifyCommand(String(body.command || ''), String(body.workspaceId || '') || undefined));
-                return;
-            }
-            case 'approvals.list': {
-                const statusParam = url.searchParams.get('status') || '';
-                const status = statusParam ? statusParam.split(',').map((item) => item.trim()).filter(Boolean) : undefined;
-                json(res, 200, await this.bindings.listApprovalRequests({
-                    workspaceId: url.searchParams.get('workspace_id') || undefined,
-                    taskId: url.searchParams.get('task_id') || undefined,
-                    status,
-                    limit: Number(url.searchParams.get('limit') || '50'),
-                }));
-                return;
-            }
-            case 'approvals.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createApprovalRequest(body));
-                return;
-            }
-            case 'approval.get':
-                json(res, 200, await this.bindings.getApprovalRequest(route.approvalId));
-                return;
-            case 'approval.resolve': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.resolveApprovalRequest(route.approvalId, body));
-                return;
-            }
-            case 'audit-events.list': {
-                const typeParam = url.searchParams.get('type') || '';
-                const type = typeParam ? typeParam.split(',').map((item) => item.trim()).filter(Boolean) : undefined;
-                json(res, 200, await this.bindings.listAuditEvents({
-                    workspaceId: url.searchParams.get('workspace_id') || undefined,
-                    taskId: url.searchParams.get('task_id') || undefined,
-                    approvalId: url.searchParams.get('approval_id') || undefined,
-                    type,
-                    limit: Number(url.searchParams.get('limit') || '50'),
-                }));
-                return;
-            }
-            case 'tasks.list': {
-                const statusParam = url.searchParams.get('status') || '';
-                const status = statusParam ? statusParam.split(',').map((item) => item.trim()).filter(Boolean) : undefined;
-                json(res, 200, await this.bindings.listAgentTasks({
-                    workspaceId: url.searchParams.get('workspace_id') || undefined,
-                    runtimeId: url.searchParams.get('runtime_id') || undefined,
-                    status,
-                    limit: Number(url.searchParams.get('limit') || '50'),
-                }));
-                return;
-            }
-            case 'tasks.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createAgentTask(body));
-                return;
-            }
-            case 'task.get':
-                json(res, 200, await this.bindings.getAgentTask(route.taskId));
-                return;
-            case 'task.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateAgentTask(route.taskId, body));
-                return;
-            }
-            case 'knowledge.sources.list':
-                json(res, 200, { sources: await this.bindings.listKnowledgeSources() });
-                return;
-            case 'knowledge.config.read':
-                json(res, 200, await this.bindings.getKnowledgeConfig());
-                return;
-            case 'knowledge.config.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateKnowledgeConfig(body));
-                return;
-            }
-            case 'knowledge.folders.list':
-                json(res, 200, { folders: await this.bindings.listKnowledgeFolders() });
-                return;
-            case 'knowledge.folders.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createKnowledgeFolder(body));
-                return;
-            }
-            case 'knowledge.folder.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateKnowledgeFolder(route.folderId, body));
-                return;
-            }
-            case 'knowledge.folder.delete':
-                json(res, 200, await this.bindings.deleteKnowledgeFolder(route.folderId));
-                return;
-            case 'knowledge.bases.list':
-                json(res, 200, { bases: await this.bindings.listKnowledgeBases() });
-                return;
-            case 'knowledge.bases.create': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.createKnowledgeBase(body));
-                return;
-            }
-            case 'knowledge.base.get':
-                json(res, 200, await this.bindings.getKnowledgeBase(route.knowledgeBaseId));
-                return;
-            case 'knowledge.base.update': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.updateKnowledgeBase(route.knowledgeBaseId, body));
-                return;
-            }
-            case 'knowledge.base.delete':
-                json(res, 200, await this.bindings.deleteKnowledgeBase(route.knowledgeBaseId));
-                return;
-            case 'knowledge.base.files.list':
-                json(res, 200, { files: await this.bindings.listKnowledgeBaseFiles(route.knowledgeBaseId) });
-                return;
-            case 'knowledge.base.files.upload': {
-                const contentType = String(req.headers['content-type'] || '').trim();
-                if (!contentType) {
-                    throw new Error('Upload content type is required.');
-                }
-                const body = await readRawBody(req);
-                json(res, 200, { results: await this.bindings.uploadKnowledgeBaseFiles(route.knowledgeBaseId, { contentType, body }) });
-                return;
-            }
-            case 'knowledge.base.file.delete':
-                json(res, 200, await this.bindings.deleteKnowledgeBaseFile(route.knowledgeBaseId, route.fileId));
-                return;
-            case 'knowledge.base.search': {
-                const body = await readJsonBody(req);
-                json(res, 200, { results: await this.bindings.searchKnowledgeBase(route.knowledgeBaseId, body) });
-                return;
-            }
-            case 'capabilities.read':
-                json(res, 200, await this.bindings.getCapabilities());
-                return;
-            case 'capabilities.snapshot':
-                json(res, 200, await this.bindings.getCapabilitySnapshot());
-                return;
-            case 'diagnostics.errors':
-                json(res, 200, { errors: await this.bindings.listDiagnosticErrors() });
-                return;
-            case 'diagnostics.doctor':
-                json(res, 200, await this.bindings.runDiagnosticsDoctor());
-                return;
-            case 'diagnostics.deployment':
-                json(res, 200, await this.bindings.runDeploymentDiagnostics());
-                return;
-            case 'plugins.diagnostics':
-                json(res, 200, await this.bindings.getPluginDiagnostics());
-                return;
-            case 'events.stream':
-                this.attachSseClient(res);
-                return;
-            case 'platform.gateways.list':
-                json(res, 200, { gateways: await this.bindings.listChannelGatewayStatuses(route.platform) });
-                return;
-            case 'platform.pairings.list': {
-                const workspaceId = String(url.searchParams.get('workspace_id') || '');
-                json(res, 200, { pairings: await this.bindings.listChannelPendingPairings(route.platform, workspaceId || undefined) });
-                return;
-            }
-            case 'platform.users.list': {
-                const workspaceId = String(url.searchParams.get('workspace_id') || '');
-                json(res, 200, { users: await this.bindings.listChannelAuthorizedUsers(route.platform, workspaceId || undefined) });
-                return;
-            }
-            case 'platform.gateway.get':
-                json(res, 200, await this.bindings.getChannelGatewayStatus(route.platform, route.workspaceId, this.channelInstanceId(url)));
-                return;
-            case 'platform.qrcode.status': {
-                const ticket = String(url.searchParams.get('ticket') || '');
-                if (!ticket) {
-                    jsonError(res, 400, new Error('Missing ticket parameter'));
-                    return;
-                }
-                json(res, 200, await this.bindings.checkChannelQrCodeStatus(route.platform, route.workspaceId, ticket, this.channelInstanceId(url)));
-                return;
-            }
-            case 'platform.pairing.approve': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.approveChannelPairing(route.platform, String(body.code || '')));
-                return;
-            }
-            case 'platform.pairing.reject': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.rejectChannelPairing(route.platform, String(body.code || '')));
-                return;
-            }
-            case 'platform.gateway.test':
-                json(res, 200, await this.bindings.testChannelConnection(route.platform, route.workspaceId, this.channelInstanceId(url)));
-                return;
-            case 'platform.gateway.enable':
-                json(res, 200, await this.bindings.enableChannelGateway(route.platform, route.workspaceId, this.channelInstanceId(url)));
-                return;
-            case 'platform.gateway.disable':
-                json(res, 200, await this.bindings.disableChannelGateway(route.platform, route.workspaceId, this.channelInstanceId(url)));
-                return;
-            case 'platform.file.send': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.sendChannelFile(route.platform, route.workspaceId, body));
-                return;
-            }
-            case 'platform.message.send': {
-                const body = await readJsonBody(req);
-                json(res, 200, await this.bindings.sendChannelMessage(route.platform, route.workspaceId, body));
-                return;
-            }
-            case 'platform.qrcode.create':
-                json(res, 200, await this.bindings.getChannelQrCode(route.platform, route.workspaceId, this.channelInstanceId(url)));
-                return;
+            (0, server_helpers_js_1.jsonError)(res, 404, new Error(`Unknown route: ${path}`));
+        }
+        catch (error) {
+            (0, server_helpers_js_1.jsonError)(res, 500, error);
         }
-    }
-    channelInstanceId(url) {
-        return String(url.searchParams.get('instance_id') || url.searchParams.get('instanceId') || '').trim() || undefined;
     }
     attachSseClient(res) {
         res.writeHead(200, {
@@ -1060,7 +216,7 @@ class LocalAiCoreServer {
         }, 15000);
         this.heartbeatTimers.set(res, heartbeat);
         const replayTimer = setInterval(() => {
-            void this.bindings.getExternalRunSnapshot(runId)
+            void this.bindings.externalService.getRunSnapshot(runId)
                 .then((snapshot) => this.replayExternalRunMessages(res, runId, snapshot, replayedMessageIds))
                 .catch(() => undefined);
         }, 1000);
@@ -1075,131 +231,15 @@ class LocalAiCoreServer {
                 this.externalRunSseClients.delete(runId);
             }
         });
-        const snapshot = await this.bindings.getExternalRunSnapshot(runId);
-        res.write(createSseEvent('external.run.snapshot', {
+        const snapshot = await this.bindings.externalService.getRunSnapshot(runId);
+        res.write((0, server_helpers_js_1.createSseEvent)('external.run.snapshot', {
             type: 'external.run.snapshot',
             snapshot,
         }));
         this.replayExternalRunMessages(res, runId, snapshot, replayedMessageIds);
     }
-    async handleOpenAiChatCompletions(req, res) {
-        let parsed;
-        try {
-            parsed = parseOpenAiChatCompletionRequest(await readJsonBody(req));
-        }
-        catch (error) {
-            openAiJsonError(res, 400, error instanceof Error ? error.message : String(error));
-            return;
-        }
-        if (parsed.stream) {
-            await this.handleOpenAiStreamingChatCompletion(parsed, res);
-            return;
-        }
-        await this.handleOpenAiNonStreamingChatCompletion(parsed, res);
-    }
-    async handleOpenAiStreamingChatCompletion(parsed, res) {
-        try {
-            const created = await this.bindings.createExternalRun(parsed.externalRun);
-            const adapters = this.openAiRunStreams.get(created.run_id) || new Set();
-            const adapter = new OpenAiChatCompletionStreamAdapter({
-                runId: created.run_id,
-                model: parsed.model,
-                response: res,
-                progressMode: parsed.progressMode,
-                onClose: () => {
-                    adapters.delete(adapter);
-                    if (adapters.size === 0) {
-                        this.openAiRunStreams.delete(created.run_id);
-                    }
-                },
-            });
-            adapters.add(adapter);
-            this.openAiRunStreams.set(created.run_id, adapters);
-            adapter.start();
-            res.on('close', () => {
-                adapters.delete(adapter);
-                if (adapters.size === 0) {
-                    this.openAiRunStreams.delete(created.run_id);
-                }
-            });
-            const snapshot = await this.bindings.getExternalRunSnapshot(created.run_id);
-            this.replayOpenAiRunMessages(adapter, snapshot);
-            if (isTerminalAgentTaskStatus(snapshot.task?.status)) {
-                adapter.finish('stop', { event: 'run_finished', kind: 'status' });
-            }
-        }
-        catch (error) {
-            openAiJsonError(res, 500, error instanceof Error ? error.message : String(error), 'agentdock_run_error');
-        }
-    }
-    async handleOpenAiNonStreamingChatCompletion(parsed, res) {
-        let created;
-        try {
-            created = await this.bindings.createExternalRun(parsed.externalRun);
-        }
-        catch (error) {
-            openAiJsonError(res, 500, error instanceof Error ? error.message : String(error), 'agentdock_run_error');
-            return;
-        }
-        const started = Date.now();
-        const timeoutMs = 10 * 60 * 1000;
-        let snapshot = await this.bindings.getExternalRunSnapshot(created.run_id);
-        while (!isTerminalAgentTaskStatus(snapshot.task?.status) && Date.now() - started < timeoutMs) {
-            await new Promise((resolve) => setTimeout(resolve, 500));
-            snapshot = await this.bindings.getExternalRunSnapshot(created.run_id);
-        }
-        if (!isTerminalAgentTaskStatus(snapshot.task?.status)) {
-            openAiJsonError(res, 504, 'OpenAI-compatible chat completion timed out waiting for the agent run.', 'run_timeout');
-            return;
-        }
-        if (snapshot.task?.status === 'failed') {
-            openAiJsonError(res, 500, snapshot.task.error || 'Agent run failed.', 'agentdock_run_failed');
-            return;
-        }
-        if (snapshot.task?.status === 'cancelled') {
-            openAiJsonError(res, 500, snapshot.task.error || 'Agent run was cancelled.', 'agentdock_run_cancelled');
-            return;
-        }
-        const messages = collectAssistantMessagesForRun(snapshot);
-        const finalContent = messages
-            .filter((message) => message.kind === 'final' || !message.bridgeKind || message.bridgeKind === 'assistant')
-            .map((message) => message.content)
-            .filter(Boolean)
-            .join('\n\n');
-        const response = {
-            id: `chatcmpl_${sanitizeOpenAiId(created.run_id)}`,
-            object: 'chat.completion',
-            created: Math.floor(Date.now() / 1000),
-            model: parsed.model,
-            choices: [
-                {
-                    index: 0,
-                    message: {
-                        role: 'assistant',
-                        content: finalContent,
-                    },
-                    finish_reason: 'stop',
-                },
-            ],
-            agentdock: {
-                run_id: created.run_id,
-                workspace_id: created.workspace_id,
-                thread_id: created.thread_id,
-                task_id: created.task_id,
-                events: messages
-                    .filter((message) => message.bridgeKind && message.bridgeKind !== 'assistant')
-                    .map((message) => ({
-                    event: `${message.bridgeKind}_update`,
-                    kind: message.bridgeKind,
-                    content: message.content,
-                    tool: message.toolCall,
-                })),
-            },
-        };
-        rawJson(res, 200, response);
-    }
     broadcast(event) {
-        const payload = createSseEvent(event.type, event);
+        const payload = (0, server_helpers_js_1.createSseEvent)(event.type, event);
         for (const client of this.sseClients) {
             client.write(payload);
         }
@@ -1209,7 +249,7 @@ class LocalAiCoreServer {
         if (!clients?.size) {
             return;
         }
-        const payload = createSseEvent('external.run.stream', {
+        const payload = (0, server_helpers_js_1.createSseEvent)('external.run.stream', {
             type: 'external.run.stream',
             runId,
             stream,
@@ -1227,17 +267,6 @@ class LocalAiCoreServer {
             adapter.handleBridgeEvent(stream);
         }
     }
-    replayOpenAiRunMessages(adapter, snapshot) {
-        for (const message of collectAssistantMessagesForRun(snapshot)) {
-            adapter.replayMessage({
-                id: message.id,
-                content: message.content,
-                bridgeKind: message.bridgeKind,
-                bridgeStatus: message.bridgeStatus,
-                toolCall: message.toolCall,
-            });
-        }
-    }
     replayExternalRunMessages(res, runId, snapshot, replayedMessageIds) {
         const thread = snapshot.thread;
         const startedAt = Date.parse(snapshot.task?.startedAt || snapshot.task?.createdAt || '');
@@ -1256,7 +285,7 @@ class LocalAiCoreServer {
                 continue;
             }
             replayedMessageIds.add(message.id);
-            res.write(createSseEvent('external.run.stream', {
+            res.write((0, server_helpers_js_1.createSseEvent)('external.run.stream', {
                 type: 'external.run.stream',
                 runId,
                 stream: {
@@ -1270,12 +299,6 @@ class LocalAiCoreServer {
             }));
         }
     }
-    async runtimeDetectionResponse() {
-        return {
-            runtimes: await this.bindings.listInstalledAgentRuntimes(),
-            checking: this.bindings.isRuntimeDetectionRunning(),
-        };
-    }
     findThreadIdFromSessionKey(sessionKey) {
         const parts = sessionKey.split(':');
         if (parts.length < 3) {