noteconnection 1.7.0 → 1.9.0

package/dist/src/learning/agentConversationExecution.test.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const agentConversationExecution_1 = require("./agentConversationExecution");
+const agentResponseBudget_1 = require("./agentResponseBudget");
+describe('agent conversation execution limits', () => {
+    const document = {
+        documentId: 'bounded-source',
+        sourcePath: 'bounded/source.md',
+        content: '# Bounded Source\n\nA bounded source explains safe execution and complete evidence. '.repeat(24),
+    };
+    test('client capability hints cannot exceed the declared host tier', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({
+            autoPersist: false,
+            responseBudgetCapability: { memoryClass: 'low', workload: 'normal' },
+        });
+        await platform.ingestKnowledge({ documents: [document] });
+        const response = await platform.agentConversation({
+            message: 'Explain bounded source', responseMode: 'full', persistMemory: false,
+            responseBudgetCapability: { memoryClass: 'high', workload: 'max' },
+        });
+        expect(response.responseBudget?.tier).toBe('standard');
+    });
+    test('declines oversized sources without claiming a complete source scan', async () => {
+        const options = {
+            autoPersist: false,
+            responseExecutionPolicy: { maxSourceBytes: 96, maxTotalSourceBytes: 128 },
+        };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(options);
+        await platform.ingestKnowledge({ documents: [document] });
+        const response = await platform.agentConversation({
+            message: 'Explain bounded source', responseMode: 'full', persistMemory: false,
+        });
+        expect(response.trace.ragContextPack?.sourceDecisions).toEqual(expect.arrayContaining([
+            expect.objectContaining({ status: 'source_window_unavailable', reason: 'runtime_source_bytes_limit' }),
+        ]));
+        expect(response.summary.responseTruncated).toBe(true);
+        expect(response.trace.ragSufficiencyReview?.status).not.toBe('sufficient');
+    });
+    test('expired query work cannot progress to memory or artifact writes', async () => {
+        const backend = {
+            id: 'delayed-query',
+            query: async (context) => {
+                await new Promise(resolve => setTimeout(resolve, 25));
+                return { candidates: context.atoms.map(atom => ({ atomId: atom.id, score: 1 })) };
+            },
+        };
+        const options = { autoPersist: false, graphQueryBackend: backend, responseExecutionPolicy: { timeoutMs: 5 } };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(options);
+        await platform.ingestKnowledge({ documents: [document] });
+        await expect(platform.agentConversation({
+            userId: 'deadline-user', message: 'Explain bounded source', persistMemory: true,
+        })).rejects.toEqual(expect.objectContaining({ code: 'runtime_timeout' }));
+        const memory = await platform.listConversationMemory({ userId: 'deadline-user' });
+        expect(memory.entries).toHaveLength(0);
+        expect((await platform.addConversationMemory({ userId: 'deadline-user', content: 'next operation' })).added).toBe(true);
+    });
+    test('bounds admitted turns before they enter the serialized state queue', async () => {
+        let release;
+        const held = new Promise(resolve => { release = resolve; });
+        const backend = {
+            id: 'held-query',
+            query: async (context) => {
+                await held;
+                return { candidates: context.atoms.map(atom => ({ atomId: atom.id, score: 1 })) };
+            },
+        };
+        const options = { autoPersist: false, graphQueryBackend: backend, responseExecutionPolicy: { maxPendingTurns: 2 } };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(options);
+        await platform.ingestKnowledge({ documents: [document] });
+        const first = platform.agentConversation({ message: 'First', persistMemory: false });
+        const second = platform.agentConversation({ message: 'Second', persistMemory: false });
+        const rejected = platform.agentConversation({ message: 'Third', persistMemory: false }).catch(error => error);
+        await new Promise(resolve => setImmediate(resolve));
+        release();
+        await Promise.all([first, second]);
+        expect((await rejected).code).toBe('runtime_turn_capacity');
+    });
+    test('cancels cooperative query I/O without retrying or writing memory', async () => {
+        const controller = new AbortController();
+        let entered;
+        const started = new Promise(resolve => { entered = resolve; });
+        let queries = 0;
+        const backend = {
+            id: 'cancellable-query',
+            query: async (context) => {
+                queries++;
+                const signal = context.signal;
+                entered();
+                await new Promise((_resolve, reject) => {
+                    if (signal.aborted)
+                        reject(signal.reason);
+                    else
+                        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+                });
+                return { candidates: [] };
+            },
+        };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false, graphQueryBackend: backend });
+        await platform.ingestKnowledge({ documents: [document] });
+        const turn = platform.agentConversation({ userId: 'cancelled-user', message: 'Bounded source' }, controller.signal)
+            .catch(error => error);
+        await started;
+        controller.abort();
+        expect((await turn).code).toBe('runtime_cancelled');
+        expect(queries).toBe(1);
+        expect((await platform.listConversationMemory({ userId: 'cancelled-user' })).entries).toHaveLength(0);
+    });
+    test('rejects dense source structure while preserving direct evidence', async () => {
+        const options = { autoPersist: false, responseExecutionPolicy: { maxSourceLines: 4 } };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(options);
+        await platform.ingestKnowledge({ documents: [document] });
+        const response = await platform.agentConversation({ message: 'Explain bounded source', persistMemory: false });
+        expect(response.trace.ragContextPack?.sourceDecisions.some(item => item.reason === 'runtime_source_lines_limit')).toBe(true);
+        expect(response.trace.ragSufficiencyReview?.status).not.toBe('sufficient');
+        expect(response.citations.length).toBeGreaterThan(0);
+    });
+    test('keeps the default tier conservative when only the host ceiling is configured', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({
+            autoPersist: false,
+            responseBudgetHostCapability: { memoryClass: 'high', workload: 'max' },
+        });
+        await platform.ingestKnowledge({ documents: [document] });
+        const request = { message: 'Explain bounded source', responseMode: 'full', persistMemory: false };
+        expect((await platform.agentConversation(request)).responseBudget?.tier).toBe('standard');
+        expect((await platform.agentConversation({
+            ...request, responseBudgetCapability: { memoryClass: 'high', workload: 'max' },
+        })).responseBudget?.tier).toBe('max');
+    });
+    test('a cancelled queued turn never reaches query or persistence', async () => {
+        let release;
+        let entered;
+        const started = new Promise(resolve => { entered = resolve; });
+        const held = new Promise(resolve => { release = resolve; });
+        const query = jest.fn(async () => { entered(); await held; return { candidates: [] }; });
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false, graphQueryBackend: { id: 'held', query } });
+        const first = platform.agentConversation({ message: 'First', persistMemory: false });
+        await started;
+        const controller = new AbortController();
+        const second = platform.agentConversation({ userId: 'queued', message: 'Second' }, controller.signal).catch(error => error);
+        controller.abort();
+        release();
+        await first;
+        expect((await second).code).toBe('runtime_cancelled');
+        expect(query).toHaveBeenCalledTimes(1);
+        expect((await platform.listConversationMemory({ userId: 'queued' })).entries).toHaveLength(0);
+    });
+});
+describe('bounded source file I/O', () => {
+    let directory;
+    beforeEach(async () => { directory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'source-budget-')); });
+    afterEach(async () => {
+        jest.restoreAllMocks();
+        await promises_1.default.rm(directory, { recursive: true, force: true });
+    });
+    test('counts UTF-8 bytes at the exact file limit and charges cumulative reads', async () => {
+        const filePath = path_1.default.join(directory, 'unicode.md');
+        const source = '知识🧠';
+        const bytes = Buffer.byteLength(source);
+        await promises_1.default.writeFile(filePath, source);
+        await agentConversationExecution_1.AgentConversationExecution.run({
+            budget: (0, agentResponseBudget_1.resolveAgentResponseBudget)(),
+            policy: (0, agentConversationExecution_1.normalizeAgentConversationExecutionPolicy)({ maxSourceBytes: bytes, maxTotalSourceBytes: bytes }),
+        }, async (execution) => {
+            expect(await execution.readSourceFile(filePath)).toBe(source);
+            expect(execution.diagnostics().sourceBytes).toBe(bytes);
+            await expect(execution.readSourceFile(filePath)).rejects.toHaveProperty('code', 'runtime_total_source_bytes_limit');
+        });
+    });
+    test('bounds actual bytes when a source grows after stat and closes the descriptor', async () => {
+        const filePath = path_1.default.join(directory, 'growing.md');
+        await promises_1.default.writeFile(filePath, 'small');
+        const file = await promises_1.default.open(filePath, 'r');
+        const oldStat = await file.stat();
+        await promises_1.default.appendFile(filePath, 'x'.repeat(128 * 1024));
+        jest.spyOn(file, 'stat').mockResolvedValueOnce(oldStat);
+        const close = jest.spyOn(file, 'close');
+        jest.spyOn(promises_1.default, 'open').mockResolvedValueOnce(file);
+        await expect(agentConversationExecution_1.AgentConversationExecution.run({
+            budget: (0, agentResponseBudget_1.resolveAgentResponseBudget)(),
+            policy: (0, agentConversationExecution_1.normalizeAgentConversationExecutionPolicy)({ maxSourceBytes: 16 }),
+        }, execution => execution.readSourceFile(filePath))).rejects.toHaveProperty('code', 'runtime_source_bytes_limit');
+        expect(close).toHaveBeenCalled();
+        await expect(file.stat()).rejects.toHaveProperty('code', 'EBADF');
+    });
+    test('aborts a source stream and closes its descriptor', async () => {
+        const filePath = path_1.default.join(directory, 'cancelled.md');
+        await promises_1.default.writeFile(filePath, Buffer.alloc(256 * 1024, 65));
+        const file = await promises_1.default.open(filePath, 'r');
+        const controller = new AbortController();
+        const createReadStream = file.createReadStream.bind(file);
+        jest.spyOn(file, 'createReadStream').mockImplementation(options => {
+            const stream = createReadStream(options);
+            stream.once('data', () => controller.abort());
+            return stream;
+        });
+        jest.spyOn(promises_1.default, 'open').mockResolvedValueOnce(file);
+        await expect(agentConversationExecution_1.AgentConversationExecution.run({
+            budget: (0, agentResponseBudget_1.resolveAgentResponseBudget)(), policy: (0, agentConversationExecution_1.normalizeAgentConversationExecutionPolicy)(), signal: controller.signal,
+        }, execution => execution.readSourceFile(filePath))).rejects.toHaveProperty('code', 'runtime_cancelled');
+        await expect(file.stat()).rejects.toHaveProperty('code', 'EBADF');
+    });
+});

package/dist/src/learning/agentConversationSerialization.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentConversationSerializationError = void 0;
+exports.measureJsonBytes = measureJsonBytes;
+exports.serializeAgentConversationResponse = serializeAgentConversationResponse;
+exports.serializeAgentConversationHttpResponse = serializeAgentConversationHttpResponse;
+exports.serializeAgentConversationTurnEvent = serializeAgentConversationTurnEvent;
+const mobileAnswerProjection_1 = require("./mobileAnswerProjection");
+const TRUNCATION_REASON = 'runtime_serialized_bytes_limit';
+// Covers a completed event, its validated 160-byte turn ID, timestamp and SSE framing.
+// Every transport reserves the same space to release the same answer.
+const TURN_WIRE_RESERVE_BYTES = 288;
+const DEFAULT_WIRE_LIMIT = 8 * 1024 * 1024;
+const MAX_RELEASE_CITATIONS = 64;
+const MAX_RELEASE_CLAIMS = 128;
+class AgentConversationSerializationError extends Error {
+    constructor() {
+        super(TRUNCATION_REASON);
+        this.code = TRUNCATION_REASON;
+        this.statusCode = 413;
+    }
+}
+exports.AgentConversationSerializationError = AgentConversationSerializationError;
+/** Exact for JSON data; stops before allocating a serialized copy of an oversized response. */
+function measureJsonBytes(value, limit) {
+    let bytes = 0;
+    const ancestors = new Set();
+    const stringBytes = (text) => {
+        bytes += 2;
+        for (let i = 0; i < text.length && bytes <= limit; i++) {
+            const code = text.charCodeAt(i);
+            if (code === 34 || code === 92 || code === 8 || code === 9 || code === 10 || code === 12 || code === 13)
+                bytes += 2;
+            else if (code < 32)
+                bytes += 6;
+            else if (code < 128)
+                bytes++;
+            else if (code < 2048)
+                bytes += 2;
+            else if (code >= 0xd800 && code <= 0xdbff) {
+                const next = text.charCodeAt(i + 1);
+                if (next >= 0xdc00 && next <= 0xdfff) {
+                    bytes += 4;
+                    i++;
+                }
+                else
+                    bytes += 6;
+            }
+            else if (code >= 0xdc00 && code <= 0xdfff)
+                bytes += 6;
+            else
+                bytes += 3;
+        }
+    };
+    const visit = (item, depth) => {
+        if (bytes > limit)
+            return;
+        if (item === null || item === undefined || typeof item === 'function' || typeof item === 'symbol') {
+            bytes += 4;
+            return;
+        }
+        if (typeof item === 'string') {
+            stringBytes(item);
+            return;
+        }
+        if (typeof item === 'boolean') {
+            bytes += item ? 4 : 5;
+            return;
+        }
+        if (typeof item === 'number') {
+            bytes += Number.isFinite(item) ? String(item).length : 4;
+            return;
+        }
+        if (typeof item !== 'object')
+            throw new TypeError('Conversation responses must contain JSON data');
+        if (ancestors.has(item) || depth > 64)
+            throw new TypeError('Cyclic or excessively nested conversation response');
+        if (typeof item.toJSON === 'function')
+            throw new TypeError('Conversation responses must contain plain JSON data');
+        ancestors.add(item);
+        bytes += 2;
+        if (Array.isArray(item)) {
+            for (let i = 0; i < item.length && bytes <= limit; i++) {
+                if (i)
+                    bytes++;
+                visit(item[i], depth + 1);
+            }
+        }
+        else {
+            let first = true;
+            for (const key in item) {
+                if (bytes > limit)
+                    break;
+                if (!Object.prototype.hasOwnProperty.call(item, key))
+                    continue;
+                const child = item[key];
+                if (child === undefined || typeof child === 'function' || typeof child === 'symbol')
+                    continue;
+                if (!first)
+                    bytes++;
+                first = false;
+                stringBytes(key);
+                bytes++;
+                visit(child, depth + 1);
+            }
+        }
+        ancestors.delete(item);
+    };
+    visit(value, 0);
+    return bytes;
+}
+function wireLimit(result) {
+    const requested = Number(result.responseBudget?.runtimeGovernor.maxSerializedBytes);
+    return Number.isFinite(requested) && requested > 0 ? Math.floor(requested) : DEFAULT_WIRE_LIMIT;
+}
+function countUnescaped(value, token) {
+    const escapedToken = token.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return (value.match(new RegExp(`(?<!\\\\)${escapedToken}`, 'gu')) || []).length;
+}
+function clipBalancedMarkdown(source, maxChars) {
+    if (source.length <= maxChars)
+        return source;
+    const marker = '\n\n[Response truncated by runtime safety governor.]';
+    if (maxChars < marker.length)
+        return '';
+    let clipped = source.slice(0, maxChars - marker.length).trimEnd();
+    // Keep whole claims when possible, and never leave an unterminated code/math block.
+    const boundary = Math.max(clipped.lastIndexOf('\n\n'), clipped.lastIndexOf('. '), clipped.lastIndexOf('。'));
+    if (boundary >= clipped.length / 2)
+        clipped = clipped.slice(0, boundary + (clipped[boundary] === '\n' ? 0 : 1)).trimEnd();
+    const fences = [...clipped.matchAll(/^\s*(`{3,}|~{3,}).*$/gm)];
+    let openFence;
+    for (const fence of fences) {
+        if (!openFence)
+            openFence = { marker: fence[1], index: fence.index };
+        else if (fence[1][0] === openFence.marker[0] && fence[1].length >= openFence.marker.length)
+            openFence = undefined;
+    }
+    if (openFence)
+        clipped = clipped.slice(0, openFence.index).trimEnd();
+    if (countUnescaped(clipped, '$$') % 2)
+        clipped = clipped.slice(0, clipped.lastIndexOf('$$')).trimEnd();
+    if (countUnescaped(clipped.replace(/(?<!\\)\$\$/gu, ''), '$') % 2)
+        clipped = clipped.slice(0, clipped.lastIndexOf('$')).trimEnd();
+    if (countUnescaped(clipped.replace(/^\s*`{3,}.*$/gm, ''), '`') % 2)
+        clipped = clipped.slice(0, clipped.lastIndexOf('`')).trimEnd();
+    if (clipped.lastIndexOf('[') > clipped.lastIndexOf(']'))
+        clipped = clipped.slice(0, clipped.lastIndexOf('[')).trimEnd();
+    if (/[\ud800-\udbff]$/.test(clipped))
+        clipped = clipped.slice(0, -1);
+    return `${clipped}${marker}`.trim();
+}
+function compactResponse(result, answerMaxChars) {
+    const sourceCitations = result.citations || [];
+    const sourceClaims = result.trace?.answerClaimCitations || [];
+    let answer = clipBalancedMarkdown(result.answer || '', answerMaxChars);
+    // Oversized metadata must not leave a retained claim with a dangling citation.
+    const boundedEvidence = sourceCitations.length <= MAX_RELEASE_CITATIONS && sourceClaims.length <= MAX_RELEASE_CLAIMS;
+    const citations = boundedEvidence ? sourceCitations.map(citation => ({
+        citationId: citation.citationId, atomId: citation.atomId, documentId: citation.documentId,
+        sourcePath: citation.sourcePath, title: citation.title,
+        snippet: citation.snippet.length > 1024 ? `${citation.snippet.slice(0, 1021)}...` : citation.snippet,
+        startOffset: citation.startOffset, endOffset: citation.endOffset, startLine: citation.startLine, endLine: citation.endLine,
+        score: citation.score,
+    })) : [];
+    const citationIds = new Set(citations.map(citation => citation.citationId));
+    const claims = boundedEvidence ? sourceClaims.filter(claim => answer.includes(claim.text)) : [];
+    const claimsSupported = claims.every(claim => claim.citationIds.length <= MAX_RELEASE_CITATIONS
+        && claim.citationIds.every(id => citationIds.has(id)));
+    if (!boundedEvidence || !claimsSupported) {
+        answer = clipBalancedMarkdown('[Response truncated by runtime safety governor. Narrow the request to retain its evidence.]', answerMaxChars);
+        citations.length = 0;
+        claims.length = 0;
+    }
+    const compact = {
+        userId: result.userId,
+        sessionId: result.sessionId,
+        assistantMessage: answer,
+        answer,
+        responseMode: result.responseMode,
+        ...(result.responseProfile ? { responseProfile: result.responseProfile } : {}),
+        ...(result.responseBudget ? { responseBudget: result.responseBudget } : {}),
+        assistantBlocks: [], knowledgePoints: [], citations, recalledMemories: [], memoryActions: [],
+        summary: {
+            generatedAt: result.summary.generatedAt,
+            topK: result.summary.topK,
+            returnedKnowledgePoints: 0,
+            returnedCitations: citations.length,
+            recalledMemoryCount: 0,
+            appliedMemoryCount: 0,
+            queryEvidenceCoverageRatioPct: citations.length ? result.summary.queryEvidenceCoverageRatioPct : 0,
+            responseTruncated: true,
+            responseTruncationReason: TRUNCATION_REASON,
+        },
+        trace: {
+            sessionId: result.sessionId,
+            invocationId: result.trace?.invocationId || '',
+            retrieval: {},
+            recalledMemoryCount: 0,
+            appliedMemoryCount: 0,
+            usedScope: {
+                source: result.trace?.usedScope?.source || 'global',
+                workspaceId: result.trace?.usedScope?.workspaceId || null,
+                corpusId: result.trace?.usedScope?.corpusId || null,
+                documentIds: [], atomIds: [], sourcePathPrefixes: [], languages: [],
+                matchedAtomCount: result.trace?.usedScope?.matchedAtomCount || 0,
+            },
+            ...(claims.length ? { answerClaimCitations: claims } : {}),
+            responseTruncated: true,
+            responseTruncationReason: TRUNCATION_REASON,
+        },
+    };
+    if (result.responseProfile === 'mobile_compact')
+        compact.mobileProjection = (0, mobileAnswerProjection_1.projectAnswerForMobile)(compact);
+    return compact;
+}
+function releaseWithinBudget(result, maxBytes) {
+    if (measureJsonBytes(result, maxBytes) <= maxBytes) {
+        const truncated = result.summary.responseTruncationReason === TRUNCATION_REASON;
+        return { json: JSON.stringify(result), result, truncated, ...(truncated ? { reason: TRUNCATION_REASON } : {}) };
+    }
+    let lower = 0;
+    let upper = Math.min(32000, result.answer.length, result.responseBudget?.runtimeGovernor.maxReportChars || 32000);
+    let best = compactResponse(result, 0);
+    if (measureJsonBytes(best, maxBytes) > maxBytes) {
+        // If citations cannot fit, release no scientific claims and no obsolete coverage.
+        best = compactResponse({ ...result, citations: [], answer: '', trace: { ...result.trace, answerClaimCitations: [] } }, 0);
+        delete best.responseBudget;
+        if (measureJsonBytes(best, maxBytes) > maxBytes)
+            throw new AgentConversationSerializationError();
+        return { json: JSON.stringify(best), result: best, truncated: true, reason: TRUNCATION_REASON };
+    }
+    while (lower <= upper) {
+        const chars = Math.floor((lower + upper) / 2);
+        const candidate = compactResponse(result, chars);
+        if (measureJsonBytes(candidate, maxBytes) <= maxBytes) {
+            best = candidate;
+            lower = chars + 1;
+        }
+        else
+            upper = chars - 1;
+    }
+    return { json: JSON.stringify(best), result: best, truncated: true, reason: TRUNCATION_REASON };
+}
+function serializeAgentConversationResponse(result) {
+    return releaseWithinBudget(result, wireLimit(result) - TURN_WIRE_RESERVE_BYTES);
+}
+function serializeAgentConversationHttpResponse(result) {
+    const serialized = serializeAgentConversationResponse(result);
+    return { ...serialized, json: `{"success":true,"result":${serialized.json}}` };
+}
+function serializeAgentConversationTurnEvent(eventType, payload) {
+    if (eventType === 'turn_completed' && payload && typeof payload === 'object' && 'result' in payload && payload.result) {
+        const event = payload;
+        const limit = wireLimit(event.result);
+        const envelope = { ...event, result: null };
+        const framingBytes = Buffer.byteLength(`event: ${eventType}\ndata: \n\n`);
+        const envelopeBytes = measureJsonBytes(envelope, limit) - 4 + framingBytes;
+        const serialized = releaseWithinBudget(event.result, limit - Math.max(TURN_WIRE_RESERVE_BYTES, envelopeBytes));
+        return { json: JSON.stringify({ ...event, result: serialized.result }), truncated: serialized.truncated };
+    }
+    const payloadLimit = DEFAULT_WIRE_LIMIT - Buffer.byteLength(`event: ${eventType}\ndata: \n\n`);
+    if (measureJsonBytes(payload, payloadLimit) > payloadLimit)
+        throw new AgentConversationSerializationError();
+    return { json: JSON.stringify(payload), truncated: false };
+}

package/dist/src/learning/agentConversationSerialization.test.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const agentConversationSerialization_1 = require("./agentConversationSerialization");
+function makeResponse(overrides = {}) {
+    const answer = overrides.answer || 'A bounded answer.';
+    return {
+        userId: 'serialization-user',
+        sessionId: 'serialization-session',
+        assistantMessage: answer,
+        answer,
+        responseMode: 'full',
+        responseBudget: {
+            mode: 'unbounded',
+            tier: 'unbounded',
+            productCapDisabled: true,
+            rag: {
+                maxFragments: 4096,
+                maxCharsPerFragment: 16000,
+                maxTotalChars: 320000,
+                productCapDisabled: true,
+                runtimeMaxFragments: 4096,
+                runtimeMaxCharsPerFragment: 16000,
+                runtimeMaxTotalChars: 64 * 1024 * 1024,
+            },
+            runtimeGovernor: {
+                timeoutMs: 180000,
+                maxSerializedBytes: 1200,
+                maxFragmentsProcessed: 4096,
+                maxReportChars: 320000,
+            },
+        },
+        knowledgePoints: [],
+        citations: [],
+        recalledMemories: [],
+        memoryActions: [],
+        summary: {
+            generatedAt: '2026-09-03T00:00:00.000Z',
+            topK: 6,
+            returnedKnowledgePoints: 0,
+            returnedCitations: 0,
+            recalledMemoryCount: 0,
+            appliedMemoryCount: 0,
+            queryEvidenceCoverageRatioPct: 100,
+        },
+        trace: {
+            sessionId: 'serialization-session',
+            invocationId: 'serialization-invocation',
+            retrieval: {},
+            recalledMemoryCount: 0,
+            appliedMemoryCount: 0,
+            usedScope: {
+                source: 'global',
+                workspaceId: null,
+                corpusId: null,
+                documentIds: [],
+                atomIds: [],
+                sourcePathPrefixes: [],
+                languages: [],
+                matchedAtomCount: 0,
+            },
+            responseBudget: undefined,
+        },
+        ...overrides,
+    };
+}
+describe('agent conversation serialization governor', () => {
+    test.each(['知识🧠', 'quotes " \\ \n\t', '\ud800', '\u0000', { nested: [null, undefined, 1, false] }])('measures JSON escaping and UTF-8 before allocation: %p', value => {
+        const bytes = Buffer.byteLength(JSON.stringify(value));
+        expect((0, agentConversationSerialization_1.measureJsonBytes)(value, bytes)).toBe(bytes);
+        expect((0, agentConversationSerialization_1.measureJsonBytes)(value, bytes - 1)).toBeGreaterThan(bytes - 1);
+    });
+    test('the response fits but the full SSE envelope does not', () => {
+        const response = makeResponse();
+        response.responseBudget.runtimeGovernor.maxSerializedBytes = 2000;
+        response.answer += 'x'.repeat(Math.max(0, 1998 - Buffer.byteLength(JSON.stringify(response))));
+        expect(Buffer.byteLength(JSON.stringify(response))).toBe(1998);
+        const event = (0, agentConversationSerialization_1.serializeAgentConversationTurnEvent)('turn_completed', {
+            type: 'turn_completed', turnId: 'turn_envelope', emittedAt: '2026-09-12T00:00:00.000Z', result: response,
+        });
+        expect(Buffer.byteLength(`event: turn_completed\ndata: ${event.json}\n\n`)).toBeLessThanOrEqual(2000);
+        expect(event.truncated).toBe(true);
+        expect(JSON.parse(event.json).result.summary.responseTruncated).toBe(true);
+    });
+    test('one released projection is reused for JSON, SSE and replay with surviving citations', () => {
+        const response = makeResponse({ answer: 'A supported claim. '.repeat(800), assistantMessage: 'A supported claim. '.repeat(800) });
+        response.responseBudget.runtimeGovernor.maxSerializedBytes = 4000;
+        response.citations = [{ citationId: 'cite-1', atomId: 'atom-1', documentId: 'doc-1', sourcePath: 'source.md', title: 'Source', snippet: 'A supported claim.', score: 1 }];
+        response.summary.returnedCitations = 99;
+        response.trace.answerClaimCitations = [{ claimId: 'claim-1', text: 'A supported claim.', citationIds: ['cite-1'], fragmentIds: ['fragment-1'], sourcePaths: ['source.md'], supportStatus: 'supported' }];
+        const http = (0, agentConversationSerialization_1.serializeAgentConversationHttpResponse)(response);
+        const event = { type: 'turn_completed', turnId: 'turn_citations', emittedAt: '2026-09-12T00:00:00.000Z', result: response };
+        const live = (0, agentConversationSerialization_1.serializeAgentConversationTurnEvent)('turn_completed', event);
+        const replay = (0, agentConversationSerialization_1.serializeAgentConversationTurnEvent)('turn_completed', { ...event, result: http.result });
+        expect(JSON.parse(live.json).result).toEqual(http.result);
+        expect(JSON.parse(replay.json).result).toEqual(http.result);
+        expect(http.result.answer).toContain('A supported claim.');
+        expect(http.result.citations.map(citation => citation.citationId)).toEqual(['cite-1']);
+        expect(http.result.summary.returnedCitations).toBe(http.result.citations.length);
+        expect(http.result.summary.returnedKnowledgePoints).toBe(http.result.knowledgePoints.length);
+    });
+    test('does not initially stringify oversized diagnostic collections', () => {
+        const response = makeResponse();
+        response.trace.retrieval = { hugeDiagnostics: Array.from({ length: 10000 }, () => 'diagnostic'.repeat(50)) };
+        const stringify = jest.spyOn(JSON, 'stringify');
+        try {
+            const serialized = (0, agentConversationSerialization_1.serializeAgentConversationResponse)(response);
+            expect(stringify).not.toHaveBeenCalledWith(response);
+            expect(Buffer.byteLength(serialized.json)).toBeLessThanOrEqual(1200);
+            expect(serialized.result.summary.queryEvidenceCoverageRatioPct).toBe(0);
+        }
+        finally {
+            stringify.mockRestore();
+        }
+    });
+    test('rejects a ceiling too small for the required response contract', () => {
+        const response = makeResponse();
+        response.responseBudget.runtimeGovernor.maxSerializedBytes = 64;
+        expect(() => (0, agentConversationSerialization_1.serializeAgentConversationHttpResponse)(response)).toThrow('runtime_serialized_bytes_limit');
+    });
+    test('keeps responses unchanged while under the runtime byte limit', () => {
+        const response = makeResponse({
+            responseBudget: {
+                ...makeResponse().responseBudget,
+                runtimeGovernor: {
+                    ...makeResponse().responseBudget.runtimeGovernor,
+                    maxSerializedBytes: 100000,
+                },
+            },
+        });
+        const serialized = (0, agentConversationSerialization_1.serializeAgentConversationResponse)(response);
+        expect(serialized.truncated).toBe(false);
+        expect(JSON.parse(serialized.json).answer).toBe(response.answer);
+    });
+    test('compacts oversized unbounded responses and preserves balanced display math', () => {
+        const response = makeResponse({
+            answer: `## Report\n\n${'Long evidence. '.repeat(2000)}\n\n$$\\frac{a}{b}$$`,
+            assistantMessage: `## Report\n\n${'Long evidence. '.repeat(2000)}\n\n$$\\frac{a}{b}$$`,
+        });
+        const serialized = (0, agentConversationSerialization_1.serializeAgentConversationResponse)(response);
+        expect(serialized.truncated).toBe(true);
+        expect(Buffer.byteLength(serialized.json, 'utf8')).toBeLessThanOrEqual(1200);
+        expect(serialized.result.summary.responseTruncated).toBe(true);
+        expect(serialized.result.summary.responseTruncationReason).toBe('runtime_serialized_bytes_limit');
+        expect((serialized.result.answer.match(/(?<!\\)\$\$/gu) || []).length % 2).toBe(0);
+    });
+    test('applies the same governor to a completed SSE event', () => {
+        const response = makeResponse({ answer: 'Event payload '.repeat(2000) });
+        const serialized = (0, agentConversationSerialization_1.serializeAgentConversationTurnEvent)('turn_completed', {
+            type: 'turn_completed',
+            turnId: 'turn_serialization',
+            emittedAt: '2026-09-03T00:00:00.000Z',
+            result: response,
+        });
+        const event = JSON.parse(serialized.json);
+        expect(serialized.truncated).toBe(true);
+        expect(event.result.summary.responseTruncated).toBe(true);
+    });
+    test('serializes the HTTP success envelope within the runtime limit', () => {
+        const response = makeResponse({ answer: 'HTTP payload '.repeat(2000) });
+        const serialized = (0, agentConversationSerialization_1.serializeAgentConversationHttpResponse)(response);
+        expect(serialized.truncated).toBe(true);
+        expect(Buffer.byteLength(serialized.json, 'utf8')).toBeLessThanOrEqual(1200);
+        expect(JSON.parse(serialized.json).success).toBe(true);
+    });
+});