@liwu1995/afu-context 0.1.6 → 0.1.11

package/src/afu_host_integrations/pi/dist/index.js

@@ -1,5 +1,5 @@
-import { sessionEntryToContextMessages, convertToLlm } from "@earendil-works/pi-coding-agent";
-import { journal, sessionHash, summaryPrefix, observationId, CompactWorkerClient, HostCompactPool, bindingKey, findAppliedArtifact, normalizeContent, } from "../../shared/runtime-client/dist/index.js";
+import { sessionEntryToContextMessages, convertToLlm, estimateTokens, getAgentDir, SettingsManager, DEFAULT_COMPACTION_SETTINGS } from "@earendil-works/pi-coding-agent";
+import { journal, sessionHash, afuTrigger, summaryPrefix, observationId, CompactWorkerClient, HostCompactPool, bindingKey, findAppliedArtifact, normalizeContent, } from "../../shared/runtime-client/dist/index.js";
 export function createCompactPiExtension(options = {}) {
     return function compactPi(pi) {
         const injected = options.worker instanceof CompactWorkerClient ? options.worker : undefined;
@@ -12,9 +12,46 @@ export function createCompactPiExtension(options = {}) {
         let warned = false;
         const log = journal("pi");
         const pending = new Map();
+        let epoch = 0;
+        let timer;
+        let automatic;
+        const fingerprint = (ctx) => bindingKey([
+            ctx.sessionManager.getSessionId(), ctx.model,
+            ctx.sessionManager.buildContextEntries(),
+        ]);
+        const invalidate = () => {
+            epoch++;
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+        };
+        pi.on("agent_start", invalidate);
+        pi.on("session_before_switch", invalidate);
+        pi.on("session_before_fork", invalidate);
+        pi.on("session_before_tree", invalidate);
+        pi.on("model_select", invalidate);
+        // Ready summaries per Pi session. They replace the summarized prefix of the
+        // very next model request (as the Codex/Claude Code gateway and DSH do),
+        // whether or not Pi's own compaction later accepts them.
+        const ready = new Map();
+        pi.on("context", async (event, ctx) => {
+            const sid = ctx.sessionManager.getSessionId();
+            const summary = ready.get(sid);
+            if (!summary)
+                return undefined;
+            const messages = applyPreparedSummary(event.messages, summary);
+            if (!messages)
+                return undefined;
+            log("summary_applied", { session: sessionHash(sid), artifact_id: summary.artifactId, phase: "host_request", removed_tokens_estimate: summary.removedTokens });
+            return { messages: messages };
+        });
         const report = (ctx, error) => {
             if (ctx.signal?.aborted)
                 return;
+            // Pi's own compaction declining (its keep-recent window covers the whole
+            // session) is not a model problem; the summary is still used per request.
+            if (error instanceof Error && /Nothing to compact|Already compacted/.test(error.message))
+                return;
             log("adapter_error", { session: sessionHash(ctx.sessionManager.getSessionId()), reason: "host_model_unavailable_or_changed" });
             if (warned || options.notifyErrors === false)
                 return;
@@ -23,7 +60,21 @@ export function createCompactPiExtension(options = {}) {
             ctx.ui.notify(`compact unavailable; Pi compaction remains active: ${message}`, "warning");
         };
         pi.on("agent_settled", async (_event, ctx) => {
-            log("request_observed", { session: sessionHash(ctx.sessionManager.getSessionId()), phase: "host_turn_settled" });
+            invalidate();
+            const generation = epoch;
+            // Context size as Pi itself measures it, for the dashboard's progress to the AFU trigger.
+            let usage;
+            try {
+                usage = ctx.getContextUsage();
+            }
+            catch {
+                usage = undefined;
+            }
+            log("request_observed", {
+                session: sessionHash(ctx.sessionManager.getSessionId()), phase: "host_turn_settled",
+                ...(usage?.tokens == null ? {} : { estimated_input_tokens: usage.tokens }),
+                ...afuTrigger(usage?.contextWindow),
+            });
             const entries = ctx.sessionManager.buildContextEntries();
             const visible = modelVisibleEntries(entries);
             const latest = visible.at(-1);
@@ -33,7 +84,54 @@ export function createCompactPiExtension(options = {}) {
             if (request === undefined)
                 return;
             try {
-                await compact(request, ctx, ctx.signal);
+                const identity = fingerprint(ctx);
+                const binding = injected ? undefined : await piHostBinding(ctx, pi);
+                const prepare = () => injected ? injected.compact(request, ctx.signal) : host.compact(request, binding, ctx.signal);
+                const deadline = Date.now() + 630_000;
+                const valid = () => generation === epoch && identity === fingerprint(ctx) && !ctx.signal?.aborted;
+                const inspect = async (result) => {
+                    if (!valid())
+                        return;
+                    if (piCompactionFromResult(visible, result, usage?.tokens ?? 0)) {
+                        const prepared = preparedSummary(visible, result);
+                        if (prepared)
+                            ready.set(ctx.sessionManager.getSessionId(), prepared);
+                        // Pi refuses to compact ("Nothing to compact") while its keep-recent
+                        // window covers the whole branch, and shows that as an error. The
+                        // summary is already used per request, so only commit when Pi can.
+                        if (!piCanCompact(ctx, visible, options.keepRecentTokens))
+                            return;
+                        // The native compact API aborts an active turn. Invoke only while idle,
+                        // with no queued prompt, then revalidate again in the native hook.
+                        if (!ctx.isIdle?.() || ctx.hasPendingMessages?.() || automatic)
+                            return;
+                        if (binding && !await binding.current())
+                            return;
+                        if (!valid() || !ctx.isIdle() || ctx.hasPendingMessages())
+                            return;
+                        automatic = { result, fingerprint: identity, ...(binding ? { binding } : {}) };
+                        const clear = () => { automatic = undefined; };
+                        try {
+                            ctx.compact({ onComplete: clear, onError: error => { clear(); report(ctx, error); } });
+                        }
+                        catch (error) {
+                            clear();
+                            throw error;
+                        }
+                        return;
+                    }
+                    if (!["scheduled", "running"].includes(result.async_job.status) || Date.now() >= deadline)
+                        return;
+                    timer = setTimeout(() => {
+                        timer = undefined;
+                        if (!valid())
+                            return;
+                        void prepare().then(inspect).catch(error => { if (valid())
+                            report(ctx, error); });
+                    }, 500);
+                    timer.unref?.();
+                };
+                await inspect(await prepare());
                 warned = false;
             }
             catch (error) {
@@ -41,6 +139,7 @@ export function createCompactPiExtension(options = {}) {
             }
         });
         pi.on("session_before_compact", async (event, ctx) => {
+            invalidate();
             const started = performance.now();
             const entries = modelVisibleEntries(ctx.sessionManager.buildContextEntries());
             const latest = entries.at(-1);
@@ -51,7 +150,13 @@ export function createCompactPiExtension(options = {}) {
             if (request === undefined)
                 return;
             try {
-                const result = await compact(request, ctx, event.signal);
+                const prepared = automatic;
+                // COSEC: an automatically requested commit must never use a stale model,
+                // session or history, nor fall back to an unrelated native summary.
+                if (prepared && ((prepared.binding && !await prepared.binding.current()) ||
+                    prepared.fingerprint !== fingerprint(ctx) || event.signal.aborted))
+                    return { cancel: true };
+                const result = prepared?.result ?? await compact(request, ctx, event.signal);
                 warned = false;
                 const compaction = piCompactionFromResult(entries, result, event.preparation.tokensBefore);
                 if (compaction) {
@@ -63,18 +168,21 @@ export function createCompactPiExtension(options = {}) {
                     pending.set(sid, { signature: bindingKey([compaction.summary, compaction.firstKeptEntryId]), artifactId });
                     log("summary_handoff", { session: sid, artifact_id: artifactId });
                 }
-                return compaction === undefined ? undefined : { compaction };
+                return compaction === undefined ? (prepared ? { cancel: true } : undefined) : { compaction };
             }
             catch (error) {
                 if (!event.signal.aborted)
                     report(ctx, error);
-                return undefined;
+                return automatic ? { cancel: true } : undefined;
             }
             finally {
                 log("host_compaction_receipt", { session: sessionHash(ctx.sessionManager.getSessionId()), host_compaction_ms: performance.now() - started });
             }
         });
         pi.on("session_compact", async (event, ctx) => {
+            // Pi's history now starts from its own compaction entry; the prepared
+            // prefix can no longer match, so stop offering it.
+            ready.delete(ctx.sessionManager.getSessionId());
             const sid = sessionHash(ctx.sessionManager.getSessionId());
             const handoff = pending.get(sid);
             if (event.fromExtension && handoff?.signature === bindingKey([event.compactionEntry.summary, event.compactionEntry.firstKeptEntryId]))
@@ -92,6 +200,9 @@ export function createCompactPiExtension(options = {}) {
             }
         });
         pi.on("session_shutdown", async () => {
+            invalidate();
+            automatic = undefined;
+            ready.clear();
             log("runtime_stopped");
             await host.close();
             await injected?.close();
@@ -134,10 +245,17 @@ export async function piHostBinding(ctx, pi) {
             const response = await ctx.modelRegistry.complete(model, {
                 ...(ids?.length ? { systemPrompt: ctx.getSystemPrompt(), ...(tools ? { tools } : {}) } : {}),
                 messages: [...selected.messages, { role: "user", content: selected.prompt, timestamp: Date.now() }],
-            }, { signal, maxTokens: 4096, sessionId: ctx.sessionManager.getSessionId() });
+            }, { signal, maxTokens: piSummaryMaxTokens(ctx, model), sessionId: ctx.sessionManager.getSessionId() });
             usage = piSummaryUsage(response.usage);
-            if (response.stopReason !== "stop" || response.content.some(b => b.type === "toolCall"))
-                throw new Error("Pi summary incomplete");
+            const failure = (reason) => Object.assign(new Error("Pi summary incomplete"), { afuReason: reason });
+            if (response.stopReason === "length")
+                throw failure("summary_output_limit");
+            if (response.stopReason === "error")
+                throw failure("summary_provider_error");
+            if (response.stopReason !== "stop")
+                throw failure("summary_incomplete");
+            if (response.content.some(b => b.type === "toolCall"))
+                throw failure("summary_called_tool");
             return response.content.filter(b => b.type === "text").map(b => b.text).join("\n");
         },
     };
@@ -182,6 +300,8 @@ export function piEntriesToRequest(entries, ctx, requiredIds) {
         mode: "active",
         metadata: {
             adapter: "pi",
+            // Pi's own measurement of the whole request; the worker follows it for the trigger.
+            ...(Number.isSafeInteger(usage.tokens) && usage.tokens > 0 ? { host_context_tokens: usage.tokens } : {}),
             source_profile: {
                 representation: "text",
                 sequence_semantics: "append_only",
@@ -219,6 +339,90 @@ export function piCompactionFromResult(entries, result, tokensBefore) {
         },
     };
 }
+/**
+ * Output budget for one summary, the way Pi sizes its own: 80% of
+ * compaction.reserveTokens (16,384 by default, so 13,107), capped by the
+ * model's maxTokens. Reasoning models spend part of it thinking; a fixed
+ * 4,096 made long summaries stop at the limit and every retry fail.
+ */
+export function piSummaryMaxTokens(ctx, model) {
+    let reserve = DEFAULT_COMPACTION_SETTINGS.reserveTokens;
+    try {
+        const value = SettingsManager.create(ctx.cwd, getAgentDir()).getCompactionReserveTokens();
+        if (Number.isFinite(value) && value > 0)
+            reserve = value;
+    }
+    catch { /* Pi's default */ }
+    const budget = Math.max(4096, Math.floor(0.8 * reserve));
+    return typeof model.maxTokens === "number" && model.maxTokens > 0 ? Math.min(budget, model.maxTokens) : budget;
+}
+/** Pi's compaction.keepRecentTokens for this project (Pi's own default when unset). */
+function piKeepRecentTokens(ctx) {
+    try {
+        const value = SettingsManager.create(ctx.cwd, getAgentDir()).getCompactionKeepRecentTokens();
+        if (Number.isFinite(value) && value >= 0)
+            return value;
+    }
+    catch { /* fall back to Pi's default */ }
+    return DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
+}
+/**
+ * Whether Pi's own compaction would accept a commit now: the messages after
+ * the latest compaction must exceed keepRecentTokens (Pi's estimate), or Pi
+ * reports "Nothing to compact (session too small)".
+ */
+export function piCanCompact(ctx, visible, keepRecent = piKeepRecentTokens(ctx)) {
+    let total = 0;
+    for (const entry of visible) {
+        if (entry.type === "compaction") {
+            total = 0;
+            continue;
+        }
+        for (const message of sessionEntryToContextMessages(entry))
+            total += estimateTokens(message);
+    }
+    return total > keepRecent;
+}
+/** A ready result that replaces a leading run of the given entries. */
+export function preparedSummary(visible, result) {
+    const artifact = findAppliedArtifact(result);
+    if (artifact === undefined || typeof artifact.item.content !== "string")
+        return undefined;
+    const ids = visible.map((entry) => entry.id);
+    if (artifact.replacedItemIds.length === 0 || artifact.replacedItemIds.length >= ids.length)
+        return undefined;
+    if (artifact.replacedItemIds.some((id, index) => ids[index] !== id))
+        return undefined;
+    const replaced = visible.slice(0, artifact.replacedItemIds.length).flatMap((entry) => sessionEntryToContextMessages(entry));
+    const replacedChars = JSON.stringify(replaced).length;
+    // Same id the summary_started/summary_ready events carry, so the dashboard links them.
+    const artifactId = observationId(result) ?? artifact.artifactId;
+    return {
+        replaced,
+        summary: artifact.item.content,
+        ...(artifactId === undefined ? {} : { artifactId }),
+        removedTokens: Math.max(0, Math.round((replacedChars - artifact.item.content.length) / 4)),
+    };
+}
+/**
+ * Replace the summarized prefix of a model request with Pi's own compaction
+ * summary message. Only an exact prefix match is rewritten; anything else
+ * (a later Pi compaction, a branch switch, edited history) is sent unchanged.
+ */
+export function applyPreparedSummary(messages, ready) {
+    const count = ready.replaced.length;
+    if (messages.length <= count)
+        return undefined;
+    for (let index = 0; index < count; index++) {
+        if (JSON.stringify(messages[index]) !== JSON.stringify(ready.replaced[index]))
+            return undefined;
+    }
+    const first = messages[0];
+    return [
+        { role: "compactionSummary", summary: ready.summary, tokensBefore: ready.removedTokens, timestamp: first?.timestamp ?? Date.now() },
+        ...messages.slice(count),
+    ];
+}
 function modelVisibleEntries(entries) {
     return entries.filter((entry) => sessionEntryToContextMessages(entry).length > 0);
 }

package/src/afu_host_integrations/shared/runtime-client/dist/host-worker.js

@@ -130,10 +130,12 @@ export class HostCompactPool {
                 res.setHeader("Content-Type", "application/json");
                 res.end(JSON.stringify({ choices: [{ message: { content: text }, finish_reason: "stop" }] }));
             }
-            catch {
+            catch (error) {
                 const diag = entry.binding.diagnostics;
+                // A short, fixed reason code from the binding (never provider text).
+                const code = typeof error?.afuReason === "string" ? error.afuReason : "host_summary_unavailable";
                 if (diag)
-                    journal(diag.host)("summary_failed", { session: diag.session, artifact_id: artifactId, duration_ms: started === undefined ? undefined : performance.now() - started, reason: controller.signal.aborted ? "summary_cancelled" : "host_summary_unavailable" });
+                    journal(diag.host)("summary_failed", { session: diag.session, artifact_id: artifactId, duration_ms: started === undefined ? undefined : performance.now() - started, reason: controller.signal.aborted ? "summary_cancelled" : code });
                 if (!res.destroyed)
                     res.writeHead(502).end('{"error":"host_summary_unavailable"}');
             }

package/src/afu_host_integrations/shared/runtime-client/dist/index.js

@@ -237,6 +237,6 @@ function isJsonValue(value) {
     return isRecord(value) && Object.values(value).every(isJsonValue);
 }
 export { HostCompactPool, bindingKey } from "./host-worker.js";
-export { journal, sessionHash } from "./telemetry.js";
+export { journal, sessionHash, afuTrigger } from "./telemetry.js";
 export { summaryPrefix } from "./prefix.js";
 //# sourceMappingURL=index.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/telemetry.js

@@ -3,15 +3,35 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID, createHash } from 'node:crypto';
 export const sessionHash = (value) => createHash('sha256').update(value).digest('hex').slice(0, 16);
+/**
+ * Context window and the token count at which AFU starts a background summary,
+ * matching the worker (afu_context.local_worker): an explicit window override,
+ * then AFU_TRIGGER_RATIO, else 0.5 for windows of 1M tokens or more and 0.6 below.
+ */
+export function afuTrigger(hostWindow, env = process.env, _platform = process.platform) {
+    const override = env.AFU_HOST_CONTEXT_WINDOW_OVERRIDE;
+    const window = override && override !== 'auto' ? Number(override) : hostWindow;
+    if (!Number.isSafeInteger(window) || !window || window < 1)
+        return {};
+    const configured = env.AFU_TRIGGER_RATIO && env.AFU_TRIGGER_RATIO !== 'auto' ? Number(env.AFU_TRIGGER_RATIO) : NaN;
+    const fallback = window >= 1_000_000 ? 0.5 : 0.6;
+    const ratio = configured > 0 && configured < 1 ? configured : fallback;
+    return { context_window: window, threshold: Math.floor(window * ratio) };
+}
 const journals = new Map();
 export function journal(host) {
     let log = journals.get(host);
     if (!log) {
-        log = createJournal(host);
-        journals.set(host, log);
-        log('runtime_started');
+        const created = createJournal(host);
+        journals.set(host, created);
+        created('runtime_started');
+        // One runtime_stopped per process, however many times the host recycles
+        // the adapter (DSH disposes an engine per agent scope).
+        process.once('exit', () => created('runtime_stopped'));
+        log = created;
     }
-    return log;
+    return (event, fields) => { if (event !== 'runtime_stopped')
+        log(event, fields); };
 }
 function createJournal(host) {
     const root = join(process.env.AFU_STATE_DIR ?? join(homedir(), '.local/share/afu-context'), 'logs');
@@ -33,7 +53,7 @@ function createJournal(host) {
             for (const [k, v] of Object.entries(fields)) {
                 if (['session', 'artifact_id', 'phase', 'reason'].includes(k) && typeof v === 'string' && /^[A-Za-z0-9_.:+-]{1,100}$/.test(v))
                     row[k] = v;
-                if (['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens', 'context_window', 'threshold', 'duration_ms', 'host_compaction_ms'].includes(k) && typeof v === 'number' && Number.isFinite(v) && v >= 0)
+                if (['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens', 'context_window', 'threshold', 'estimated_input_tokens', 'removed_tokens_estimate', 'duration_ms', 'host_compaction_ms'].includes(k) && typeof v === 'number' && Number.isFinite(v) && v >= 0)
                     row[k] = v;
                 if (['cache_usage_known', 'applied', 'upstream_success'].includes(k) && typeof v === 'boolean')
                     row[k] = v;