noteconnection 1.8.0 → 1.9.0

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);
+    });
+});

package/dist/src/learning/agentResponseBudget.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_RESPONSE_UNBOUNDED_RUNTIME_GOVERNOR = exports.AGENT_RESPONSE_BUDGET_TIERS = void 0;
+exports.resolveAgentResponseBudget = resolveAgentResponseBudget;
+exports.applyRuntimeGovernor = applyRuntimeGovernor;
+exports.resolveHostedAgentResponseBudget = resolveHostedAgentResponseBudget;
+const STANDARD_RUNTIME_GOVERNOR = Object.freeze({
+    timeoutMs: 60000,
+    maxSerializedBytes: 8 * 1024 * 1024,
+    maxFragmentsProcessed: 512,
+    maxReportChars: 48000,
+});
+const EXTENDED_RUNTIME_GOVERNOR = Object.freeze({
+    timeoutMs: 90000,
+    maxSerializedBytes: 16 * 1024 * 1024,
+    maxFragmentsProcessed: 1024,
+    maxReportChars: 80000,
+});
+const MAX_RUNTIME_GOVERNOR = Object.freeze({
+    timeoutMs: 120000,
+    maxSerializedBytes: 32 * 1024 * 1024,
+    maxFragmentsProcessed: 2048,
+    maxReportChars: 160000,
+});
+const UNBOUNDED_RUNTIME_GOVERNOR = Object.freeze({
+    timeoutMs: 180000,
+    maxSerializedBytes: 64 * 1024 * 1024,
+    maxFragmentsProcessed: 4096,
+    maxReportChars: 320000,
+});
+function createProductBudgetDefinition(maxFragments, maxCharsPerFragment, maxTotalChars, reportMaxChars, runtimeGovernor) {
+    return Object.freeze({
+        rag: Object.freeze({
+            maxFragments,
+            maxCharsPerFragment,
+            maxTotalChars,
+            productCapDisabled: false,
+            runtimeMaxFragments: runtimeGovernor.maxFragmentsProcessed,
+            runtimeMaxCharsPerFragment: maxCharsPerFragment,
+            runtimeMaxTotalChars: reportMaxChars,
+        }),
+        reportMaxChars,
+        runtimeGovernor,
+    });
+}
+exports.AGENT_RESPONSE_BUDGET_TIERS = Object.freeze({
+    standard: createProductBudgetDefinition(120, 8000, 64000, 48000, STANDARD_RUNTIME_GOVERNOR),
+    extended: createProductBudgetDefinition(160, 12000, 128000, 80000, EXTENDED_RUNTIME_GOVERNOR),
+    max: createProductBudgetDefinition(256, 16000, 256000, 160000, MAX_RUNTIME_GOVERNOR),
+});
+exports.AGENT_RESPONSE_UNBOUNDED_RUNTIME_GOVERNOR = UNBOUNDED_RUNTIME_GOVERNOR;
+function normalizedMemoryClass(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return normalized === 'low' || normalized === 'standard' || normalized === 'high'
+        ? normalized
+        : undefined;
+}
+function normalizedWorkload(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return normalized === 'normal' || normalized === 'large' || normalized === 'max'
+        ? normalized
+        : undefined;
+}
+function normalizedCapability(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    const record = value;
+    const capability = {};
+    const memoryClass = normalizedMemoryClass(record.memoryClass ?? record.memory_class);
+    const workload = normalizedWorkload(record.workload ?? record.workload_class);
+    if (memoryClass) {
+        capability.memoryClass = memoryClass;
+    }
+    if (workload) {
+        capability.workload = workload;
+    }
+    return capability;
+}
+function resolveAdaptiveTier(capability) {
+    if (capability.memoryClass === 'low') {
+        return 'standard';
+    }
+    if (capability.memoryClass === 'high' && capability.workload === 'max') {
+        return 'max';
+    }
+    if (capability.workload === 'max' || (capability.memoryClass === 'high' && capability.workload === 'large')) {
+        return 'extended';
+    }
+    return 'standard';
+}
+function cloneRuntimeGovernor(governor) {
+    return {
+        timeoutMs: governor.timeoutMs,
+        maxSerializedBytes: governor.maxSerializedBytes,
+        maxFragmentsProcessed: governor.maxFragmentsProcessed,
+        maxReportChars: governor.maxReportChars,
+    };
+}
+function cloneRagBudget(rag, productCapDisabled = false) {
+    const cloned = {
+        maxFragments: rag.maxFragments,
+        maxCharsPerFragment: rag.maxCharsPerFragment,
+        maxTotalChars: rag.maxTotalChars,
+    };
+    if (productCapDisabled) {
+        cloned.productCapDisabled = true;
+        cloned.runtimeMaxFragments = rag.runtimeMaxFragments;
+        cloned.runtimeMaxCharsPerFragment = rag.runtimeMaxCharsPerFragment;
+        cloned.runtimeMaxTotalChars = rag.runtimeMaxTotalChars;
+    }
+    return cloned;
+}
+function resolveAgentResponseBudget(input = {}) {
+    const responseMode = input.responseMode === 'full' ? 'full' : 'slim';
+    const mobile = input.mobile === true;
+    const requestedMode = input.responseBudgetMode === 'unbounded'
+        ? 'unbounded'
+        : 'adaptive';
+    if (responseMode !== 'full' || mobile) {
+        const standard = exports.AGENT_RESPONSE_BUDGET_TIERS.standard;
+        return {
+            mode: 'adaptive',
+            tier: 'standard',
+            productCapDisabled: false,
+            rag: cloneRagBudget(standard.rag),
+            reportMaxChars: standard.reportMaxChars,
+            runtimeGovernor: cloneRuntimeGovernor(standard.runtimeGovernor),
+        };
+    }
+    if (requestedMode === 'unbounded') {
+        return {
+            mode: 'unbounded',
+            tier: 'unbounded',
+            productCapDisabled: true,
+            rag: cloneRagBudget({
+                maxFragments: UNBOUNDED_RUNTIME_GOVERNOR.maxFragmentsProcessed,
+                maxCharsPerFragment: exports.AGENT_RESPONSE_BUDGET_TIERS.max.rag.maxCharsPerFragment,
+                maxTotalChars: exports.AGENT_RESPONSE_UNBOUNDED_RUNTIME_GOVERNOR.maxReportChars,
+                runtimeMaxFragments: UNBOUNDED_RUNTIME_GOVERNOR.maxFragmentsProcessed,
+                runtimeMaxCharsPerFragment: exports.AGENT_RESPONSE_BUDGET_TIERS.max.rag.maxCharsPerFragment,
+                runtimeMaxTotalChars: UNBOUNDED_RUNTIME_GOVERNOR.maxReportChars,
+            }, true),
+            runtimeGovernor: cloneRuntimeGovernor(UNBOUNDED_RUNTIME_GOVERNOR),
+        };
+    }
+    const tier = resolveAdaptiveTier(normalizedCapability(input.capability));
+    const definition = exports.AGENT_RESPONSE_BUDGET_TIERS[tier];
+    return {
+        mode: 'adaptive',
+        tier,
+        productCapDisabled: false,
+        rag: cloneRagBudget(definition.rag),
+        reportMaxChars: definition.reportMaxChars,
+        runtimeGovernor: cloneRuntimeGovernor(definition.runtimeGovernor),
+    };
+}
+function applyRuntimeGovernor(input) {
+    const governor = input.budget.runtimeGovernor;
+    if (Number(input.nowMs) - Number(input.startedAtMs) > governor.timeoutMs) {
+        return { allowed: false, truncated: true, reason: 'runtime_timeout' };
+    }
+    if (Number(input.processedFragments) > governor.maxFragmentsProcessed) {
+        return { allowed: false, truncated: true, reason: 'runtime_fragment_limit' };
+    }
+    if (Number(input.serializedBytes) > governor.maxSerializedBytes) {
+        return { allowed: false, truncated: true, reason: 'runtime_serialized_bytes_limit' };
+    }
+    if (Number(input.reportChars) > governor.maxReportChars) {
+        return { allowed: false, truncated: true, reason: 'runtime_report_chars_limit' };
+    }
+    return { allowed: true, truncated: false };
+}
+function resolveHostedAgentResponseBudget(input, hostCapability) {
+    const requested = resolveAgentResponseBudget(input);
+    const ceiling = resolveAgentResponseBudget({ ...input, capability: hostCapability });
+    const rank = { standard: 0, extended: 1, max: 2, unbounded: 3 };
+    return rank[requested.tier] <= rank[ceiling.tier] ? requested : ceiling;
+}