noteconnection 1.7.0 → 1.9.0

package/dist/src/agent_workspace.contract.parity.test.js

@@ -0,0 +1,159 @@
+"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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const vm = __importStar(require("vm"));
+const KnowledgeLearningPlatform_1 = require("./learning/KnowledgeLearningPlatform");
+const agentWorkspaceCapabilityContracts_1 = require("./learning/agentWorkspaceCapabilityContracts");
+describe('agent workspace capability runtime parity', () => {
+    let diagnostics;
+    let capabilities;
+    let workspace;
+    let fetch;
+    beforeAll(async () => {
+        const window = {};
+        fetch = jest.fn();
+        vm.runInNewContext(fs.readFileSync(path.join(__dirname, 'frontend', 'agent_workspace.js'), 'utf8'), {
+            window, document: { readyState: 'loading', addEventListener() { }, getElementById() { return null; } },
+            console, Set, Map, fetch,
+        });
+        workspace = window.NoteConnectionAgentWorkspace;
+        diagnostics = workspace.getCapabilityRegistryDiagnostics();
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+        await platform.ingestKnowledge({ documents: [{ documentId: 'contract', sourcePath: 'contracts/graph.md', content: '# Graph\n\nGraph theory studies nodes and edges.' }] });
+        const response = await platform.agentConversation({ message: 'Graph theory', persistMemory: false });
+        expect(response.knowledgePoints.length).toBeGreaterThan(0);
+        capabilities = response.knowledgePoints.flatMap(point => point.capabilities);
+        expect(capabilities.length).toBeGreaterThan(0);
+    });
+    test('transport registry covers the exported operation contract', () => {
+        expect(new Set(diagnostics.operationTransports)).toEqual(new Set(agentWorkspaceCapabilityContracts_1.AGENT_WORKSPACE_OPERATION_IDS));
+    });
+    test('request builders cover the exported operation contract', () => {
+        expect(new Set(diagnostics.operationRequestBuilders)).toEqual(new Set(agentWorkspaceCapabilityContracts_1.AGENT_WORKSPACE_OPERATION_IDS));
+    });
+    test('transports and request builders agree at runtime', () => {
+        expect(new Set(diagnostics.operationTransports)).toEqual(new Set(diagnostics.operationRequestBuilders));
+    });
+    test('override operation keys exist in the exported contract', () => {
+        for (const operation of Object.keys(diagnostics.operationResultPresentationOverrideMap))
+            expect(agentWorkspaceCapabilityContracts_1.AGENT_WORKSPACE_OPERATION_IDS).toContain(operation);
+    });
+    test('override presentations exist in the exported contract', () => {
+        for (const presentations of Object.values(diagnostics.operationResultPresentationOverrideMap)) {
+            expect(presentations.length).toBeGreaterThan(0);
+            for (const presentation of presentations)
+                expect(agentWorkspaceCapabilityContracts_1.AGENT_WORKSPACE_RESULT_PRESENTATIONS).toContain(presentation);
+        }
+    });
+    test('every operation has a nonempty unique allowlist containing its default', () => {
+        for (const operation of agentWorkspaceCapabilityContracts_1.AGENT_WORKSPACE_OPERATION_IDS) {
+            const allowed = diagnostics.operationAllowedResultPresentations[operation];
+            expect(allowed).toContain(diagnostics.operationDefaultResultPresentations[operation]);
+            expect(new Set(allowed).size).toBe(allowed.length);
+        }
+    });
+    test('overrides declare only non-default presentations', () => {
+        for (const [operation, presentations] of Object.entries(diagnostics.operationResultPresentationOverrideMap)) {
+            expect(presentations).not.toContain(diagnostics.operationDefaultResultPresentations[operation]);
+        }
+    });
+    test('diagnostics report no invalid or unknown presentation drift', () => {
+        expect(diagnostics.operationResultPresentationOverrideDriftDetected).toBe(false);
+        expect(diagnostics.operationResultPresentationInvalidOverrideTokenCount).toBe(0);
+        expect(diagnostics.operationResultPresentationUnknownOverrideTokenCount).toBe(0);
+    });
+    test('presenters cover the exported presentation contract', () => {
+        expect(new Set(diagnostics.resultPresentations)).toEqual(new Set(agentWorkspaceCapabilityContracts_1.AGENT_WORKSPACE_RESULT_PRESENTATIONS));
+    });
+    test('card presenters and payload builders agree', () => {
+        expect(new Set(diagnostics.cardResultPresentations)).toEqual(new Set(diagnostics.resultPresentationPayloadBuilders));
+    });
+    test('execution handlers cover the exported execution contract', () => {
+        expect(new Set(diagnostics.executionKinds)).toEqual(new Set(agentWorkspaceCapabilityContracts_1.AGENT_WORKSPACE_EXECUTION_KINDS));
+    });
+    test('real conversation capabilities expose stable unique actions and core operations', () => {
+        const oneAtom = capabilities.filter(capability => capability.targetAtomId === capabilities[0].targetAtomId);
+        expect(new Set(oneAtom.map(capability => capability.capabilityId)).size).toBe(oneAtom.length);
+        expect(oneAtom.map(capability => capability.actionId)).toEqual(expect.arrayContaining(['open_focus_mode', 'open_learning_path', 'build_study_session', 'generate_quiz', 'recap']));
+        expect(oneAtom.map(capability => capability.actionId)).not.toContain('analyze_answer');
+    });
+    test('all emitted operations are executable through both frontend registries', () => {
+        for (const capability of capabilities)
+            if (capability.execution.kind === 'knowledge_operation') {
+                expect(diagnostics.operationTransports).toContain(capability.execution.operationId);
+                expect(diagnostics.operationRequestBuilders).toContain(capability.execution.operationId);
+            }
+    });
+    test('every emitted result presentation has a frontend presenter', () => {
+        for (const capability of capabilities)
+            if (capability.execution.kind === 'knowledge_operation')
+                expect(diagnostics.resultPresentations).toContain(capability.execution.resultPresentation);
+    });
+    test('emitted operation presentations respect each operation allowlist', () => {
+        for (const capability of capabilities)
+            if (capability.execution.kind === 'knowledge_operation')
+                expect(diagnostics.operationAllowedResultPresentations[capability.execution.operationId]).toContain(capability.execution.resultPresentation);
+    });
+    test('emitted non-default presentations require an explicit override', () => {
+        for (const capability of capabilities)
+            if (capability.execution.kind === 'knowledge_operation') {
+                const { operationId, resultPresentation } = capability.execution;
+                if (resultPresentation !== diagnostics.operationDefaultResultPresentations[operationId])
+                    expect(diagnostics.operationResultPresentationOverrideMap[operationId]).toContain(resultPresentation);
+            }
+    });
+    test('tutor override is exercised by actual capability emission', () => {
+        expect(capabilities.some(capability => capability.execution.kind === 'knowledge_operation' && capability.execution.resultPresentation === 'tutor_action_card')).toBe(true);
+        // Workflow-history cards are emitted by artifact workflows, not every conversation.
+        expect(diagnostics.operationAllowedResultPresentations.fetch_workflow_artifacts).toEqual(expect.arrayContaining(['knowledge_run_card', 'knowledge_run_history_card']));
+    });
+    test('every emitted capability has a complete executable identity and label', () => {
+        for (const capability of capabilities) {
+            expect(capability.capabilityId).toBeTruthy();
+            expect(capability.actionId).toBeTruthy();
+            expect(capability.targetAtomId).toBeTruthy();
+            expect(capability.label).toBeTruthy();
+            expect(capability.labelKey).toMatch(/^agentWorkspace\.actions\./);
+            expect(diagnostics.executionKinds).toContain(capability.execution.kind);
+        }
+    });
+    test.each([{ execution: { kind: 'unsupported' } }, { actionId: 'open_learning_path' }])('rejects unsupported/missing execution without implicit legacy I/O: %p', async (capability) => {
+        await workspace.executeCapability({}, capability, {});
+        expect(fetch).not.toHaveBeenCalled();
+        expect(diagnostics.legacyActionFallbacks).toEqual([]);
+    });
+});