@myagentroam/node 0.10.20 → 0.10.22

package/dist/service/prompt-completion-cache.js

@@ -0,0 +1,368 @@
+import { createHash, randomUUID } from 'node:crypto';
+const EMPTY_REFERENCES = Object.freeze({ epoch: 'empty', messages: [] });
+const MAX_SCOPES = 32;
+const MAX_SESSIONS = 16;
+const MAX_WORKSPACE_BYTES = 2 * 1024 * 1024;
+const MAX_BYTES = 32 * 1024 * 1024;
+const MAX_REFERENCE_SESSIONS = 4;
+export const PROMPT_COMPLETION_REFERENCE_POOL_SESSIONS = MAX_REFERENCE_SESSIONS + 1;
+const MAX_REFERENCE_MESSAGES = 20;
+const MAX_REFERENCE_BYTES = 8_192;
+const MAX_REFERENCE_TEXT_BYTES = 1_024;
+/** Node-only material cache. Drafts, generated suggestions and credentials never enter it. */
+export class PromptCompletionCache {
+    scopes = new Map();
+    now;
+    refreshMs;
+    hardTtlMs;
+    disposed = false;
+    reads = 0;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.refreshMs = options.refreshMs ?? 5 * 60_000;
+        this.hardTtlMs = options.hardTtlMs ?? 15 * 60_000;
+    }
+    async references(scope, sessionId, lease, load) {
+        if (this.disposed || !this.authorized(lease))
+            return EMPTY_REFERENCES;
+        const entry = this.entry(scope);
+        entry.lease = lease;
+        entry.load = load;
+        const latest = entry.snapshots.at(-1);
+        if (!latest || this.now() - latest.verifiedAt >= this.refreshMs)
+            await this.build(entry);
+        if (!this.retained(entry) || !this.authorized(lease))
+            return EMPTY_REFERENCES;
+        const pin = sessionId === null ? undefined : entry.pins.get(sessionId);
+        const pinned = pin && this.now() - pin.pinnedAt < this.hardTtlMs
+            ? entry.snapshots.find((value) => value.epoch === pin.epoch)
+            : undefined;
+        const snapshot = pinned && this.now() - pinned.verifiedAt < this.hardTtlMs ? pinned : entry.snapshots.at(-1);
+        if (!snapshot || this.now() - snapshot.verifiedAt >= this.hardTtlMs)
+            return EMPTY_REFERENCES;
+        if (sessionId !== null && snapshot !== pinned) {
+            entry.pins.delete(sessionId);
+            entry.pins.set(sessionId, { epoch: snapshot.epoch, pinnedAt: this.now() });
+            trimMap(entry.pins, MAX_SESSIONS);
+        }
+        return {
+            epoch: snapshot.epoch,
+            messages: selectReferences(snapshot.messages, sessionId)
+        };
+    }
+    /** The caller supplies an authoritative bounded window, not an unverified delta. */
+    session(scope, sessionId, generation, messages) {
+        if (this.disposed)
+            return [];
+        const entry = this.entry(scope);
+        const previous = entry.sessions.get(sessionId);
+        const start = previous?.generation === generation && previous.messages[0]
+            ? messages.findIndex((value) => value.id === previous.messages[0].id)
+            : -1;
+        const bounded = boundMessages(start >= 0 ? messages.slice(start) : messages);
+        const unchangedPrefix = previous?.generation === generation &&
+            previous.messages.length <= bounded.length &&
+            previous.messages.every((old, index) => {
+                const next = bounded[index];
+                return (next?.id === old.id &&
+                    next.revision === old.revision &&
+                    next.role === old.role &&
+                    next.text === old.text);
+            });
+        const result = unchangedPrefix
+            ? [...previous.messages, ...bounded.slice(previous.messages.length)]
+            : bounded;
+        if (!unchangedPrefix)
+            entry.pins.delete(sessionId);
+        entry.sessions.delete(sessionId);
+        entry.lastUsed = this.now();
+        entry.sessions.set(sessionId, { generation, messages: result, refreshedAt: this.now() });
+        trimMap(entry.sessions, MAX_SESSIONS);
+        this.enforceLimits();
+        return result;
+    }
+    /** Maintenance only reclaims idle material; history reads require a manual request. */
+    sweep() {
+        for (const entry of this.scopes.values()) {
+            if (this.now() - entry.lastUsed >= this.hardTtlMs) {
+                this.evict(entry);
+                continue;
+            }
+            for (const [id, window] of entry.sessions)
+                if (this.now() - window.refreshedAt >= this.hardTtlMs) {
+                    entry.sessions.delete(id);
+                    entry.pins.delete(id);
+                }
+            if (!entry.lease || !this.authorized(entry.lease)) {
+                entry.build?.controller.abort();
+                delete entry.load;
+                delete entry.lease;
+                continue;
+            }
+        }
+    }
+    invalidateWorkspace(workspaceId) {
+        for (const entry of this.scopes.values())
+            if (entry.scope.workspaceId === workspaceId)
+                this.evict(entry);
+    }
+    invalidateSession(workspaceId, sessionId) {
+        for (const entry of this.scopes.values()) {
+            if (entry.scope.workspaceId !== workspaceId)
+                continue;
+            // A source removal also invalidates every pinned reference containing that source.
+            if (entry.build ||
+                entry.snapshots.some((snapshot) => snapshot.messages.some((message) => message.sessionId === sessionId)))
+                this.evict(entry);
+            else {
+                entry.sessions.delete(sessionId);
+                entry.pins.delete(sessionId);
+            }
+        }
+    }
+    invalidateView(authorizationView) {
+        for (const entry of this.scopes.values())
+            if (entry.scope.authorizationView === authorizationView)
+                this.evict(entry);
+    }
+    dispose() {
+        this.disposed = true;
+        this.clear();
+    }
+    clear() {
+        for (const entry of this.scopes.values())
+            this.evict(entry);
+    }
+    statistics() {
+        return {
+            scopes: this.scopes.size,
+            bytes: [...this.scopes.values()].reduce((total, entry) => total + bytes(entry), 0)
+        };
+    }
+    authorized(lease) {
+        return lease.expiresAt > this.now() && lease.valid();
+    }
+    entry(scope) {
+        const key = scopeKey(scope);
+        let entry = this.scopes.get(key);
+        if (entry && this.now() - entry.lastUsed >= this.hardTtlMs) {
+            this.evict(entry);
+            entry = undefined;
+        }
+        if (!entry) {
+            entry = {
+                scope: { ...scope },
+                snapshots: [],
+                pins: new Map(),
+                sessions: new Map(),
+                lastUsed: this.now()
+            };
+            this.scopes.set(key, entry);
+        }
+        entry.lastUsed = this.now();
+        // Map order is LRU across views as well as Workspaces.
+        this.scopes.delete(key);
+        this.scopes.set(key, entry);
+        this.enforceLimits();
+        return entry;
+    }
+    retained(entry) {
+        return !this.disposed && this.scopes.get(scopeKey(entry.scope)) === entry;
+    }
+    build(entry) {
+        if (entry.build)
+            return entry.build.promise;
+        const { lease, load } = entry;
+        if (this.reads >= 2 || !lease || !load || !this.authorized(lease) || !this.retained(entry))
+            return Promise.resolve();
+        const controller = new AbortController();
+        const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(1_000)]);
+        const promise = (async () => {
+            try {
+                this.reads++;
+                const loading = Promise.resolve().then(() => {
+                    signal.throwIfAborted();
+                    if (!this.retained(entry) || !this.authorized(lease))
+                        throw new Error('PROMPT_COMPLETION_UNAVAILABLE');
+                    return load(signal);
+                });
+                void loading
+                    .finally(() => {
+                    this.reads--;
+                })
+                    .catch(() => undefined);
+                const values = await abortable(loading, signal);
+                if (signal.aborted || !this.retained(entry) || !this.authorized(lease))
+                    return;
+                const messages = boundReferences(values);
+                const hash = createHash('sha256').update(JSON.stringify(messages)).digest('hex');
+                const latest = entry.snapshots.at(-1);
+                if (latest?.hash === hash)
+                    latest.verifiedAt = this.now();
+                else {
+                    entry.snapshots.push({ epoch: randomUUID(), hash, messages, verifiedAt: this.now() });
+                    if (entry.snapshots.length > 2)
+                        entry.snapshots.shift();
+                    for (const [id, pin] of entry.pins)
+                        if (!entry.snapshots.some((value) => value.epoch === pin.epoch))
+                            entry.pins.delete(id);
+                }
+                this.enforceLimits();
+            }
+            catch {
+                // Optional references may be omitted; failure never renews freshness.
+            }
+            finally {
+                if (entry.build?.controller === controller)
+                    delete entry.build;
+            }
+        })();
+        entry.build = { controller, promise };
+        return promise;
+    }
+    evict(entry) {
+        entry.build?.controller.abort();
+        this.scopes.delete(scopeKey(entry.scope));
+        delete entry.load;
+        delete entry.lease;
+        entry.snapshots.length = 0;
+        entry.sessions.clear();
+        entry.pins.clear();
+    }
+    enforceLimits() {
+        let total = 0;
+        const workspaceBytes = new Map();
+        for (const entry of [...this.scopes.values()].reverse()) {
+            const size = bytes(entry);
+            const workspaceSize = (workspaceBytes.get(entry.scope.workspaceId) ?? 0) + size;
+            if (total + size > MAX_BYTES || workspaceSize > MAX_WORKSPACE_BYTES)
+                this.evict(entry);
+            else {
+                total += size;
+                workspaceBytes.set(entry.scope.workspaceId, workspaceSize);
+            }
+        }
+        while (this.scopes.size > MAX_SCOPES)
+            this.evict(this.scopes.values().next().value);
+    }
+}
+function scopeKey(scope) {
+    return JSON.stringify([scope.workspaceId, scope.generation, scope.authorizationView]);
+}
+function bytes(entry) {
+    return Buffer.byteLength(JSON.stringify([entry.snapshots, [...entry.sessions], [...entry.pins]]));
+}
+function trimMap(map, size) {
+    while (map.size > size)
+        map.delete(map.keys().next().value);
+}
+function boundReferences(values) {
+    const seen = new Set();
+    const result = [];
+    for (const group of groupReferences(values.slice(0, 100), PROMPT_COMPLETION_REFERENCE_POOL_SESSIONS, null)) {
+        const selected = [];
+        let size = 0;
+        for (const value of group.slice(-MAX_REFERENCE_MESSAGES).reverse()) {
+            const key = JSON.stringify([value.sessionId, value.id]);
+            if (seen.has(key) || !value.text.trim())
+                continue;
+            seen.add(key);
+            const text = clipReferenceText(value.text);
+            if (size + Buffer.byteLength(text) > MAX_REFERENCE_BYTES)
+                continue;
+            size += Buffer.byteLength(text);
+            selected.push(Object.freeze({ sessionId: value.sessionId, id: value.id, revision: value.revision, text }));
+        }
+        result.push(...selected.reverse());
+    }
+    return Object.freeze(result);
+}
+function groupReferences(values, maximumSessions, excludedSessionId) {
+    const groups = new Map();
+    for (const value of values) {
+        if (value.sessionId === excludedSessionId)
+            continue;
+        let group = groups.get(value.sessionId);
+        if (!group) {
+            if (groups.size >= maximumSessions)
+                continue;
+            group = [];
+            groups.set(value.sessionId, group);
+        }
+        group.push(value);
+    }
+    return [...groups.values()];
+}
+function selectReferences(values, sessionId) {
+    const groups = groupReferences(values, MAX_REFERENCE_SESSIONS, sessionId);
+    const selected = [];
+    let size = 0;
+    for (let offset = 1; offset <= MAX_REFERENCE_MESSAGES && selected.length < MAX_REFERENCE_MESSAGES; offset++) {
+        for (const group of groups) {
+            const value = group.at(-offset);
+            if (!value || size + Buffer.byteLength(value.text) > MAX_REFERENCE_BYTES)
+                continue;
+            selected.push(value.text);
+            size += Buffer.byteLength(value.text);
+            if (selected.length >= MAX_REFERENCE_MESSAGES)
+                break;
+        }
+    }
+    // Generation reads this sequence from the end, so the newest round stays last.
+    return selected.reverse();
+}
+function clipReferenceText(text) {
+    if (Buffer.byteLength(text) <= MAX_REFERENCE_TEXT_BYTES)
+        return text;
+    const suffix = '\n[truncated]';
+    let size = Buffer.byteLength(suffix);
+    let prefix = '';
+    for (const character of text) {
+        const length = Buffer.byteLength(character);
+        if (size + length > MAX_REFERENCE_TEXT_BYTES)
+            break;
+        prefix += character;
+        size += length;
+    }
+    return prefix + suffix;
+}
+function boundMessages(values) {
+    const selected = values.slice(-64).map((value) => Object.freeze({
+        id: value.id,
+        revision: value.revision,
+        role: value.role,
+        text: clip(value.text, 4_096)
+    }));
+    let size = selected.reduce((sum, value) => sum + Buffer.byteLength(value.text), 0);
+    if (values.length > 64 || size > 32_768)
+        while (selected.length > 1 && (selected.length > 32 || size > 16_384))
+            size -= Buffer.byteLength(selected.shift().text);
+    return Object.freeze(selected);
+}
+function clip(text, max) {
+    if (text.length <= max)
+        return text;
+    const end = /[\uD800-\uDBFF]/u.test(text[max - 1]) ? max - 1 : max;
+    return `${text.slice(0, end)}\n[truncated]`;
+}
+function abortable(pending, signal) {
+    return new Promise((resolve, reject) => {
+        const aborted = () => {
+            cleanup();
+            reject(signal.reason);
+        };
+        const cleanup = () => signal.removeEventListener('abort', aborted);
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        signal.addEventListener('abort', aborted, { once: true });
+        pending.then((value) => {
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}

package/dist/service/prompt-completion-context.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { composerVisibleText } from '@myagentroam/protocol';
+/** Consumes normalized conversation facts; never parses vendor logs or raw tool payloads. */
+export function projectCompletionContext(turns, historyGeneration) {
+    const history = [];
+    const references = [];
+    const seen = new Set();
+    const semantic = [];
+    const tools = [];
+    const waiting = [];
+    const partial = [];
+    let progressRevision = 0;
+    for (const turn of turns.slice(-12)) {
+        semantic.push([turn.id, turn.runId, turn.status]);
+        for (const item of turn.items.slice(-128)) {
+            progressRevision += item.revision;
+            const payload = record(item.payload);
+            if (item.kind === 'user_message') {
+                // Missing delivery is permitted only because the canonical history reader owns it.
+                if (payload.source !== undefined ||
+                    (payload.delivery !== undefined &&
+                        payload.delivery !== 'ACCEPTED' &&
+                        payload.delivery !== 'STEERED'))
+                    continue;
+                const text = typeof payload.text === 'string' ? composerVisibleText(payload.text) : '';
+                const id = typeof payload.clientMessageId === 'string' ? payload.clientMessageId : item.id;
+                if (!text.trim() || seen.has(id))
+                    continue;
+                seen.add(id);
+                const bounded = clip(text, 4_096);
+                history.push({ id, revision: item.revision, role: 'user', text: bounded });
+                references.push({ sessionId: item.sessionId, id, revision: item.revision, text: bounded });
+                semantic.push([id, item.revision, bounded]);
+            }
+            else if (item.kind === 'assistant_message' && typeof payload.text === 'string') {
+                if (item.status === 'COMPLETED') {
+                    if (seen.has(item.id))
+                        continue;
+                    seen.add(item.id);
+                    const text = clip(payload.text, 4_096);
+                    history.push({ id: item.id, revision: item.revision, role: 'assistant', text });
+                    semantic.push([item.id, item.revision, text]);
+                }
+                else if (item.status === 'IN_PROGRESS' && turn.id === turns.at(-1)?.id)
+                    partial.push(clip(payload.text, 1_024));
+            }
+            else if (['approval', 'user_input_request'].includes(item.kind)) {
+                semantic.push([item.id, item.revision, item.status]);
+                if (turn.id === turns.at(-1)?.id &&
+                    (item.status === 'PENDING' || item.status === 'IN_PROGRESS'))
+                    waiting.push({ kind: item.kind, status: item.status });
+            }
+            else if (['tool_call', 'command_execution', 'file_change'].includes(item.kind)) {
+                // Tool names, arguments, titles, paths, output and error bodies are not copied.
+                if (turn.id === turns.at(-1)?.id)
+                    tools.push({ category: item.kind, status: item.status });
+            }
+        }
+    }
+    const contextVersion = createHash('sha256')
+        .update(JSON.stringify([historyGeneration, semantic]))
+        .digest('hex');
+    return {
+        identity: { historyGeneration, contextVersion, progressRevision },
+        history: history.slice(-64),
+        references: references.slice(-20),
+        executionSnapshot: JSON.stringify({
+            status: turns.at(-1)?.status ?? 'IDLE',
+            tools: tools.slice(-6),
+            waiting: waiting.slice(-6),
+            partialAssistant: partial.slice(-3)
+        })
+    };
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function clip(text, max) {
+    if (text.length <= max)
+        return text;
+    const half = Math.floor((max - 32) / 2);
+    const head = text.slice(0, half).replace(/[\uD800-\uDBFF]$/u, '');
+    const tail = text.slice(-half).replace(/^[\uDC00-\uDFFF]/u, '');
+    return `${head}\n[excerpt omitted]\n${tail}`;
+}