noteconnection 1.6.8 → 1.8.0

package/dist/src/routes/notemd.js

@@ -0,0 +1,565 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNotemdRoutes = registerNotemdRoutes;
+const CrashLogger_1 = require("../backend/utils/CrashLogger");
+const capabilityManifest_1 = require("../notemd/operations/capabilityManifest");
+const cliContracts_1 = require("../notemd/operations/cliContracts");
+const registry_1 = require("../notemd/operations/registry");
+function registerNotemdRoutes(ctx) {
+    const { notemdService, loadNotemdSettings, persistNotemdSettings } = ctx;
+    const api = (path) => `/api/notemd${path}`;
+    const json = (res, code, data) => {
+        res.writeHead(code, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    const ok = (res, data) => json(res, 200, { success: true, ...data });
+    const fail = (res, error, label) => {
+        console.error(error);
+        CrashLogger_1.CrashLogger.log(error, label);
+        json(res, 500, { success: false, error: String(error) });
+    };
+    const readBody = (req) => new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+    return [
+        {
+            method: 'GET',
+            path: api('/settings'),
+            handler: async (_req, res) => {
+                try {
+                    const settings = await loadNotemdSettings();
+                    ok(res, { settings });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/notemd/settings');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/settings'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const payload = JSON.parse(body);
+                    const nextSettings = payload && typeof payload === 'object' && payload.settings !== undefined
+                        ? payload.settings
+                        : payload;
+                    const settings = persistNotemdSettings
+                        ? await persistNotemdSettings(nextSettings)
+                        : await notemdService.updateSettings(payload);
+                    ok(res, { settings });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/settings');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/test-llm'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.testLlmConnection(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/test-llm');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/process-file'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.processFile(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/process-file');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/process-folder'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.processFolder(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/process-folder');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/generate-content'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.generateContent(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/generate-content');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/translate-file'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.translateFile(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/translate-file');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/fix-mermaid'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const { filePath, inPlace } = JSON.parse(raw);
+                    const result = await notemdService.fixMermaid(filePath, inPlace);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/fix-mermaid');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/fix-formulas'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const { filePath, inPlace } = JSON.parse(raw);
+                    const result = await notemdService.fixFormulas(filePath, inPlace);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/fix-formulas');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/check-duplicates'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const { filePath } = JSON.parse(raw);
+                    const result = await notemdService.checkDuplicates(filePath);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/check-duplicates');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/extract-concepts'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const { filePath } = JSON.parse(raw);
+                    const result = await notemdService.extractConcepts(filePath, settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/extract-concepts');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/cancel'),
+            handler: async (_req, res) => {
+                try {
+                    notemdService.cancelCurrentOperation();
+                    ok(res, { cancelled: true });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/cancel');
+                }
+            },
+        },
+        // ── Diagram generation (obsidian-notemd v1.8.4) ──
+        {
+            method: 'POST',
+            path: api('/generate-diagram'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.generateDiagram(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/generate-diagram');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/preview-diagram'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.previewDiagram(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/preview-diagram');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/export-diagram'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.exportDiagram(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/export-diagram');
+                }
+            },
+        },
+        // ── Web search (obsidian-notemd v1.8.4) ──
+        {
+            method: 'POST',
+            path: api('/search'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.search(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/search');
+                }
+            },
+        },
+        // ── Batch progress query (obsidian-notemd v1.8.4) ──
+        {
+            method: 'GET',
+            path: api('/progress'),
+            handler: async (_req, res) => {
+                try {
+                    const progress = await notemdService.getBatchProgress();
+                    ok(res, { progress });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/notemd/progress');
+                }
+            },
+        },
+        // ── LLM provider diagnostics (obsidian-notemd v1.8.4) ──
+        {
+            method: 'POST',
+            path: api('/diagnose-llm'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const result = await notemdService.diagnoseLlmProvider(JSON.parse(body));
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/diagnose-llm');
+                }
+            },
+        },
+        // ── Extract original text (obsidian-notemd v1.8.4) ──
+        {
+            method: 'POST',
+            path: api('/extract-original-text'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.extractOriginalText(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/extract-original-text');
+                }
+            },
+        },
+        // ── CLI operations registry ──
+        {
+            method: 'GET',
+            path: api('/capability-manifest'),
+            handler: async (_req, res) => {
+                try {
+                    const manifest = (0, capabilityManifest_1.buildCliCapabilityManifest)('notemd');
+                    ok(res, { manifest });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/notemd/capability-manifest');
+                }
+            },
+        },
+        {
+            method: 'GET',
+            path: api('/invocation-contract'),
+            handler: async (_req, res) => {
+                try {
+                    const contract = (0, cliContracts_1.buildCliInvocationContract)();
+                    ok(res, { contract });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/notemd/invocation-contract');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/provider-diagnostic'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.diagnoseLlmProvider(JSON.parse(body), settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/provider-diagnostic');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/one-click-extract'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.oneClickExtract(JSON.parse(body).filePath, settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/one-click-extract');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/batch-fix-mermaid'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const { folderPath, inPlace } = JSON.parse(raw);
+                    const result = await notemdService.batchFixMermaid(folderPath, inPlace ?? true);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/batch-fix-mermaid');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/batch-fix-formulas'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const { folderPath, inPlace } = JSON.parse(raw);
+                    const result = await notemdService.batchFixFormulas(folderPath, inPlace ?? true);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/batch-fix-formulas');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/batch-generate-content'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const { folderPath } = JSON.parse(raw);
+                    const settings = await loadNotemdSettings();
+                    const result = await notemdService.generateFolderContent(folderPath, settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/batch-generate-content');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/batch-progress'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const { operationId } = JSON.parse(raw);
+                    const result = await notemdService.getBatchProgress(operationId);
+                    ok(res, { progress: result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/batch-progress');
+                }
+            },
+        },
+        // ── Workflow pipeline (NoteConnection native) ──
+        {
+            method: 'POST',
+            path: api('/workflow'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const request = JSON.parse(raw);
+                    const result = await notemdService.runWorkflow(request, settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/workflow');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/batch-workflow'),
+            handler: async (req, res) => {
+                try {
+                    const raw = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const request = JSON.parse(raw);
+                    const result = await notemdService.runBatchWorkflow(request, settings);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/batch-workflow');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/provider-profiles/export'),
+            handler: async (req, res) => {
+                try {
+                    const settings = await loadNotemdSettings();
+                    const { buildProviderProfileExport } = await Promise.resolve().then(() => __importStar(require('../notemd/providerProfiles')));
+                    const profile = buildProviderProfileExport(settings.providers);
+                    ok(res, { profile });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/provider-profiles/export');
+                }
+            },
+        },
+        // ── Agent Workspace Bridge (Phase 4 P3) ──
+        {
+            method: 'GET',
+            path: api('/agent-manifest'),
+            handler: async (_req, res) => {
+                try {
+                    const defs = (0, registry_1.listOperationDefinitions)();
+                    const operations = defs.map(def => ({
+                        operationId: def.id,
+                        description: def.commandBindings[0]?.commandId ?? def.id,
+                        automationLevel: def.automationLevel,
+                        requiredContext: def.requiredContext,
+                        sideEffectClass: def.sideEffectClass,
+                        agentAutoExecutable: def.automationLevel === 'safe',
+                        requiredParams: def.inputSchema
+                            ? def.inputSchema.required ?? []
+                            : [],
+                    }));
+                    const manifest = {
+                        version: 1,
+                        generatedAt: new Date().toISOString(),
+                        totalOperations: operations.length,
+                        agentExecutableCount: operations.filter(o => o.agentAutoExecutable).length,
+                        operations,
+                    };
+                    ok(res, { manifest });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/notemd/agent-manifest');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/provider-profiles/import'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const settings = await loadNotemdSettings();
+                    const { parseProviderProfileImport } = await Promise.resolve().then(() => __importStar(require('../notemd/providerProfiles')));
+                    const result = parseProviderProfileImport(body, settings.providers);
+                    ok(res, { result });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/notemd/provider-profiles/import');
+                }
+            },
+        },
+    ];
+}

package/dist/src/routes/registry.contract.test.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Route Registry Contract Tests
+ * Verifies the modular route registration and dispatch infrastructure.
+ */
+const index_1 = require("./index");
+function createMockContext() {
+    const scheduleKnowledgeLearningPlatformWarmup = jest.fn();
+    return {
+        knowledgeLearningPlatform: {
+            getKnowledgeState: async () => ({ documents: 0 })
+        },
+        scheduleKnowledgeLearningPlatformWarmup,
+        knowledgeIngestor: { ingestKnowledge: async () => ({}), averageIngestLatencyMs: () => 0, getDiagnostics: () => ({}) },
+        knowledgeQuerier: { queryKnowledge: async () => ({}), getDiagnosticsSummary: () => ({}) },
+        conversationManager: { getDiagnosticsSummary: () => ({}) },
+        masteryEngine: { getDiagnosticsSummary: () => ({}) },
+        qualityEvaluator: { getDiagnosticsSummary: () => ({}) },
+        tutorRouter: { getDiagnosticsSummary: () => ({}) },
+        memoryPolicyManager: { getDiagnosticsSummary: () => ({}) },
+        notemdService: {},
+        loadNotemdSettings: async () => ({}),
+        LOOPBACK_HOST: '127.0.0.1',
+        finalPort: 3000,
+        KNOWLEDGE_GRAPH_STORE_BACKEND: 'file',
+        KNOWLEDGE_GRAPHDB_ADAPTER_PROVIDER: 'none',
+        KNOWLEDGE_GRAPHDB_ADAPTER_ID: '',
+        KNOWLEDGE_GRAPHDB_FALLBACK_ENABLED: false,
+        KNOWLEDGE_GRAPHDB_OPERATION_MODE: 'read_write',
+        kbRoot: '/tmp/test-kb',
+        runtimeDataDir: '/tmp/test-runtime-data',
+    };
+}
+describe('Route Registry', () => {
+    const ctx = createMockContext();
+    const routes = (0, index_1.registerAllRoutes)(ctx);
+    test('registers all route groups', () => {
+        expect(routes.length).toBeGreaterThanOrEqual(70);
+    });
+    test('every route has required fields', () => {
+        for (const route of routes) {
+            expect(route.method).toMatch(/^(GET|POST|PUT|DELETE)$/);
+            expect(route.path).toBeTruthy();
+            expect(typeof route.handler).toBe('function');
+        }
+    });
+    test('knowledge routes are registered', () => {
+        const knowledgeRoutes = routes.filter(r => r.path.startsWith('/api/knowledge'));
+        expect(knowledgeRoutes.length).toBeGreaterThanOrEqual(30);
+        // Verify key endpoints exist
+        const paths = new Set(knowledgeRoutes.map(r => `${r.method} ${r.path}`));
+        expect(paths.has('GET /api/knowledge/state')).toBe(true);
+        expect(paths.has('GET /api/knowledge/workflow-artifacts')).toBe(true);
+        expect(paths.has('POST /api/knowledge/workflow-artifacts/review-follow-up')).toBe(true);
+        expect(paths.has('POST /api/knowledge/ingest')).toBe(true);
+        expect(paths.has('POST /api/knowledge/query')).toBe(true);
+        expect(paths.has('POST /api/knowledge/export/workspace')).toBe(true);
+        expect(paths.has('POST /api/knowledge/session/graph-focus-diagnostics')).toBe(true);
+        expect(paths.has('POST /api/knowledge/conversation')).toBe(false);
+    });
+    test('notemd routes are registered', () => {
+        const notemdRoutes = routes.filter(r => r.path.startsWith('/api/notemd'));
+        expect(notemdRoutes.length).toBeGreaterThanOrEqual(10);
+        const paths = new Set(notemdRoutes.map(r => `${r.method} ${r.path}`));
+        expect(paths.has('GET /api/notemd/settings')).toBe(true);
+        expect(paths.has('POST /api/notemd/process-file')).toBe(true);
+    });
+    test('render routes are registered', () => {
+        const renderRoutes = routes.filter(r => r.path.startsWith('/api/render') || r.path.startsWith('/api/clipboard'));
+        expect(renderRoutes.length).toBeGreaterThanOrEqual(4);
+    });
+    test('no duplicate method+path combinations', () => {
+        const seen = new Set();
+        for (const route of routes) {
+            const key = `${route.method} ${route.path}`;
+            expect(seen.has(key)).toBe(false);
+            seen.add(key);
+        }
+    });
+    test('all GET routes have idempotent paths', () => {
+        const getRoutes = routes.filter(r => r.method === 'GET');
+        for (const route of getRoutes) {
+            expect(route.path).toMatch(/^\/api\//);
+        }
+    });
+    test('domain diagnostics are exposed via context', () => {
+        // All 7 domain classes are available through ServerContext
+        expect(ctx.knowledgeIngestor).toBeDefined();
+        expect(ctx.knowledgeQuerier).toBeDefined();
+        expect(ctx.conversationManager).toBeDefined();
+        expect(ctx.masteryEngine).toBeDefined();
+        expect(ctx.qualityEvaluator).toBeDefined();
+        expect(ctx.tutorRouter).toBeDefined();
+        expect(ctx.memoryPolicyManager).toBeDefined();
+    });
+    test('domain diagnostics have required methods', () => {
+        expect(typeof ctx.knowledgeIngestor.getDiagnostics).toBe('function');
+        expect(typeof ctx.knowledgeQuerier.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.conversationManager.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.masteryEngine.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.qualityEvaluator.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.tutorRouter.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.memoryPolicyManager.getDiagnosticsSummary).toBe('function');
+    });
+    test('knowledge routes can be dispatched', async () => {
+        const stateRoute = routes.find(r => r.method === 'GET' && r.path === '/api/knowledge/state');
+        expect(stateRoute).toBeDefined();
+        // Mock request/response
+        const mockRes = {
+            _statusCode: 0,
+            _headers: {},
+            _body: '',
+            writeHead(code, headers) {
+                this._statusCode = code;
+                this._headers = headers;
+            },
+            end(data) {
+                this._body = data;
+            },
+            setHeader(_name, _value) { },
+            getHeader(_name) { return ''; },
+        };
+        await stateRoute.handler({ url: '/api/knowledge/state', method: 'GET', headers: {} }, mockRes, ctx);
+        // The handler should produce a JSON response
+        expect(mockRes._statusCode).toBeGreaterThanOrEqual(200);
+        expect(mockRes._statusCode).toBeLessThan(600);
+        expect(ctx.scheduleKnowledgeLearningPlatformWarmup).toHaveBeenCalledWith('knowledge_state_request');
+    });
+});