@kafca/agentdock 0.1.46 → 0.1.47

package/dist-electron/services/local-ai-core/src/runtime/handlers/openai-handler.js

@@ -0,0 +1,496 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAiChatCompletionStreamAdapter = void 0;
+exports.registerOpenAiHandler = registerOpenAiHandler;
+const server_helpers_js_1 = require("../server-helpers.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_${(0, server_helpers_js_1.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((0, server_helpers_js_1.createOpenAiSseData)(chunk));
+        this.options.response.write((0, server_helpers_js_1.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((0, server_helpers_js_1.createOpenAiSseData)(chunk));
+        this.options.response.write((0, server_helpers_js_1.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 = (0, server_helpers_js_1.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 = (0, server_helpers_js_1.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((0, server_helpers_js_1.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}` : '';
+    }
+}
+exports.OpenAiChatCompletionStreamAdapter = OpenAiChatCompletionStreamAdapter;
+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;
+    });
+}
+function registerOpenAiHandler(map, externalService, streamReg) {
+    map.set('openai.chat.completions', async (_route, req, res) => {
+        let parsed;
+        try {
+            parsed = parseOpenAiChatCompletionRequest(await (0, server_helpers_js_1.readJsonBody)(req));
+        }
+        catch (error) {
+            (0, server_helpers_js_1.openAiJsonError)(res, 400, error instanceof Error ? error.message : String(error));
+            return;
+        }
+        if (parsed.stream) {
+            await handleStreaming(externalService, streamReg, parsed, res);
+            return;
+        }
+        await handleNonStreaming(externalService, parsed, res);
+    });
+}
+async function handleStreaming(externalService, streamReg, parsed, res) {
+    try {
+        const created = await externalService.createRun(parsed.externalRun);
+        const adapter = new OpenAiChatCompletionStreamAdapter({
+            runId: created.run_id,
+            model: parsed.model,
+            response: res,
+            progressMode: parsed.progressMode,
+            onClose: () => {
+                streamReg.removeAdapter(created.run_id, adapter);
+            },
+        });
+        streamReg.addAdapter(created.run_id, adapter);
+        adapter.start();
+        res.on('close', () => {
+            streamReg.removeAdapter(created.run_id, adapter);
+        });
+        const snapshot = await externalService.getRunSnapshot(created.run_id);
+        replayOpenAiRunMessages(adapter, snapshot);
+        if ((0, server_helpers_js_1.isTerminalAgentTaskStatus)(snapshot.task?.status)) {
+            adapter.finish('stop', { event: 'run_finished', kind: 'status' });
+        }
+    }
+    catch (error) {
+        (0, server_helpers_js_1.openAiJsonError)(res, 500, error instanceof Error ? error.message : String(error), 'agentdock_run_error');
+    }
+}
+async function handleNonStreaming(externalService, parsed, res) {
+    let created;
+    try {
+        created = await externalService.createRun(parsed.externalRun);
+    }
+    catch (error) {
+        (0, server_helpers_js_1.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 externalService.getRunSnapshot(created.run_id);
+    while (!(0, server_helpers_js_1.isTerminalAgentTaskStatus)(snapshot.task?.status) && Date.now() - started < timeoutMs) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        snapshot = await externalService.getRunSnapshot(created.run_id);
+    }
+    if (!(0, server_helpers_js_1.isTerminalAgentTaskStatus)(snapshot.task?.status)) {
+        (0, server_helpers_js_1.openAiJsonError)(res, 504, 'OpenAI-compatible chat completion timed out waiting for the agent run.', 'run_timeout');
+        return;
+    }
+    if (snapshot.task?.status === 'failed') {
+        (0, server_helpers_js_1.openAiJsonError)(res, 500, snapshot.task.error || 'Agent run failed.', 'agentdock_run_failed');
+        return;
+    }
+    if (snapshot.task?.status === 'cancelled') {
+        (0, server_helpers_js_1.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_${(0, server_helpers_js_1.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,
+            })),
+        },
+    };
+    (0, server_helpers_js_1.rawJson)(res, 200, response);
+}
+function 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,
+        });
+    }
+}

package/dist-electron/services/local-ai-core/src/runtime/handlers/provider-handler.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerProviderHandlers = registerProviderHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+function registerProviderHandlers(map, store) {
+    map.set('providers.list', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { providers: store.listModelProviders() });
+    });
+    map.set('providers.create', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await store.upsertModelProvider(body));
+    });
+    map.set('provider.update', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        const existing = store.getModelProvider(route.providerId);
+        if (!existing) {
+            throw new Error(`Provider not found: ${route.providerId}`);
+        }
+        (0, server_helpers_js_1.json)(res, 200, store.upsertModelProvider({ ...body, id: route.providerId }));
+    });
+    map.set('provider.delete', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, store.deleteModelProvider(route.providerId));
+    });
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRuntimeHandlers = registerRuntimeHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+function registerRuntimeHandlers(map, controller, errorReporter, attachSseClient) {
+    map.set('health', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { name: 'local-ai-core', version: '0.1.0' });
+    });
+    map.set('runtime.status', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await controller.getRuntimeStatus());
+    });
+    map.set('runtime.service.start', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await controller.startService());
+    });
+    map.set('runtime.service.stop', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await controller.stopService());
+    });
+    map.set('runtime.service.restart', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await controller.restartService());
+    });
+    map.set('runtime.logs', async (_route, _req, res, url) => {
+        const limit = Number(url.searchParams.get('limit') || '200');
+        (0, server_helpers_js_1.json)(res, 200, controller.getLogs(limit));
+    });
+    map.set('logs.list', async (_route, _req, res, url) => {
+        const level = url.searchParams.get('level') || 'sys';
+        const limit = Number(url.searchParams.get('limit') || '200');
+        (0, server_helpers_js_1.json)(res, 200, {
+            entries: controller.getLogEntries(level, limit).map((entry) => ({
+                time: entry.ts,
+                level: entry.level,
+                scope: entry.scope,
+                message: entry.message,
+                meta: entry.meta,
+            })),
+        });
+    });
+    map.set('diagnostics.errors', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { errors: await errorReporter.list() });
+    });
+    map.set('runtime.config.read', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await controller.readConfigFile());
+    });
+    map.set('runtime.config.save-raw', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await controller.saveRawConfigFile(String(body.raw || '')));
+    });
+    map.set('runtime.config.save-structured', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await controller.saveStructuredConfigFile((body.config || {})));
+    });
+    map.set('runtime.settings.save', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await controller.saveSettings(body));
+    });
+    map.set('diagnostics.doctor', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await controller.runDiagnosticsDoctor());
+    });
+    map.set('diagnostics.deployment', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await controller.runDeploymentDiagnostics());
+    });
+    map.set('plugins.diagnostics', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await controller.getPluginDiagnostics());
+    });
+    map.set('events.stream', async (_route, _req, res) => {
+        attachSseClient(res);
+    });
+}

package/dist-electron/services/local-ai-core/src/runtime/handlers/runtimes-handler.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRuntimesHandlers = registerRuntimesHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+async function runtimeDetectionResponse(runtimeDetection) {
+    return {
+        runtimes: await runtimeDetection.list(),
+        checking: runtimeDetection.isChecking(),
+    };
+}
+function registerRuntimesHandlers(map, runtimeDetection) {
+    map.set('runtime.agent-runtimes', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await runtimeDetectionResponse(runtimeDetection));
+    });
+    map.set('runtimes.list', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await runtimeDetectionResponse(runtimeDetection));
+    });
+    map.set('runtimes.detail', async (route, _req, res) => {
+        const rId = route.runtimeId;
+        const runtimes = await runtimeDetection.list();
+        const runtime = runtimes.find((entry) => entry.runtimeId === rId || entry.agentType === rId);
+        if (!runtime) {
+            (0, server_helpers_js_1.json)(res, 404, null, false, 'Runtime not found');
+            return;
+        }
+        (0, server_helpers_js_1.json)(res, 200, runtime);
+    });
+    map.set('runtimes.refresh', async (_route, _req, res) => {
+        const runtimes = await runtimeDetection.refresh();
+        (0, server_helpers_js_1.json)(res, 200, { runtimes, checking: runtimeDetection.isChecking() });
+    });
+    map.set('runtimes.refresh-one', async (route, _req, res) => {
+        const rId = route.runtimeId;
+        const runtimes = await runtimeDetection.refresh(rId);
+        (0, server_helpers_js_1.json)(res, 200, { runtimes, checking: runtimeDetection.isChecking(rId) });
+    });
+}

package/dist-electron/services/local-ai-core/src/runtime/handlers/scheduler-handler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSchedulerHandlers = registerSchedulerHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+function registerSchedulerHandlers(map, scheduledJobs) {
+    map.set('scheduler.jobs.list', async (_route, _req, res, url) => {
+        const workspaceId = String(url.searchParams.get('workspace_id') || '');
+        (0, server_helpers_js_1.json)(res, 200, { jobs: await scheduledJobs.listJobs(workspaceId || undefined) });
+    });
+    map.set('scheduler.jobs.create', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await scheduledJobs.createJob(body));
+    });
+    map.set('scheduler.job.get', async (route, _req, res) => {
+        const job = scheduledJobs.getJob(route.jobId);
+        if (!job) {
+            throw new Error(`Scheduled job not found: ${route.jobId}`);
+        }
+        (0, server_helpers_js_1.json)(res, 200, job);
+    });
+    map.set('scheduler.job.runs', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { runs: await scheduledJobs.listJobRuns(route.jobId) });
+    });
+    map.set('scheduler.job.run', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await scheduledJobs.runJobNow(route.jobId));
+    });
+    map.set('scheduler.job.update', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await scheduledJobs.updateJob(route.jobId, body));
+    });
+    map.set('scheduler.job.delete', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await scheduledJobs.deleteJob(route.jobId));
+    });
+}