@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/plugins/compaction/index.js

@@ -0,0 +1,7 @@
+import{a as B,b as Me,c as j}from"../../chunks/UC3FVVJ2.js";import{a as G}from"../../chunks/4XVRUSCQ.js";import{a as Se}from"../../chunks/L3N4FIEN.js";import"../../chunks/NAOUTU7A.js";import"../../chunks/UKXMCHHT.js";import{b as K}from"../../chunks/DRYAN665.js";import"../../chunks/2OSESBIL.js";import{j as Te,k as qe,o as A,p as Oe}from"../../chunks/YLNJXQ3Z.js";import{f as se}from"../../chunks/DDANMY45.js";import{h as Ie}from"../../chunks/37YOGDGY.js";import{a as L,b as Re}from"../../chunks/KESCTXGO.js";import"../../chunks/TYTQRLTX.js";import{A as Ce,i as $e,j as ne,k as _e,q as ve,v as H,w as D}from"../../chunks/D7E6EWIE.js";import{z as p}from"zod";var Ee=p.number().gt(0).lt(1),U=p.number().int().nonnegative(),ot=p.strictObject({provider:p.string().min(1).optional(),model:p.string().min(1).optional(),thinkingEffort:_e.default("low")}),at=p.strictObject({kind:p.literal("summarize"),target:Ee.default(.5),tail:p.number().nonnegative().lt(1).default(.15),opening:p.number().nonnegative().lt(1).default(.1),summaryCap:p.number().int().positive().default(8192),summaryFloor:p.number().int().positive().default(1024),reasoningAllowance:U.default(8192),replyReserve:U.default(16384),checkpointRatio:p.number().gt(0).lte(1).default(.5),copiedInputChars:p.number().int().positive().default(4e3),boundaryQuoteChars:p.number().int().positive().default(200),breaker:p.number().int().positive().default(3),withoutWindow:p.strictObject({tailTokens:U.default(2e4),openingTokens:U.default(1e4)}).default({tailTokens:2e4,openingTokens:1e4}),summarizer:ot.default({thinkingEffort:"low"})}).refine(e=>e.summaryFloor<=e.summaryCap,{message:"The summary floor must not exceed the summary cap, or no summary could be allowed"}),it=p.strictObject({kind:p.literal("prune"),keepRecent:p.number().int().nonnegative().default(8),minTokens:p.number().int().positive().default(250)}),ze=p.strictObject({threshold:Ee.default(.8),strategy:p.discriminatedUnion("kind",[at,it]).prefault({kind:"summarize"})}).refine(e=>e.strategy.kind!=="summarize"||e.strategy.target<e.threshold,{message:"The target must lie below the threshold, or a compaction would aim above the point that triggers it",path:["strategy","target"]}),Ae=p.strictObject({focus:p.string().trim().min(1).optional()}).nullable();var ct=4,re=4,je=4,lt=1600,v=e=>Math.ceil(e.length/ct);function ut(e){let t=0;for(let n of e)t+=re+(n.type==="text"?v(n.text):lt);return t}function R(e){let t=je+ut(e.content);e.reasoning_content!==null&&(t+=v(e.reasoning_content));for(let n of e.tool_calls)t+=re+v(n.name)+v(ve(n));return t}function Ne(e){let t=Ce(e.systemPrompt),n=e.tools.length===0?0:re+v(JSON.stringify(e.tools));return(t.length===0?0:je+v(t))+n}import{z as T}from"zod";var W="lagent:compaction",Pe=K({plugin:W,kind:"checkpoint",version:1,schema:T.strictObject({summary_cap:T.number().int().positive(),target_reached:T.boolean().nullable()})}),Fe=K({plugin:W,kind:"prune",version:1,schema:T.strictObject({chars:T.number().int().nonnegative(),attachments:T.number().int().nonnegative()})}),We=K({plugin:W,kind:"unusable-summary",version:1,schema:T.strictObject({reason:T.string()})});import{scopeOf as He}from"@leuduan/cordis";function J(e){let t=new Set;return(n,s)=>{t.has(n)||(t.add(n),e.reportError(new Error(s)))}}function Q(e,t){let n=new Set(e.tools.toolsFor(He(e),t).map(s=>s.name));return Me.every(s=>n.has(s))}function V(e,t,n){return Ne({systemPrompt:e.journal.state(A,t).threadPrompt??[],tools:e.tools.toolsFor(He(e),n).map(s=>s.spec)})}var Y=e=>e.queued.reduce((t,n)=>t+R(H({role:n.role,content:n.content})),0);var Le={name:"lagent:compaction:prune",inject:["journal","llm","tools"],apply(e,t){let n=new ae(e,t);G(e,t.threadId,{name:"compaction (prune)",plan:s=>n.plan(s)})}},ae=class{strategy;threshold;threadId;agentName;reportOnce;ctx;constructor(t,n){this.ctx=t,this.strategy=n.strategy,this.threshold=n.threshold,this.threadId=n.threadId,this.agentName=n.agentName,this.reportOnce=J(t)}plan(t){let{trigger:n,route:s}=t,r=this.ctx.journal.state(A,this.threadId).surface.entries,o=this.survey(r);if(n==="pressure"){let c=this.ctx.llm.capacity(s).contextWindow;if(c===null)return this.reportOnce(`window:${oe(s)}`,`Thread ${this.threadId}: ${oe(s)} declares no context window, so its tool results are never pruned for pressure`),{kind:"skip",reason:"the route declares no context window"};let l=this.estimate(r,t);if(l<=this.threshold*c)return{kind:"skip",reason:`the request is estimated at ${dt(l/c)} of the window, under the threshold`}}if(o.eligible.length===0){let c=`nothing to prune: ${N(o.results,"tool result")}, ${o.kept} kept recent, none of the rest an unpruned result estimated at ${N(this.strategy.minTokens,"token")} or more`;return n!=="request"&&this.reportOnce(`none:${n}:${s===null?"":oe(s)}:${mt(r)}`,`Thread ${this.threadId}: cannot prune (${n}): ${c}`),{kind:"skip",reason:c}}let a=o.eligible.reduce((c,l)=>c+l.chars,0),i=o.eligible.reduce((c,l)=>c+l.attachments,0);return{kind:"replace",replacements:this.rewrites(o.eligible),reason:`pruned ${N(o.eligible.length,"tool result")}, ${De(a,i)}`}}survey(t){let n=t.filter(a=>a.message.role==="tool"),s=Math.min(this.strategy.keepRecent,n.length),r=n.slice(0,n.length-s),o=[];for(let a of r){if(a.type!=="tool/result"||R(a.message)<this.strategy.minTokens)continue;let i=this.ctx.journal.eventAt(a.row.seq);if(i?.type!=="tool/result")throw new Error(`Row ${a.row.seq} is behind a tool result but is no tool result`);o.push({entry:a,name:i.data.result.name,chars:D(a.message).length,attachments:a.message.content.filter(c=>c.type!=="text").length})}return{results:n.length,kept:s,eligible:o}}rewrites(t){let{journal:n}=this.ctx,s=B(n,this.threadId),r=Q(this.ctx,this.agentName);return t.map(({entry:o,name:a,chars:i,attachments:c})=>{let l=s.get(o.row.seq);return{kind:"rewrite",stand_in:{content:[{type:"text",text:[`[tool result pruned: ${a}, ${De(i,c)}; message ${l}]`,...r?[j(l,1)]:[]].join(`
+`)}]},source:Fe.record({chars:i,attachments:c}),source_seqs:[o.row.seq]}})}estimate(t,n){let s=V(this.ctx,this.threadId,this.agentName),r=t.reduce((o,a)=>o+R(a.message),0);return s+r+Y(n)}},mt=e=>e.reduce((t,n)=>n.type==="surface/replaced"?Math.max(t,n.row.seq):t,0),N=(e,t)=>`${e} ${t}${e===1?"":"s"}`,De=(e,t)=>t===0?N(e,"character"):`${N(e,"character")} and ${N(t,"attachment")}`,dt=e=>`${Math.round(e*100)}%`,oe=e=>`${e.provider}/${e.model}`;function ie(e){let{boundary:t}=e;return[t===null?"Condense the conversation above, from its first message through its last, into a checkpoint.":`Condense part of the conversation above into a checkpoint: every message after the ${t.role} message that begins ${ht(t.text,e.quoteChars)} (the last message with that beginning before the part), through the last message above. What comes before that part is context, kept as it is or condensed already: do not restate it.`,"The checkpoint will replace that part for a model that continues the work from it. Describe the state as of the last message above, not what is happening now: later messages exist that you cannot see.",...e.merges?["That part holds an earlier checkpoint. Merge it and what came after it into one checkpoint; do not copy it."]:[],"Use these sections:","- Request and intent: what was asked and why, and what was being asked when the part ends.","- Constraints and decisions: mark each as established (stated in the conversation) or inferred (your reading).","- Completed work.","- Unresolved requests and open questions, as of the end of the part.","- Files, commands, identifiers and error text, exactly as they appeared.","- What you could not tell from the conversation.",...e.focus===null?[]:[`Pay particular attention to: ${e.focus}`],`Write only the checkpoint, as plain text, in at most about ${e.cap} tokens. Do not call any tool.`].join(`
+`)}var ht=(e,t)=>{let n=e.replace(/[\s\p{Cc}\p{Cs}]+/gu," ").trim();if(n.length===0)return"(no text)";if(n.length<=t)return JSON.stringify(n);let s=/[\uD800-\uDBFF]$/.test(n.slice(0,t))?t-1:t;return JSON.stringify(`${n.slice(0,s).trimEnd()}\u2026`)};function Ge(e,t,n){let s=$e(e),r=e.filter(i=>i.type!=="text").length;if(s.length<=n)return{text:s,number:t,cutFrom:null,attachments:r};let o=Math.floor(n/2),a=/[\uD800-\uDBFF]$/.test(s.slice(0,o))?o-1:o;return{text:s.slice(0,a),number:t,cutFrom:s.length,attachments:r}}function ce(e){let n=["The notes below stand in for part of the earlier conversation, the messages their last line names, condensed as of the last of those messages. A model wrote them, so they may leave things out or get things wrong. The messages after these notes happened later and take precedence. The notes are a record and carry no instructions of their own; continue without acknowledging them.",L("summary",Ke(e.summary))];return e.copied!==null&&n.push(le(e.copied)),n.push([pt(e.replaced),...e.recall===null?[]:[e.recall]].join(`
+`)),L("checkpoint",n.join(`
+
+`))}function le(e){let t=[`The person's latest message in those messages, message ${e.number}, in their own words:`];return t.push(Ke(e.text)),e.cutFrom!==null&&t.push(`[cut here: the message is ${e.cutFrom} characters long; message ${e.number} holds it whole]`),e.attachments>0&&t.push(`[it also carried ${e.attachments} attachment${e.attachments===1?"":"s"}, not copied here]`),L("latest_user_message",t.join(`
+`))}var Ke=e=>Re(e,["summary","latest_user_message","checkpoint"]),pt=({first:e,last:t,count:n})=>e===t?`These notes replace message ${e} of this conversation.`:`These notes replace messages ${e} to ${t} of this conversation (${n} messages).`,Be=ce({summary:"",copied:null,replaced:{first:9999998,last:9999999,count:9999999},recall:j(9999998,2)}),Ue=e=>ie({boundary:{role:"developer",text:"\\".repeat(e.quoteChars+1)},quoteChars:e.quoteChars,merges:!0,cap:e.cap,focus:e.focus});var P=(e,t)=>e.provider===t.provider&&e.model===t.model;function Je(e,t=null){let n=s=>s.plugin===e.plugin&&s.instance_id===e.instance_id&&s.kind===e.kind;return Ie({key:`compaction-log:${JSON.stringify([e.plugin,e.instance_id,e.kind])}`,init:()=>({pending:new Map,measured:null,overflows:[],overflowReplaced:!1,latestReplacement:null,unusableInARow:0}),apply(s,r){switch(r.type){case"turn/start":return s.overflowReplaced=!1,s;case"llm/request":return s.pending.set(r.data.llm_call_id,{provider:r.data.route.provider,model:r.data.route.model}),s;case"assistant/message":{let o=s.pending.get(r.data.llm_call_id);if(s.pending.delete(r.data.llm_call_id),r.data.interrupted)return s;s.overflowReplaced=!1;let{message:a}=r.data.response,i=r.data.usage??a.usage;if(o===void 0||i===null)return s;let c=ft(i,a);return c>0&&(s.measured={...o,seq:r.seq,tokens:c},s.overflows=s.overflows.filter(l=>!P(l,o))),s}case"assistant/attempt":{let o=s.pending.get(r.data.llm_call_id);return s.pending.delete(r.data.llm_call_id),r.data.failure_kind==="overflow"&&o!==void 0&&s.overflows.push({...o,seq:r.seq,measured:s.measured}),s}case"surface/replaced":return s.latestReplacement=r.seq,n(r.data.source)&&(r.data.trigger==="overflow"&&(s.overflowReplaced=!0),s.unusableInARow=0),s;case"ext":return t!==null&&r.data.plugin===e.plugin&&r.data.instance_id===e.instance_id&&r.data.kind===t.kind&&(s.unusableInARow+=1),s;case"installation/applied":case"installation/removed":return s.unusableInARow=0,s;default:return s}}})}function ft(e,t){let n=t.provider_state!==null||t.reasoning_content!==null;return e.input_tokens+e.output_tokens-(n?0:e.reasoning_output_tokens)}function Qe(e,t=0){let n=[],s=t;for(let r=t;r<=e.length;r+=1)r<e.length&&!e[r].directDeveloperInput||(r>s&&n.push({start:s,end:r,last:r===e.length}),s=r+1);return n}var de=e=>e.measured||e.written;function Ye(e){let{entries:t,balanced:n,budgets:s}=e;if(n.length!==t.length+1)throw new RangeError(`balanced has ${n.length} cuts for ${t.length} entries; it needs one more`);let r=t.length,{window:o}=e.continuation,a=ue(e.continuation,e.head,t),i=ue(e.summarizer,e.head,t),c=me(t.map(u=>u.retold?u.tokens:0)),l=(u,m,h)=>u[h]-u[m],w=o===null?s.withoutWindow.openingTokens:s.opening*o,k=o===null?s.withoutWindow.tailTokens:s.tail*o,{openingEnd:g}=e,f=g!==null&&g<r&&n[g+1]===!0&&l(a.sums,0,g+1)<=w?g+1:0,d=Qe(t,f),y=me(t.map(u=>u.written?0:1)),x=(u,m)=>l(y,u,m)>0,E=d.map(u=>{if(!n[u.start])return[];if(!u.last)return n[u.end]&&x(u.start,u.end)?[u.end]:[];let m=[];for(let h=u.start+1;h<r;h+=1)n[h]&&x(u.start,h)&&m.push(h);return m}),z=(u,m,h,$)=>{let I=l(a.sums,m,h),O=l(c,m,h),S=e.latestInput,C=S!==null&&S.index>=m&&S.index<h,M=C?S.tokens:0,F=a.head+a.sums[r]-I+a.written*(e.framing+M+O)+e.continuation.factor*e.claimed,ge=$===null?1/0:($-F)/a.written,Z=e.summarizer,we=Z.reasons?s.reasoningAllowance:0,ke=i.head+i.sums[h]+i.written*e.instruction,ye=Z.window===null?1/0:Z.window-ke-we,xe=s.checkpointRatio*I/a.written-(e.framing+M+O),ee=Math.floor(Math.min(s.summaryCap,ge,ye,xe)),te=Math.max(ee,0),rt=a.written*(e.framing+M+O+te),be=F+a.written*te;return{segment:u,start:m,end:h,capContinuation:ge,capSummary:ye,capRatio:xe,summaryCap:ee,feasible:ee>=s.summaryFloor,copiesInput:C,spanTokens:I,continuation:be,summaryCall:ke+te+we,reduction:I-rt,targetReached:o===null?null:be+s.replyReserve<=s.target*o}},_=u=>{let m=r,h=0;do m-=1,h+=l(a.sums,m,m+1);while(m>u+1&&h<k);for(;m>u&&!n[m];)m-=1;return m},q=u=>d.map((m,h)=>E[h].map($=>z(h,m.start,$,u)).filter($=>$.feasible)),fe=u=>{let m=u.flatMap(($,I)=>{if($.length===0)return[];let O=$.filter(C=>C.targetReached!==!1);if(O.length===0)return[Ve($)];if(!d[I].last)return[O[0]];let S=_(d[I].start);return[O.reduce((C,M)=>{let F=Math.abs(M.end-S)-Math.abs(C.end-S);return F<0||F===0&&M.end<C.end?M:C})]});if(m.length===0)return null;let h=m.filter($=>$.targetReached!==!1);return Ve(h.length>0?h:m)},X=o===null?null:s.threshold*o-s.replyReserve,b=fe(q(X));if(b===null&&o!==null){let u=q(o-s.replyReserve),m=u.filter(h=>h.length>0).length>=2;(e.acceptance==="window"||m)&&(X=o-s.replyReserve,b=fe(u))}return b===null?gt(s.summaryFloor,d.flatMap((u,m)=>E[m].map(h=>z(m,u.start,h,X)))):{kind:"plan",start:b.start,end:b.end,pinned:f,summaryCap:b.summaryCap,copiesInput:b.copiesInput,spanTokens:b.spanTokens,continuation:b.continuation,summaryCall:b.summaryCall,targetReached:b.targetReached,segment:{index:b.segment,count:d.length}}}var Ve=e=>e.reduce((t,n)=>n.reduction>t.reduction?n:t);function gt(e,t){if(t.length===0)return{kind:"none",cause:"nothing-to-replace",reason:"no span can be replaced: past the pinned opening there is no balanced run that keeps the newest message and holds more than checkpoints and notices"};let n=r=>Math.floor(r)>=e,s=t.filter(r=>n(r.capRatio));return s.length===0?{kind:"none",cause:"no-reduction",reason:`no span leaves room for a summary of at least ${e} tokens under the reduction it must make, its checkpoint and the notices it would make plugins tell again counted`}:s.every(r=>!n(r.capSummary))?{kind:"none",cause:"summary-call-too-large",reason:`no span's summary call leaves room for a summary of at least ${e} tokens in the summarizer's window; a summarizer route with a larger window is the way out`}:s.every(r=>!n(r.capContinuation))?{kind:"none",cause:"continuation-too-large",reason:`no span leaves room for a summary of at least ${e} tokens under the next request's ceiling: what must stay (prompt, tools, opening, developer input, tail) plus the reply reserve is too large`}:{kind:"none",cause:"no-span-fits-both",reason:`no span fits both budgets with room for a summary of at least ${e} tokens: a span short enough for the summary call leaves the next request over its ceiling; a summarizer route with a larger window is the way out`}}function ue(e,t,n){let s=e.scale??e.factor,r=o=>e.scale!==null&&de(o)?e.scale:e.factor;return{head:s*t,sums:me(n.map(o=>r(o)*o.tokens)),written:s}}var me=e=>{let t=[0];for(let n of e)t.push(t.at(-1)+n);return t};function Xe(e){let{head:t,sums:n}=ue(e.route,e.head,e.entries);return t+n.at(-1)+e.route.factor*e.claimed}function Ze(e,t,n){let s=t-(n.measuredTokens??0),r=n.estimated>0?s/n.estimated:1;return Math.max(1,e,r)}var wt=Je({plugin:W,instance_id:"default",kind:"checkpoint"},{kind:"unusable-summary"}),nt={name:"lagent:compaction:summarize",inject:["journal","llm","tools"],apply(e,t){let n=new pe(e,t);G(e,t.threadId,{name:"compaction (summarize)",plan:s=>n.plan(s)})}},pe=class{strategy;threshold;threadId;agentName;reportOnce;estimates=new Map;overflowParts=new Map;counted=new Map;ctx;constructor(t,n){this.ctx=t,this.strategy=n.strategy,this.threshold=n.threshold,this.threadId=n.threadId,this.agentName=n.agentName,this.reportOnce=J(t)}plan(t){let{strategy:n}=this,{trigger:s,route:r}=t,o=null;if(s==="request"){let _=Ae.safeParse(t.options??null);if(!_.success)return{kind:"fail",reason:`invalid compaction options: ${_.error.message}`};o=_.data?.focus??null}let a=this.ctx.journal.state(wt,this.threadId);if(s==="pressure"&&a.unusableInARow>=n.breaker)return{kind:"skip",reason:`the summarizer failed ${a.unusableInARow} times in a row; pressure no longer compacts until a summary is recorded or the thread is configured again`};if(s==="overflow"&&a.overflowReplaced)return{kind:"skip",reason:"this overflow sequence already had its recovery; a new turn or a completed reply allows another"};let i=this.ctx.llm.capacity(r).contextWindow;if(s==="pressure"&&i===null)return this.reportOnce(`window:${he(r)}`,`Thread ${this.threadId}: ${he(r)} declares no context window, so it is never compacted for pressure`),{kind:"skip",reason:"the route declares no context window"};let c=this.snapshot(t),l=this.factorFor(r,c.head,a),w=this.measurementOn(r,c.head,a),k=w?.scale??null,g=tt(c.entries,c.estimates,w?.anchor??null);if(s==="pressure"){let _=Xe({entries:g,head:c.head,claimed:c.claimed,route:{window:i,factor:l,scale:k}});if(a.overflowReplaced&&_<=i-n.replyReserve)return{kind:"skip",reason:"the overflow recovery planned this request; pressure resumes after the next finished reply"};if(_<=this.threshold*i)return{kind:"skip",reason:`the request is estimated at ${st(_/i)} of the window, under the threshold`}}let f,d;try{f=yt(this.ctx.llm.resolveRoute(kt(n.summarizer),r),n),d=this.ctx.llm.capacity(f)}catch(_){let q=`the summarizer route cannot be resolved: ${se(_)}`;return s==="request"?{kind:"fail",reason:q}:(this.reportOnce(`summarizer:${q}`,`Thread ${this.threadId}: cannot compact (${s}): ${q}`),{kind:"skip",reason:q})}let y=f.thinking_effort!=="none",x=this.shape(c,g),E=Ue({quoteChars:n.boundaryQuoteChars,cap:n.summaryCap,focus:o}),z=Ye({entries:x.entries,balanced:x.balanced,openingEnd:x.openingEnd,latestInput:x.latest===null?null:{index:x.latest.index,tokens:v(le(x.latest.copied))},head:c.head,claimed:c.claimed,framing:et(Be),instruction:et(E),continuation:{window:i,factor:l,scale:k},summarizer:P(f,r)?{window:d.contextWindow,factor:l,scale:k,reasons:y}:{window:d.contextWindow,factor:this.factorFor(f,c.head,a),scale:null,reasons:y},budgets:{...n,threshold:this.threshold},acceptance:s==="pressure"?"threshold":"window"});return z.kind==="none"?this.noCut(t,r,z,a):this.summarize(t,{snapshot:c,shape:x,plan:z,summarizer:f,reasons:y,focus:o,window:i},a)}summarize(t,n,s){let{strategy:r}=this,{snapshot:o,shape:a,plan:i,summarizer:c}=n,l=o.entries.slice(i.start,i.end),w=i.start>0?o.entries[i.start-1]:null,k=w===null?null:{role:w.message.role,text:D(w.message)},g=ie({boundary:k,quoteChars:r.boundaryQuoteChars,merges:l.some(f=>f.type==="surface/replaced"&&f.kind==="span"),cap:i.summaryCap,focus:n.focus});return{kind:"ask",call:{through:l.at(-1).row.seq,instructions:[g],route:{provider:c.provider,model:c.model,...c.thinking_effort===null?{}:{thinkingEffort:c.thinking_effort}},toolChoice:this.ctx.llm.capacity(c).providerTools?"none":"auto",maxOutputTokens:i.summaryCap+(n.reasons?r.reasoningAllowance:0)},finish:f=>this.checkpoint(f,n,s)}}checkpoint(t,n,s){let{strategy:r}=this,{snapshot:o,shape:a,plan:i}=n,c=o.entries.slice(i.start,i.end);if("failure"in t)return this.unusable(`the summary call failed: ${se(t.failure)}`,s);let{reply:l}=t,w=i.copiesInput?a.latest.copied:null,k=l.text.trim(),g=xt(a,i.start,i.end),f=ce({summary:k,copied:w,replaced:g,recall:this.recallLine(g.first,g.count)}),d=i.summaryCap+(n.reasons?r.reasoningAllowance:0),y=l.usage!==null?{tokens:Math.max(0,l.usage.output_tokens-l.usage.reasoning_output_tokens),limit:i.summaryCap,what:"its cap"}:n.reasons?{tokens:v(k),limit:d,what:"its generation limit"}:null,x=bt(l,y);return x!==null?this.unusable(x,s):{kind:"replace",replacements:[{kind:"span",stand_in:{role:"user",content:f},source:Pe.record({summary_cap:i.summaryCap,target_reached:i.targetReached}),source_seqs:c.map(E=>E.row.seq),auxiliary_request_seq:l.requestSeq}],reason:$t(i,g,n.window)}}recallLine(t,n){return Q(this.ctx,this.agentName)?j(t,n):null}unusable(t,n){let s=n.unusableInARow+1,r=s>=this.strategy.breaker?`; after ${s} in a row, pressure no longer compacts until a summary is recorded`:"";return{kind:"fail",reason:`unusable summary, nothing replaced: ${t}${r}`,facts:[We.record({reason:t})]}}noCut(t,n,s,r){let o=s.cause==="nothing-to-replace"||s.cause==="no-reduction";return t.trigger==="request"?{kind:o?"skip":"fail",reason:s.reason}:(this.reportOnce(`cut:${t.trigger}:${s.cause}:${he(n)}:${r.latestReplacement??0}`,`Thread ${this.threadId}: cannot compact (${t.trigger}): ${s.reason}`),{kind:"skip",reason:s.reason})}snapshot(t){let{journal:n}=this.ctx,s=[...n.state(A,this.threadId).surface.entries],r=s.map(a=>this.estimateOf(a)),o=V(this.ctx,this.threadId,this.agentName);return{entries:s,estimates:r,head:o,claimed:Y(t)}}factorFor(t,n,s){let r=this.ctx.llm.capacity(t).contextWindow;if(r===null)return 1;let o=1;for(let a of s.overflows){if(!P(a,t))continue;let i=this.overflowParts.get(a.seq);if(i===void 0){let c=a.measured!==null&&P(a.measured,a)?a.measured:null,l=0,w=0,k=this.sentWith(a.seq),g=k.map(f=>this.estimateOf(f));for(let f of tt(k,g,c))c!==null&&de(f)?l+=f.tokens:w+=f.tokens;i={measured:c,counted:l,rest:w},this.overflowParts.set(a.seq,i)}o=Ze(o,r,i.measured===null?{measuredTokens:null,estimated:n+i.rest}:{measuredTokens:this.scaleOf(i.measured,n)*(n+i.counted),estimated:i.rest})}return o}measurementOn(t,n,s){let{measured:r}=s;return r===null||!P(r,t)?null:{anchor:r,scale:this.scaleOf(r,n)}}scaleOf(t,n){let s=this.counted.get(t.seq);s===void 0&&(s=this.sentWith(t.seq).reduce((o,a)=>o+this.estimateOf(a).tokens,0),this.counted.set(t.seq,s));let r=n+s;return r>0?t.tokens/r:1}sentWith(t){let n=this.ctx.journal.eventAt(t)?.thread_id??this.threadId;return this.ctx.journal.stateAt(Oe("surface"),n,t).entries}estimateOf(t){let n=this.estimates.get(t.row.seq);if(n===void 0){let s=this.ctx.journal.eventAt(t.row.seq);n={tokens:R(t.message),retold:s?.type==="input/message"&&s.data.source!==null&&s.data.input_id===null},this.estimates.set(t.row.seq,n)}return n}shape(t,n){let{journal:s}=this.ctx,{entries:r}=t,a=s.lineage(this.threadId).filter(d=>d.type==="input/message"&&d.data.role==="user"&&d.data.source===null),i=a[0]?.seq,c=a.at(-1),l=r.map(d=>d.type==="surface/replaced"?qe(s,d.row):[d.row]),w=B(s,this.threadId),k=r.findIndex((d,y)=>(d.type!=="surface/replaced"||d.kind==="rewrite")&&l[y][0]?.seq===i),g=c===void 0?-1:l.findIndex(d=>d.some(y=>y.seq===c.seq));return{entries:r.map((d,y)=>({...n[y],directDeveloperInput:d.directDeveloperInput,retold:t.estimates[y].retold})),balanced:Array.from({length:r.length+1},(d,y)=>Te(r,y)),openingEnd:i===void 0||k<0?null:k,latest:c===void 0||g<0||c.type!=="input/message"?null:{index:g,copied:Ge(c.data.content,w.get(c.seq),this.strategy.copiedInputChars)},originals:l,numbers:w}}},et=e=>R(H({role:"user",content:e})),kt=({provider:e,model:t})=>({...e===void 0?{}:{provider:e},...t===void 0?{}:{model:t}});function yt(e,t){let n=e.thinking_effort,s=t.summarizer.thinkingEffort;if(n===null)return e;let r=ne.indexOf(s)<ne.indexOf(n)?s:n;return{...e,thinking_effort:r}}function xt(e,t,n){let s=e.originals.slice(t,n).flatMap(r=>r.map(o=>e.numbers.get(o.seq)));return{first:s.reduce((r,o)=>Math.min(r,o)),last:s.reduce((r,o)=>Math.max(r,o)),count:s.length}}function bt(e,t){return e.message.tool_calls.length>0?"it asked for a tool call":e.message.provider_calls.length>0?"the provider ran a tool for it":e.finish!=="completed"?`it did not finish (${e.finish})`:e.text.trim()===""?"it returned no text":t!==null&&t.tokens>t.limit?`it is longer than ${t.what} of ${t.limit} tokens`:null}function $t(e,t,n){let s=t.first===t.last?`message ${t.first}`:`messages ${t.first} to ${t.last}`;if(n===null)return`replaced ${s} with a checkpoint; the route declares no window, so the next request is estimated at ${Math.round(e.continuation)} tokens`;let r=st(e.continuation/n);return e.targetReached?`replaced ${s} with a checkpoint; the next request is estimated at ${r} of the window, within the target`:`replaced ${s} with a checkpoint; the next request is estimated at ${r} of the window, above the target`}var st=e=>`${Math.round(e*100)}%`,he=e=>`${e.provider}/${e.model}`;function tt(e,t,n){return e.map((s,r)=>({tokens:t[r].tokens,measured:n!==null&&s.row.seq<=n.seq,written:s.type==="surface/replaced"||t[r].retold}))}var _t=Se({id:"compaction#2",placement:"thread",schema:ze,setup(e,t,n){vt(e,n.thread.id,n.thread.agentName,t)}});function vt(e,t,n,s){let{strategy:r,threshold:o}=s;return r.kind==="summarize"?e.plugin(nt,{threadId:t,agentName:n,threshold:o,strategy:r}):e.plugin(Le,{threadId:t,agentName:n,threshold:o,strategy:r})}export{_t as compaction};

package/dist/plugins/compaction/log.d.ts

@@ -0,0 +1,61 @@
+import type { ExtensionRecord, Seq } from '../../models/index.js';
+/** A provider and model: what a usage measurement and a calibration factor belong to, effort aside. */
+export type ModelKey = {
+    readonly provider: string;
+    readonly model: string;
+};
+/** Whether two routes run on the same provider and model, whatever their efforts. */
+export declare const sameModel: (left: ModelKey, right: ModelKey) => boolean;
+/**
+ * The last request the provider measured, as its reply's usage says: the input it counted, cached
+ * tokens included, plus the reply, which is on the surface now, less reasoning a route does not
+ * send back. It counted the head and every surface row at or before the reply's row; those rows keep
+ * its scale until a newer measurement replaces it, whatever is replaced around them. Usable only on
+ * the same provider and model.
+ */
+export type UsageAnchor = ModelKey & {
+    /** The reply's `assistant/message` row: every surface entry at or before it is measured. */
+    readonly seq: Seq;
+    readonly tokens: number;
+};
+/** A request the provider refused as longer than its window, and what was measured when it was sent. */
+export type OverflowRecord = ModelKey & {
+    /** The `assistant/attempt` row whose `failure_kind` is `overflow`. */
+    readonly seq: Seq;
+    /** The measurement in force when it was sent. */
+    readonly measured: UsageAnchor | null;
+};
+/** What the compaction strategy measures from, folded over a thread's lineage. */
+export type CompactionLog = {
+    /** The route of each request whose reply has not come back yet, by its `llm_call_id`. */
+    pending: Map<string, ModelKey>;
+    /**
+     * The latest reply that was not cut off and carried usage of some positive count, on a known
+     * route; replaced only by a newer one, never by a replacement or a cut-off reply, since the rows it
+     * counted stay counted.
+     */
+    measured: UsageAnchor | null;
+    /**
+     * Overflows since the latest measurement on their own provider and model, oldest first: what the
+     * calibration factor for that model is folded from. A measurement on the model clears its overflows.
+     */
+    overflows: OverflowRecord[];
+    /**
+     * Whether this strategy already recorded a replacement on the `overflow` trigger in the current
+     * overflow sequence, which a turn's start and a reply that was not cut off begin.
+     */
+    overflowReplaced: boolean;
+    /** The latest `surface/replaced` row, by anyone; `null` when none. */
+    latestReplacement: Seq | null;
+    /**
+     * Unusable summaries since this strategy's latest checkpoint and the thread's latest change of
+     * installations: what its breaker counts.
+     */
+    unusableInARow: number;
+};
+/**
+ * The fold the strategy measures pressure from, keyed by `source` so two strategies' logs never
+ * share a key. Thread-scoped and inherited by forks: a fork's surface is its source's, and so are
+ * the measurements that describe it.
+ */
+export declare function compactionLog(source: Pick<ExtensionRecord, 'plugin' | 'instance_id' | 'kind'>, unusable?: Pick<ExtensionRecord, 'kind'> | null): import("../../journal/projection.js").PluginProjection<CompactionLog>;

package/dist/plugins/compaction/planner.d.ts

@@ -0,0 +1,207 @@
+import type { SummarizeStrategyConfig } from './config.js';
+/**
+ * The planner and the measurement it plans from: pure functions of their inputs, with no journal,
+ * no registry and no model, so every rule here is tested by handing it numbers.
+ *
+ * Token figures are estimates unless said otherwise, priced per route before they meet a window;
+ * the reasoning allowance and the reply reserve are tokens already and never scaled. A route with
+ * a usage measurement prices at that measurement's scale the head, every row it counted and every
+ * written text (stand-ins, notices, the framing, the instruction, the copied input), see
+ * {@link countedAtScale}; every other row, and the claimed input, which is recorded as such a row,
+ * at its calibration `factor`. The checkpoint is priced as the next step will price its stand-in,
+ * the summary at its cap; the summary call reserves the same cap as generation tokens, which is what
+ * bounds the summary. The stand-in is later estimated from its characters, which may differ from
+ * the provider's count by the tokenizer's ratio; the reply reserve, the slack between the plan's
+ * ceiling and the threshold the next check fires at, absorbs that.
+ */
+/** One surface message as the planner sees it. */
+export type PlannerEntry = {
+    /** Its estimated tokens, unscaled. */
+    readonly tokens: number;
+    /** A `developer` `input/message` with no `source`: no span may contain it, so it divides segments. */
+    readonly directDeveloperInput: boolean;
+    /**
+     * A sourced `input/message` a plugin contributed at a step: replacing it may make its plugin tell
+     * it again, so its size is reserved in the continuation of any span that holds it. Sourced input a
+     * plugin queued, such as an agent's notice, is not: its id is spent once queued.
+     */
+    readonly retold: boolean;
+    /** A usage measurement on the turn's provider and model counted it: its row is at or before the measured reply. */
+    readonly measured: boolean;
+    /** Written text: a stand-in a strategy wrote, or a plugin's contributed `input/message`. */
+    readonly written: boolean;
+};
+/** What pricing reads of an entry: its estimate, and how it was counted. */
+export type PricedEntry = Pick<PlannerEntry, 'tokens' | 'measured' | 'written'>;
+/**
+ * Whether an entry is priced at a route's measurement scale when the route has one: a measurement
+ * counted it, or it is written text, which the measured scale describes better than an overflow's
+ * factor. The one partition request pricing, the planner and calibration all use; everything else
+ * is priced at the factor.
+ */
+export declare const countedAtScale: (entry: Pick<PricedEntry, "measured" | "written">) => boolean;
+/**
+ * A route as the budgets read it: its declared window, `null` when none; its calibration factor;
+ * and the scale of its last usage measurement, `null` when it has none usable.
+ */
+export type RouteBudget = {
+    readonly window: number | null;
+    readonly factor: number;
+    /**
+     * What the provider counted over the estimate of what it counted, the head included: the scale
+     * the head and every entry {@link countedAtScale} are priced at, and written text. `null` prices
+     * everything at `factor`.
+     */
+    readonly scale: number | null;
+};
+/** The configured budgets the planner reads; see `SummarizeStrategySchema` and `threshold` for each. */
+export type PlanBudgets = Pick<SummarizeStrategyConfig, 'target' | 'tail' | 'opening' | 'summaryCap' | 'summaryFloor' | 'reasoningAllowance' | 'replyReserve' | 'checkpointRatio' | 'withoutWindow'> & {
+    readonly threshold: number;
+};
+/** Everything one plan is made from: the surface as estimates, the routes, and the budgets. */
+export type PlannerInput = {
+    readonly entries: readonly PlannerEntry[];
+    /** `balanced[i]`: the surface can be cut just before `entries[i]`; one longer than `entries`. */
+    readonly balanced: readonly boolean[];
+    /**
+     * The index of the first unsourced `user` input, which ends the opening the planner pins when it
+     * fits its budget; `null` when the surface holds none as itself, which pins nothing.
+     */
+    readonly openingEnd: number | null;
+    /** Where the person's latest input is, and what copying it into a checkpoint costs, unscaled. */
+    readonly latestInput: {
+        readonly index: number;
+        readonly tokens: number;
+    } | null;
+    /** The prompt, guidance and tool definitions every request sends first, unscaled. */
+    readonly head: number;
+    /** The input this step will record after the replacement, unscaled. */
+    readonly claimed: number;
+    /** A checkpoint's code-written text, preamble and footer, with an empty summary, unscaled. */
+    readonly framing: number;
+    /** The summary instruction, unscaled. */
+    readonly instruction: number;
+    /** The turn's route: what the request after the compaction is sent on. */
+    readonly continuation: RouteBudget;
+    /** The summary call's route, and whether it reasons, which adds the reasoning allowance. */
+    readonly summarizer: RouteBudget & {
+        readonly reasons: boolean;
+    };
+    readonly budgets: PlanBudgets;
+    /**
+     * What a plan must fit when nothing fits under the threshold less the reply reserve. `threshold`,
+     * for pressure: under the window less the reserve only when another segment remains for the next
+     * step to take. `window`, for an overflow or a request, which no later pressure check finishes:
+     * under the window less the reserve, whatever remains.
+     */
+    readonly acceptance: 'threshold' | 'window';
+};
+/** A span to replace with a checkpoint, and what the replacement is estimated to leave. */
+export type CompactionPlan = {
+    readonly kind: 'plan';
+    /** The span: `entries[start]` up to, not including, `entries[end]`. */
+    readonly start: number;
+    readonly end: number;
+    /** How many leading entries are the pinned opening, which no span touches. */
+    readonly pinned: number;
+    /**
+     * The most the summary may come to, in generation tokens: the `maxOutputTokens` before the
+     * allowance, and what the plan priced the summary at in the checkpoint. The recorded stand-in is
+     * estimated from its characters and may differ by the tokenizer's ratio, which the reserve absorbs.
+     */
+    readonly summaryCap: number;
+    /** Whether the span holds the person's latest input, which the checkpoint then copies. */
+    readonly copiesInput: boolean;
+    /** The span's estimate, scaled. */
+    readonly spanTokens: number;
+    /**
+     * The request after the replacement as the next step will price it, the checkpoint's summary at
+     * its cap at the written scale, without the reply reserve.
+     */
+    readonly continuation: number;
+    /** The summary call, scaled, with its whole generation reserve. */
+    readonly summaryCall: number;
+    /** Whether the continuation and its reply reserve fit under the target; `null` on a route with no window. */
+    readonly targetReached: boolean | null;
+    /** Which segment, counting from the oldest, of how many. */
+    readonly segment: {
+        readonly index: number;
+        readonly count: number;
+    };
+};
+/** Why no span is worth replacing; every room is judged against the summary floor. */
+export type NoPlanCause = 
+/** No segment has a balanced span that keeps the newest message, or holds more than written text. */
+'nothing-to-replace'
+/** No span's summary call leaves room for the floor in the summarizer's window. */
+ | 'summary-call-too-large'
+/** No span leaves room for the floor under the continuation's ceiling, its reply reserve counted. */
+ | 'continuation-too-large'
+/**
+ * Some span leaves room for the floor under both budgets, but not under the reduction it must
+ * make, its checkpoint and re-told notices counted: nothing is worth doing.
+ */
+ | 'no-reduction'
+/**
+ * Each budget alone admits some span, but no span fits both: the summary call fits only spans
+ * too short to leave the continuation room.
+ */
+ | 'no-span-fits-both';
+/** No plan: why, as a cause a strategy can act on and a reason a person can read. */
+export type NoPlan = {
+    readonly kind: 'none';
+    readonly cause: NoPlanCause;
+    readonly reason: string;
+};
+/** What `planCompaction` answers: a plan, or why there is none. */
+export type PlanOutcome = CompactionPlan | NoPlan;
+/**
+ * Plans one compaction: which balanced span to replace with a checkpoint, and how long the summary
+ * in it may be, so that both the summary call and the request after it fit; or why none can.
+ *
+ * - **The opening is pinned**: every message through the first unsourced `user` input, when together
+ *   they fit the opening budget, is never in a span.
+ * - **Direct developer inputs divide segments**, each compacted on its own. An earlier segment is
+ *   replaced whole; only the last keeps a tail, which keeps the newest message.
+ * - **Retention proposes the cut**: walking back from the newest message until the tail reaches the
+ *   tail budget, then widening it to a balanced cut.
+ * - **Two budgets settle it.** The summary call (the head, the surface through the end of the span,
+ *   the instruction and the generation reserve) must fit the summarizer's window; the continuation
+ *   (the head, the surface as the replacement leaves it, the checkpoint at its cap, the notices the
+ *   span makes plugins tell again and the claimed input) must stay under the acceptance ceiling:
+ *   the threshold less the reply reserve, or, when nothing fits that, the window less it as
+ *   `acceptance` allows. The summary cap is the configured cap, lowered to what both leave and to
+ *   what the reduction leaves, the checkpoint and its re-tells within the configured ratio of the
+ *   span; a candidate whose cap ends below the summary floor is discarded.
+ * - **Feasibility first, then the target.** Among feasible candidates, those that bring the
+ *   continuation and its reply reserve under the target come first, and in the last segment the one
+ *   nearest the retention cut, the larger tail on a tie; with none, the largest reduction. Across
+ *   segments, a candidate reaching the target first, then the largest reduction.
+ *
+ * On a route with no window the opening and tail budgets are the configured absolute ones, nothing
+ * has a ceiling, and every feasible candidate counts as aimed: the outcome is a reduction, not a fit.
+ */
+export declare function planCompaction(input: PlannerInput): PlanOutcome;
+/**
+ * The size of the request about to be sent on `route`, priced as the planner prices a
+ * continuation: the head, the surface and the claimed input, each at its scale. One computation, so
+ * a pressure check after a replacement prices the rows that survived it as the plan did.
+ */
+export declare function estimateRequest(input: {
+    readonly entries: readonly PricedEntry[];
+    readonly head: number;
+    readonly claimed: number;
+    readonly route: RouteBudget;
+}): number;
+/**
+ * The calibration factor after a request the provider refused as longer than its `window`: that
+ * request was at least the window, so the estimated part of it was low by at least the window, less
+ * any measured part, over that estimate. Never below one, and never below `previous`, the factor in
+ * force, until a usage anchor replaces it: a request sent already estimated above the window proves
+ * nothing about the estimator, and a factor below one would make a recovery less careful than the
+ * attempt. No count is ever read from the provider's message; this bound is the measurement.
+ */
+export declare function calibrate(previous: number, window: number, failed: {
+    readonly measuredTokens: number | null;
+    readonly estimated: number;
+}): number;

package/dist/plugins/compaction/preset.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The compaction plugin, a `thread` preset with two placements, which keeps a thread's surface
+ * within its route's window by the strategy its configuration names. Mounted on the root for an
+ * agent selector, `mountPreset(root, compaction, config, { agents })`, it serves every thread whose
+ * agent `agents` selects: each matching activation gets its own strategy, provided in the thread's
+ * scope, until the mount is disposed. Installed on one thread through the presets service, it
+ * serves that thread, recorded so a reopen and a fork keep it.
+ *
+ * Both strategies act on three triggers: **pressure**, before every model step whose request is
+ * estimated above `threshold` of the window (a route whose provider declares no window is never
+ * compacted for pressure, which is reported once per route); **overflow**, when the provider
+ * refuses a step's request as too long, after which the step is asked again if anything was
+ * replaced; and **request**, `thread.compact()`, whatever the pressure.
+ *
+ * - **`summarize`**, the default. It replaces one span, after the pinned opening and between direct
+ *   developer inputs, with one `user` checkpoint: notes a summary call wrote from the surface
+ *   through the span, the person's latest input copied from its row when the span held it, and a
+ *   footer naming the messages replaced. It measures from the last usage the provider reported on
+ *   the same provider and model plus an estimate of what came since, calibrates its estimates by
+ *   an overflow, and recovers once per overflow sequence: a new turn or a completed reply allows
+ *   another. Three unusable summaries in a row stop pressure compaction until its next
+ *   checkpoint or a change of the thread's configuration; the count is recorded, so a reopen and a
+ *   fork keep it. On request, `options` may say what the summary should `focus` on.
+ * - **`prune`**. It rewrites old tool results in place, keeping each one's role and call id, to a
+ *   one-line stand-in, `[tool result pruned: <tool>, <n> characters and <k> attachments; message
+ *   <number>]`, the attachments named only when it had some, followed by where to read it back when
+ *   the agent has both `historyRecall` tools; no model is called. A result is pruned when it is an
+ *   original, never a stand-in, outside the `keepRecent` most recent tool results, and estimated at
+ *   `minTokens` or more, images and files included; every such result goes in one atomic group.
+ *   Pressure is estimated by characters, uncalibrated. Nothing eligible is `skipped`, reported once
+ *   per activation, trigger, route and latest replacement on pressure and overflow. It takes no
+ *   request options and ignores any.
+ *
+ * Plugins whose notices a replacement took away tell them again at the next model step.
+ *
+ * Disposing a root mount stops new dispatches on the threads it serves, live ones included; a
+ * dispatch already in flight finishes, and may still record its replacement. A mount added later
+ * reaches activations from then on, not threads already live: they get it at their next activation.
+ *
+ * A thread runs one strategy, and a second on it, from another mount of this plugin or any other
+ * strategy that claims its thread, is refused when the thread activates, naming the one already
+ * there. To choose per agent, mount this on the root more than once with disjoint selectors and the
+ * strategy each should run; to choose per thread, mount none on the root and install it on each
+ * thread instead.
+ *
+ * ```ts
+ * await mountPreset(root, compaction, {}, { agents: ['main'] }) // summarize, with every default
+ * await mountPreset(root, compaction, { strategy: { kind: 'prune', keepRecent: 4 } }, { agents: ['worker'] })
+ * ```
+ */
+export declare const compaction: import("../../services/preset.js").Preset<import("zod").ZodObject<{
+    threshold: import("zod").ZodDefault<import("zod").ZodNumber>;
+    strategy: import("zod").ZodPrefault<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"summarize">;
+        target: import("zod").ZodDefault<import("zod").ZodNumber>;
+        tail: import("zod").ZodDefault<import("zod").ZodNumber>;
+        opening: import("zod").ZodDefault<import("zod").ZodNumber>;
+        summaryCap: import("zod").ZodDefault<import("zod").ZodNumber>;
+        summaryFloor: import("zod").ZodDefault<import("zod").ZodNumber>;
+        reasoningAllowance: import("zod").ZodDefault<import("zod").ZodNumber>;
+        replyReserve: import("zod").ZodDefault<import("zod").ZodNumber>;
+        checkpointRatio: import("zod").ZodDefault<import("zod").ZodNumber>;
+        copiedInputChars: import("zod").ZodDefault<import("zod").ZodNumber>;
+        boundaryQuoteChars: import("zod").ZodDefault<import("zod").ZodNumber>;
+        breaker: import("zod").ZodDefault<import("zod").ZodNumber>;
+        withoutWindow: import("zod").ZodDefault<import("zod").ZodObject<{
+            tailTokens: import("zod").ZodDefault<import("zod").ZodNumber>;
+            openingTokens: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strict>>;
+        summarizer: import("zod").ZodDefault<import("zod").ZodObject<{
+            provider: import("zod").ZodOptional<import("zod").ZodString>;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+            thinkingEffort: import("zod").ZodDefault<import("zod").ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"prune">;
+        keepRecent: import("zod").ZodDefault<import("zod").ZodNumber>;
+        minTokens: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strict>], "kind">>;
+}, import("zod/v4/core").$strict>>;

package/dist/plugins/compaction/prune.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from '@leuduan/cordis';
+import type { PruneStrategyConfig, StrategyOptions } from './config.js';
+/**
+ * The `prune` strategy on one thread, provided from the thread's own scope; a second strategy on the
+ * thread, this one again or another, is refused, the later of the two. It rewrites old tool results to a one-line stand-in and calls no
+ * model, the read-time counterpart of `truncateToolOutput`. Its reports last one activation;
+ * everything it decides from is the surface.
+ */
+export declare const pruneStrategy: Plugin.Object<StrategyOptions<PruneStrategyConfig>>;