@afu_context/afu-context 0.0.0-stage → 0.1.7

package/platform-locks/pi/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "afu-pi-runtime",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "0.84.4"
+  }
+}

package/python/constraints.txt

@@ -0,0 +1,23 @@
+aiohappyeyeballs==2.7.1
+aiohttp==3.14.5
+aiosignal==1.4.0
+annotated-types==0.8.0
+attrs==26.1.0
+backports-zstd==1.8.0 ; python_full_version < '3.14'
+certifi==2026.10.23
+charset-normalizer==3.5.2
+frozenlist==1.8.0
+idna==3.20
+multidict==7.2.1
+propcache==0.5.4
+pydantic==2.14.1
+pydantic-core==2.50.1
+regex==2026.9.29
+requests==2.34.2
+tiktoken==0.12.0
+tomlkit==0.15.2
+truststore==0.10.5
+typing-extensions==4.16.0
+typing-inspection==0.4.4
+urllib3==2.8.0
+yarl==1.25.1

package/release.json

@@ -0,0 +1,6 @@
+{
+  "version": "0.1.7",
+  "build": "b2d271d0d7c5fdd1680e950c2bf74924ed174eb1e17c8d67f5ec1aeb636e6cea",
+  "wheel": "afu_context_local-0.1.7-py3-none-any.whl",
+  "prebuilt": false
+}

package/scripts/dsh-overlay.mjs

@@ -0,0 +1,63 @@
+/** Compose a disposable overlay using DSH's own YAML and patch semantics. */
+import {readFileSync, writeFileSync, realpathSync} from 'node:fs';
+import {createRequire} from 'node:module';
+import {join} from 'node:path';
+import {pathToFileURL} from 'node:url';
+import {load,dump} from 'js-yaml';
+import {entryListSchema,applyEntryPatches} from '@deepseek-ai/cordis-plugin-include';
+
+export function overlay(entries,module,presetModule) {
+  if (!Array.isArray(entries)) throw Error('Expected a composed DSH entry list');
+  const ids=new Set(), matches=[], presets=[];
+  function visit(rows,parent=null) {
+    for (const row of rows) {
+      if (!row || typeof row!=='object') throw Error('Invalid DSH entry');
+      if (row.id) {if(ids.has(row.id))throw Error('Ambiguous duplicate DSH entry id');ids.add(row.id);}
+      if (row.disabled) continue;
+      if (row.name==='@deepseek-ai/dsh-agent-presets') presets.push({row,parent});
+      if (row.name==='@deepseek-ai/dsh-compaction-basic') matches.push({row,parent});
+      if(row.group && Array.isArray(row.config))visit(row.config,row);
+    }
+  }
+  visit(entries);
+  if (presetModule) matches.push(...presets);
+  if (!matches.length) throw Error('No active basic compaction provider in the composed profile');
+  const patches=[];
+  for (const {row,parent} of matches) {
+    if(!row.id || (parent && !parent.id))throw Error('Compaction scope must have stable entry ids');
+    const id='afu-'+row.id;
+    if(ids.has(id))throw Error('AFU entry already exists');
+    patches.push({id:row.id,name:row.name,disabled:true});
+    patches.push({...parent && {id:parent.id},insert:[{...row,id,name:row.name==='@deepseek-ai/dsh-agent-presets'?presetModule:module}]});
+  }
+  const warnings=[];applyEntryPatches(entries,patches,(x)=>warnings.push(x));
+  if(warnings.length)throw Error('DSH overlay did not match the composed tree');
+  return patches;
+}
+if(process.argv[1] && import.meta.url===pathToFileURL(process.argv[1]).href) {
+  try {
+    const tree=load(readFileSync(0,'utf8'),{schema:entryListSchema});
+    let presetModule;
+    if (process.argv[3] && process.argv[4]) {
+      const requireHost=createRequire(realpathSync(process.argv[4]));
+      try {
+        const native=requireHost.resolve('@deepseek-ai/dsh-agent-presets');
+        presetModule=join(process.argv[3],'presets.mjs');
+        writeFileSync(presetModule, `import Native from ${JSON.stringify(pathToFileURL(native).href)};\nimport {presetAdapter} from ${JSON.stringify(new URL('./dsh-presets.mjs',import.meta.url).href)};\nexport default presetAdapter(Native, ${JSON.stringify(process.argv[2])}, ${JSON.stringify(process.argv[3])});\n`, {mode:0o600});
+      } catch (error) { if(error.code!=='MODULE_NOT_FOUND') throw error; }
+    }
+    const patches=overlay(tree,process.argv[2],presetModule);
+    if (process.argv[5]==='web-compat') {
+      const picker=tree.find(row=>!row.disabled && row.name==='@deepseek-ai/dsh-host-directory-picker-auto');
+      if (picker) {
+        if(!picker.id) throw Error('Directory picker has no stable ID');
+        patches.push({id:picker.id,name:picker.name,disabled:true}, {insert:[
+          {id:'afu-directory-backend',name:'@deepseek-ai/dsh-host-directory-picker-browse'},
+          {id:'afu-directory-ui',name:'@deepseek-ai/dsh-client-ui-directory-picker-browse'}
+        ]});
+      }
+    }
+    process.stdout.write(dump(patches,{schema:entryListSchema}));
+  }
+  catch {process.stderr.write('AFU: cannot safely locate DSH compaction scopes\n');process.exitCode=2;}
+}

package/scripts/dsh-presets.mjs

@@ -0,0 +1,49 @@
+/** Adapt only mount-time preset snapshots; discovery and authoring stay native. */
+import {cp, mkdtemp, readFile, writeFile, unlink} from 'node:fs/promises';
+import {dirname, join} from 'node:path';
+import {createHash} from 'node:crypto';
+import {load, dump} from 'js-yaml';
+import {entryListSchema, applyEntryPatches} from '@deepseek-ai/cordis-plugin-include';
+import {overlay} from './dsh-overlay.mjs';
+
+export function presetAdapter(Native, module, scratch) {
+  return class AfuAgentPresets extends Native {
+    snapshots = new Map();
+    async resolveMountable(id) {
+      const preset = await super.resolveMountable(id);
+      try {
+        const source = await readFile(preset.path, 'utf8');
+        // COSEC: only host-authorized local preset config; this schema preserves
+        // !!js expressions as data. AFU never evaluates config expressions.
+        const entries = load(source, {schema:entryListSchema});
+        let patches;
+        try { patches = overlay(entries, module); }
+        catch (error) {
+          if (error.message === 'No active basic compaction provider in the composed profile') return preset;
+          throw error;
+        }
+        const key = createHash('sha256').update(preset.path).update(source).digest('hex');
+        let pending = this.snapshots.get(key);
+        if (!pending) {
+          pending = (async () => {
+            // Random directory under the launcher's private temporary directory;
+            // never use a preset ID as a writable path or modify installed files.
+            const folder = await mkdtemp(join(scratch, 'preset-'));
+            await cp(dirname(preset.path), folder, {recursive:true, verbatimSymlinks:false});
+            const path = join(folder, 'agent.cordis.yml');
+            // COSEC: detach any copied symlink before writing the replacement.
+            await unlink(path);
+            await writeFile(path, dump(applyEntryPatches(entries, patches), {schema:entryListSchema}), {mode:0o600});
+            return {...preset, path};
+          })();
+          this.snapshots.set(key, pending);
+          pending.catch(() => this.snapshots.delete(key));
+        }
+        return await pending;
+      } catch {
+        this.ctx.logger.warn('AFU preset overlay unavailable; retaining native compaction');
+        return preset;
+      }
+    }
+  };
+}

package/scripts/dsh-web-probe.mjs

@@ -0,0 +1,14 @@
+/** Read host capabilities without starting plugins or changing its profile. */
+import {createRequire} from 'node:module';
+import {realpathSync,readFileSync} from 'node:fs';
+import {pathToFileURL} from 'node:url';
+const host=createRequire(realpathSync(process.argv[2]));
+try {
+  const boot=await import(pathToFileURL(host.resolve('@deepseek-ai/dsh-app-boot')).href);
+  boot.loadLayeredEnv('afu');
+  const dir=boot.resolveProfileDir(process.argv[3]);
+  const manifest=JSON.parse(readFileSync(new URL('package.json',pathToFileURL(dir+'/')),'utf8'));
+  let compatible=false;
+  try { const {default:Hmr}=await import(pathToFileURL(host.resolve('@deepseek-ai/cordis-plugin-hmr')).href);compatible=typeof Hmr?.prototype?.registerConfig==='function'; } catch {}
+  process.stdout.write(JSON.stringify({profileDir:dir,patchReload:manifest.dsh?.profile?.patchReload??'live',hmrCompatible:compatible}));
+} catch { process.exitCode=2; }

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

@@ -0,0 +1,422 @@
+import { BasicCompactionEngine, } from "@deepseek-ai/dsh-compaction-basic";
+import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { journal, sessionHash, summaryPrefix, observationId, HostCompactPool, bindingKey, estimateContentTokens, findAppliedArtifact, normalizeContent, } from "../../shared/runtime-client/dist/index.js";
+/**
+ * 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) {
+        const handoff = this.handed.get(agent);
+        if (!handoff)
+            return;
+        this.handed.delete(agent);
+        this.log(committed ? "summary_applied" : "summary_discarded", { session: sessionHash(agent.session.id), artifact_id: handoff.id, ...(committed ? { phase: "host_commit" } : { reason: "host_commit_failed" }) });
+    }
+    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++; });
+        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;
+            this.log("request_observed", { session: sessionHash(agent.session.id), phase: "host_turn_idle" });
+            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 () => {
+            this.log("runtime_stopped");
+            // 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");
+    }
+    async boundRequest(agent, messages, mode) {
+        const binding = await dshHostBinding(this.ctx, agent, () => this.generation);
+        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);
+        return dshMessagesToRequest(messages, binding.key, mode);
+    }
+    async compactIfNeeded(agent, trigger, signal) {
+        const started = performance.now();
+        try {
+            return await this.compactObserved(agent, trigger, signal);
+        }
+        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);
+                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);
+            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) {
+    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);
+        const window = info.context?.contextWindow;
+        if (!Number.isSafeInteger(window) || !window || window <= 0)
+            throw new Error("DSH model window unavailable");
+        return window;
+    };
+    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: 4096, 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 } : {};
+            if (!finished || assembler.finish.kind !== "stop")
+                throw new Error("DSH summary incomplete");
+            const blocks = assembler.blocks();
+            if (blocks.some(b => b.type === "tool-call"))
+                throw new Error("DSH summary called a tool");
+            return blocks.filter(b => b.type === "text").map(b => b.text).join("\n");
+        },
+    };
+}
+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.1.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;
+    const requestIds = request.items.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