afucontext 0.0.0-stage → 0.1.18

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

@@ -0,0 +1,548 @@
+import { BasicCompactionEngine as BundledBasicCompactionEngine, } from "@deepseek-ai/dsh-compaction-basic";
+import { BlockAssembler as BundledBlockAssembler, createUserMessage as bundledCreateUserMessage, } from "@deepseek-ai/dsh-llm";
+import { journal, sessionHash, afuTrigger, summaryPrefix, observationId, HostCompactPool, bindingKey, estimateContentTokens, findAppliedArtifact, normalizeContent, } from "../../shared/runtime-client/dist/index.js";
+const hostModules = (globalThis.__afuDshHost) ?? {};
+const BasicCompactionEngine = typeof hostModules.BasicCompactionEngine === "function" ? hostModules.BasicCompactionEngine : BundledBasicCompactionEngine;
+const BlockAssembler = typeof hostModules.BlockAssembler === "function" ? hostModules.BlockAssembler : BundledBlockAssembler;
+const createUserMessage = typeof hostModules.createUserMessage === "function" ? hostModules.createUserMessage : bundledCreateUserMessage;
+/**
+ * DSH-native compaction provider. Idle turns prepare Compact Artifacts off-path;
+ * the next pre-step commits only exact, still-contiguous coverage through DSH's
+ * native transaction. Missing or stale Artifacts keep DSH's default policy.
+ */
+export class CompactDshEngine extends BasicCompactionEngine {
+    log = journal("dsh");
+    handed = new WeakMap();
+    handoff(agent, result) {
+        const id = observationId(result);
+        const previous = this.handed.get(agent);
+        // A retried or manual compactRegion hands off again; the earlier summary
+        // was superseded rather than silently dropped.
+        if (previous && previous.id !== id)
+            this.log("summary_discarded", { session: sessionHash(agent.session.id), artifact_id: previous.id, reason: "superseded" });
+        this.handed.set(agent, { id });
+        this.log("summary_handoff", { session: sessionHash(agent.session.id), artifact_id: id });
+    }
+    finishHandoff(agent, committed, result) {
+        const handoff = this.handed.get(agent);
+        if (!handoff)
+            return;
+        if (committed)
+            this.handoffCommitted.add(agent);
+        this.handed.delete(agent);
+        const removed = committed && result ? dshRemovedTokens(result) : undefined;
+        if (committed)
+            this.carried.set(agent.session.id, { artifactId: handoff.id, ...(removed === undefined ? {} : { removed }) });
+        this.log(committed ? "summary_applied" : "summary_discarded", { session: sessionHash(agent.session.id), artifact_id: handoff.id, ...(committed ? { phase: "host_commit", ...(removed === undefined ? {} : { removed_tokens_estimate: removed }) } : { reason: "host_commit_failed" }) });
+    }
+    /** Agents whose current compaction committed an AFU summary. */
+    handoffCommitted = new WeakSet();
+    /** Per DSH session: the AFU summary its current surface starts from. */
+    carried = new Map();
+    cacheSeen = new Set();
+    host = new HostCompactPool();
+    bindings = new Map();
+    compactClient;
+    generation = 0;
+    idlePrecomputer;
+    selectedResults = new Map();
+    constructor(ctx, config = {}) {
+        super(ctx, { ...config, summarizationProvider: "", summarizationModel: "" });
+        this.compactClient = { compact: (request, signal) => {
+                const binding = this.bindings.get(String(request.session_id));
+                if (!binding)
+                    throw new Error("No DSH model binding");
+                return this.host.compact(request, binding, signal);
+            } };
+        ctx.on("llm/adapters-updated", () => { this.generation++; });
+        // One receipt per model call, from the usage DSH records with each
+        // assistant message: provider counts, cache reads, and whether the
+        // request was built on an AFU summary.
+        ctx.on("session/event", (session, raw) => {
+            const event = raw;
+            // Any compaction replaces the surface; an AFU commit sets it again
+            // right after (finishHandoff), a native one leaves it cleared.
+            if (event?.type === "compaction/end")
+                this.carried.delete(session.id);
+            if (event?.type !== "assistant/message" || !event.data?.usage)
+                return;
+            const carried = this.carried.get(session.id);
+            const usage = dshUsage(event.data.usage, this.cacheSeen, session.id);
+            this.log("request_receipt", { session: sessionHash(session.id), applied: carried !== undefined, upstream_success: true,
+                ...(carried?.artifactId ? { artifact_id: carried.artifactId } : {}),
+                ...(carried?.removed === undefined ? {} : { removed_tokens_estimate: carried.removed }),
+                ...usage });
+        });
+        this.idlePrecomputer = new DshIdlePrecomputer(this.compactClient, (sessionId, error) => {
+            this.log("adapter_error", { session: sessionHash(sessionId), reason: "idle_preparation_unavailable" });
+            ctx.logger.warn("compact idle preparation unavailable; native compaction remains active");
+        });
+        ctx.on("agent/status", async ({ agent, status }) => {
+            if (status !== "idle")
+                return;
+            // Context size as DSH's own token meter prices it, plus the AFU trigger for the routed model.
+            let tokens, window;
+            tokens = dshContextTokens(ctx, agent);
+            try {
+                window = (await dshHostBinding(ctx, agent, () => this.generation, this.summaryMaxTokens(agent))).contextWindow;
+            }
+            catch {
+                window = undefined;
+            }
+            this.log("request_observed", { session: sessionHash(agent.session.id), phase: "host_turn_idle",
+                ...(tokens === undefined ? {} : { estimated_input_tokens: tokens }), ...afuTrigger(window) });
+            try {
+                const request = await this.boundRequest(agent, agent.session.deriveMessages(), "sync");
+                this.idlePrecomputer.schedule(request);
+            }
+            catch {
+                ctx.logger.warn("compact host model unavailable; native compaction remains active");
+            }
+        });
+        ctx.effect(() => async () => {
+            // DSH creates and disposes an engine for every agent scope (the web app
+            // does so per request); the process lives on. runtime_stopped is logged
+            // once, when the process exits (see telemetry.journal).
+            // Stop scheduling first so jobs cancelled by shutdown are not reported
+            // as preparation failures, then stop the host and let them settle.
+            this.idlePrecomputer.stop();
+            await this.host.close();
+            await this.idlePrecomputer.close();
+            this.bindings.clear();
+        }, "afuContext.compact.workerClose");
+    }
+    /**
+     * Output budget for one summary: the maxTokens DSH's own compaction uses for
+     * this model (a modelPolicies entry, else the engine's, 65,536 by default).
+     * Reasoning models spend part of it thinking; a fixed 4,096 cut long
+     * summaries off at the limit.
+     */
+    summaryMaxTokens(agent) {
+        const config = this.config;
+        const target = dshRoute(agent);
+        const policy = config?.modelPolicies?.find(p => p.provider === target.provider && p.model === target.model);
+        const value = policy?.maxTokens ?? config?.maxTokens;
+        return Number.isSafeInteger(value) && value > 0 ? value : 65_536;
+    }
+    async boundRequest(agent, messages, mode) {
+        const binding = await dshHostBinding(this.ctx, agent, () => this.generation, this.summaryMaxTokens(agent));
+        for (const [key, old] of this.bindings) {
+            if (!await old.current()) {
+                this.bindings.delete(key);
+                this.idlePrecomputer.forget(key);
+            }
+        }
+        if (!this.bindings.has(binding.key) && this.bindings.size >= 16)
+            throw new Error("DSH binding limit reached");
+        this.bindings.set(binding.key, binding);
+        const request = dshMessagesToRequest(messages, binding.key, mode);
+        const tokens = dshContextTokens(this.ctx, agent);
+        return tokens === undefined ? request : { ...request, metadata: { ...request.metadata, host_context_tokens: tokens } };
+    }
+    async compactIfNeeded(agent, trigger, signal) {
+        const started = performance.now();
+        this.handoffCommitted.delete(agent);
+        try {
+            const result = await this.compactObserved(agent, trigger, signal);
+            // A compaction DSH made with its own summarizer (AFU had no usable
+            // summary, on any path): record it, so a failed AFU attempt is not
+            // the session's last word.
+            if (result && !this.handoffCommitted.has(agent)) {
+                this.carried.delete(agent.session.id);
+                const removed = dshRemovedTokens(result);
+                this.log("host_native_compaction", { session: sessionHash(agent.session.id), ...(removed === undefined ? {} : { removed_tokens_estimate: removed }) });
+            }
+            return result;
+        }
+        finally {
+            this.finishHandoff(agent, false);
+            this.log("host_compaction_receipt", { session: sessionHash(agent.session.id), host_compaction_ms: performance.now() - started });
+        }
+    }
+    async compactObserved(agent, trigger, signal) {
+        let request;
+        try {
+            request = await this.boundRequest(agent, agent.session.deriveMessages(), "active");
+        }
+        catch {
+            return super.compactIfNeeded(agent, trigger, signal);
+        }
+        this.handed.delete(agent);
+        const sessionId = String(request.session_id);
+        const prepared = this.idlePrecomputer.latest(sessionId);
+        const range = prepared === undefined
+            ? undefined
+            : dshPreparedRange(agent.session, request, prepared);
+        if (range !== undefined && prepared !== undefined) {
+            this.selectedResults.set(sessionId, prepared);
+            try {
+                const result = await this.compactRegion(range.start, range.end, agent, signal);
+                this.finishHandoff(agent, true, result);
+                return result;
+            }
+            catch (error) {
+                signal.throwIfAborted();
+                this.ctx.logger.warn("compact artifact unavailable; using DSH compaction policy");
+            }
+            finally {
+                this.selectedResults.delete(sessionId);
+            }
+        }
+        this.finishHandoff(agent, false);
+        try {
+            const result = await super.compactIfNeeded(agent, trigger, signal);
+            if (result)
+                this.finishHandoff(agent, true, result);
+            return result;
+        }
+        finally {
+            this.finishHandoff(agent, false);
+        }
+    }
+    async summarize(input, agent, signal) {
+        let request;
+        try {
+            request = await this.boundRequest(agent, input.messages, "sync");
+        }
+        catch {
+            // Model window unknown or binding limit reached: DSH's own summarizer
+            // must still run (this path is also used by manual compactNow).
+            signal?.throwIfAborted();
+            return super.summarize(input, agent, signal);
+        }
+        const sessionId = String(request.session_id);
+        const target = dshRoute(agent);
+        const prepared = this.selectedResults.get(sessionId) ?? this.idlePrecomputer.latest(sessionId);
+        const preparedSummary = prepared === undefined
+            ? undefined
+            : dshSummaryFromResult(request, prepared);
+        if (preparedSummary !== undefined) {
+            this.handoff(agent, prepared);
+            return { ...preparedSummary, provider: target.provider, model: target.model };
+        }
+        try {
+            const result = await this.compactClient.compact(request, signal);
+            const summary = dshSummaryFromResult(request, result);
+            if (summary !== undefined) {
+                this.handoff(agent, result);
+                return { ...summary, provider: target.provider, model: target.model };
+            }
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            this.ctx.logger.warn("compact worker unavailable; using DSH summarizer");
+        }
+        return super.summarize(input, agent, signal);
+    }
+}
+/** Resolve the host's route; credentials and provider middleware stay in ctx.llm. */
+const dshRoutes = new WeakMap();
+function dshRoute(agent) {
+    const latest = agent.session.requestHeader()?.config;
+    const options = { ...(agent.options.provider ? { provider: agent.options.provider } : {}), ...(agent.options.model ? { model: agent.options.model } : {}) };
+    const optionsKey = bindingKey(options), headerKey = bindingKey(latest);
+    const previous = dshRoutes.get(agent);
+    const target = !previous || previous.header !== headerKey
+        ? (latest ? { provider: latest.provider, model: latest.model } : options)
+        : previous.options !== optionsKey ? options : previous.target;
+    dshRoutes.set(agent, { options: optionsKey, header: headerKey, target });
+    return target;
+}
+export async function dshHostBinding(ctx, agent, generation, summaryMaxTokens = 65_536) {
+    const route = () => dshRoute(agent);
+    const target = route();
+    if (!target.provider || !target.model)
+        throw new Error("No selected DSH model");
+    const windowFor = async (selected) => {
+        if (!selected.provider || !selected.model)
+            throw new Error("DSH model unavailable");
+        const info = await ctx.llm.resolveModelInfo(selected.provider, selected.model);
+        outputCap = info.defaultMaxTokens;
+        const window = info.context?.contextWindow;
+        if (!Number.isSafeInteger(window) || !window || window <= 0)
+            throw new Error("DSH model window unavailable");
+        return window;
+    };
+    let outputCap;
+    const epoch = generation();
+    const contextWindow = await windowFor(target);
+    const key = bindingKey([agent.session.id, target, epoch, contextWindow]);
+    let usage = {};
+    return {
+        key,
+        diagnostics: { host: "dsh", session: sessionHash(agent.session.id), usage: () => usage },
+        contextWindow,
+        current: async () => {
+            const selected = route();
+            if (generation() !== epoch || bindingKey(selected) !== bindingKey(target))
+                return false;
+            const window = await windowFor(selected);
+            return generation() === epoch && bindingKey(route()) === bindingKey(target) && window === contextWindow;
+        },
+        complete: async (prompt, signal, ids) => {
+            const header = agent.session.requestHeader();
+            const selected = summaryPrefix((ids?.length ? agent.session.deriveMessages() : []).map(message => ({ id: String(message.id), messages: [message] })), ids, prompt);
+            const assembler = new BlockAssembler();
+            let finished = false;
+            for await (const chunk of ctx.llm.stream({
+                provider: target.provider, model: target.model,
+                ...(ids?.length ? { ...(header?.system === undefined ? {} : { system: header.system }), ...(header?.tools === undefined ? {} : { tools: [...header.tools] }) } : {}),
+                messages: [...selected.messages, createUserMessage({ content: [{ type: "text", text: selected.prompt }], source: { kind: "plugin", plugin: "afu-context" } })],
+                maxTokens: Number.isSafeInteger(outputCap) && outputCap > 0 ? Math.min(summaryMaxTokens, outputCap) : summaryMaxTokens,
+                purpose: "compaction", sessionId: agent.session.id, signal,
+            })) {
+                if (chunk.type === "finish")
+                    finished = true;
+                assembler.push(chunk);
+            }
+            const u = assembler.usage;
+            usage = u ? { input_tokens: u.inputTokens, output_tokens: u.outputTokens, cache_read_input_tokens: u.cacheReadTokens, cache_creation_input_tokens: u.cacheWriteTokens, cache_usage_known: u.cacheReadTokens !== undefined } : {};
+            const failure = (reason) => Object.assign(new Error("DSH summary incomplete"), { afuReason: reason });
+            if (!finished)
+                throw failure("summary_incomplete");
+            if (assembler.finish.kind === "max-tokens")
+                throw failure("summary_output_limit");
+            if (assembler.finish.kind === "error" || assembler.finish.kind === "aborted") {
+                // Fixed codes only: the provider's failure text is never logged.
+                const code = assembler.finish.failure?.code;
+                throw failure(assembler.finish.kind === "aborted" ? "summary_cancelled"
+                    : code === "CONTEXT_WINDOW_EXCEEDED" ? "summary_context_exceeded"
+                        : code === "RATE_LIMIT" ? "summary_rate_limited" : "summary_provider_error");
+            }
+            if (assembler.finish.kind !== "stop")
+                throw failure("summary_incomplete");
+            const blocks = assembler.blocks();
+            if (blocks.some(b => b.type === "tool-call"))
+                throw failure("summary_called_tool");
+            return blocks.filter(b => b.type === "text").map(b => b.text).join("\n");
+        },
+    };
+}
+/** DSH usage counts are disjoint (inputTokens is uncached input); total input includes cache. */
+export function dshUsage(u, cacheSeen, sessionId) {
+    const read = Number.isFinite(u.cacheReadTokens) ? u.cacheReadTokens : undefined;
+    const write = Number.isFinite(u.cacheWriteTokens) ? u.cacheWriteTokens : 0;
+    if (!Number.isFinite(u.inputTokens))
+        return {};
+    if (read !== undefined && read > 0)
+        cacheSeen.add(sessionId);
+    const known = read !== undefined && (read > 0 || cacheSeen.has(sessionId));
+    return {
+        input_tokens: u.inputTokens + (read ?? 0) + write,
+        ...(Number.isFinite(u.outputTokens) ? { output_tokens: u.outputTokens } : {}),
+        cache_usage_known: known,
+        ...(known ? { cache_read_input_tokens: read } : {}),
+        ...(write > 0 ? { cache_creation_input_tokens: write } : {}),
+    };
+}
+/** Tokens the committed summary took out of every following request. */
+function dshRemovedTokens(result) {
+    const shadowed = result.shadowedTokenCount;
+    if (!Number.isFinite(shadowed))
+        return undefined;
+    const text = result.summary.map(b => b.type === "text" ? b.text : "").join("");
+    return Math.max(0, shadowed - Math.ceil(text.length / 4));
+}
+/** DSH's own token meter (the measure its native compaction uses), if available. */
+function dshContextTokens(ctx, agent) {
+    try {
+        const meter = ctx.tokenMeter;
+        const tokens = meter?.measure(agent.session).totalTokens;
+        return Number.isSafeInteger(tokens) && tokens > 0 ? tokens : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function dshMessagesToRequest(messages, sessionId, mode = "active") {
+    const groups = toolCallGroups(messages);
+    const items = messages.map((message) => {
+        const content = normalizeContent(message.content);
+        const toolResult = message.content.find((block) => block.type === "tool-result");
+        const atomicGroup = toolResult?.type === "tool-result"
+            ? groups.calls.get(String(toolResult.toolCallId))
+            : groups.messageGroups.get(String(message.id));
+        return {
+            schema_version: "1",
+            id: String(message.id),
+            kind: toolResult === undefined ? dshKind(message.role) : "tool",
+            content,
+            source: { schema_version: "1", provider: "dsh.surface", source_id: String(message.id) },
+            token_count: estimateContentTokens(content),
+            ...(atomicGroup === undefined ? {} : { atomic_group: atomicGroup }),
+            metadata: {
+                adapter: "dsh",
+                native_role: message.role,
+            },
+        };
+    });
+    const estimatedTokens = items.reduce((total, item) => total + (item.token_count ?? 0), 0);
+    return {
+        schema_version: "1",
+        session_id: sessionId,
+        token_budget: Math.max(20_000, estimatedTokens),
+        items,
+        query: "",
+        mode,
+        metadata: {
+            adapter: "dsh",
+            source_profile: {
+                representation: "text",
+                sequence_semantics: "append_only",
+                atomic_unit: "turn",
+                preserve_atomic_units: true,
+                loss_tolerance: "low",
+            },
+            runtime_version: "0.2.2-rc.1",
+            query_aware: false,
+            host_owns_compaction_transaction: true,
+        },
+    };
+}
+/**
+ * Resolve a prepared Artifact to the exact DSH surface span it covers.
+ * Stale, reordered, or non-contiguous coverage is rejected without mutation.
+ */
+export function dshPreparedRange(session, request, result) {
+    const artifact = findAppliedArtifact(result);
+    if (artifact === undefined)
+        return undefined;
+    const requestIds = request.items.map((item) => item.id);
+    const startIndex = requestIds.indexOf(artifact.replacedItemIds[0] ?? "");
+    if (startIndex < 0)
+        return undefined;
+    const coveredIds = requestIds.slice(startIndex, startIndex + artifact.replacedItemIds.length);
+    if (coveredIds.length !== artifact.replacedItemIds.length ||
+        coveredIds.some((id, index) => id !== artifact.replacedItemIds[index])) {
+        return undefined;
+    }
+    const seqByMessageId = new Map();
+    for (const seq of session.surface.nodes) {
+        const event = session.eventAt(seq);
+        if (event === undefined)
+            return undefined;
+        const message = session.deriveEventMessage(event);
+        if (message !== null)
+            seqByMessageId.set(String(message.id), seq);
+    }
+    const start = seqByMessageId.get(artifact.replacedItemIds[0] ?? "");
+    const end = seqByMessageId.get(artifact.replacedItemIds.at(-1) ?? "");
+    return start === undefined || end === undefined ? undefined : { start, end };
+}
+/** Return a DSH summary only when one Artifact covers the whole selected input. */
+export function dshSummaryFromResult(request, result) {
+    const artifact = findAppliedArtifact(result);
+    if (artifact === undefined || typeof artifact.item.content !== "string")
+        return undefined;
+    // DSH 0.2 replays the system head in front of the region it summarizes;
+    // the summary replaces only the region, so a leading system message is
+    // context, not coverage.
+    let first = 0;
+    while (first < request.items.length && request.items[first].kind === "system" && request.items[first].id !== artifact.replacedItemIds[0])
+        first++;
+    const requestIds = request.items.slice(first).map((item) => item.id);
+    if (artifact.replacedItemIds.length !== requestIds.length ||
+        artifact.replacedItemIds.some((id, index) => id !== requestIds[index])) {
+        return undefined;
+    }
+    const summary = [{ type: "text", text: artifact.item.content }];
+    return {
+        summary,
+        rawOutput: summary,
+        provider: "afu_context.compact",
+        model: "worker",
+    };
+}
+/** Serializes background preparation per session and keeps only completed results. */
+export class DshIdlePrecomputer {
+    client;
+    onError;
+    pending = new Map();
+    running = new Map();
+    completed = new Map();
+    closed = false;
+    constructor(client, onError = () => undefined) {
+        this.client = client;
+        this.onError = onError;
+    }
+    schedule(request) {
+        if (this.closed || request.session_id === null || request.session_id === undefined)
+            return;
+        const sessionId = request.session_id;
+        this.pending.set(sessionId, structuredClone({ ...request, mode: "sync" }));
+        if (!this.running.has(sessionId))
+            this.start(sessionId);
+    }
+    forget(sessionId) {
+        this.pending.delete(sessionId);
+        this.completed.delete(sessionId);
+    }
+    latest(sessionId) {
+        return this.completed.get(sessionId);
+    }
+    async drain() {
+        while (this.running.size > 0) {
+            await Promise.all(this.running.values());
+        }
+    }
+    /** Stop accepting work; in-flight failures after this are expected. */
+    stop() {
+        this.closed = true;
+        this.pending.clear();
+    }
+    async close() {
+        this.stop();
+        await this.drain();
+    }
+    start(sessionId) {
+        const task = this.run(sessionId).finally(() => {
+            if (this.running.get(sessionId) === task)
+                this.running.delete(sessionId);
+            if (!this.closed && this.pending.has(sessionId))
+                this.start(sessionId);
+        });
+        this.running.set(sessionId, task);
+    }
+    async run(sessionId) {
+        while (!this.closed) {
+            const request = this.pending.get(sessionId);
+            if (request === undefined)
+                return;
+            this.pending.delete(sessionId);
+            try {
+                const result = await this.client.compact(request);
+                if (findAppliedArtifact(result) === undefined)
+                    this.completed.delete(sessionId);
+                else
+                    this.completed.set(sessionId, result);
+            }
+            catch (error) {
+                if (!this.closed)
+                    this.onError(sessionId, error);
+            }
+        }
+    }
+}
+function dshKind(role) {
+    if (role === "assistant")
+        return "assistant";
+    if (role === "system")
+        return "system";
+    return "user";
+}
+function toolCallGroups(messages) {
+    const calls = new Map();
+    const messageGroups = new Map();
+    for (const message of messages) {
+        const callIds = message.content.flatMap((block) => block.type === "tool-call" ? [String(block.id)] : []);
+        if (callIds.length === 0)
+            continue;
+        const group = `dsh-tool-batch:${String(message.id)}`;
+        messageGroups.set(String(message.id), group);
+        for (const callId of callIds)
+            calls.set(callId, group);
+    }
+    return { calls, messageGroups };
+}
+export default CompactDshEngine;
+//# sourceMappingURL=index.js.map