@chatcode/chatcode-cli 3.0.2-rc.4 → 3.0.2-rc.5

package/runtime/node_modules/@deepseek-ai/dsh-compaction-basic/lib/index.js

@@ -233,6 +233,32 @@ function assertRatio(name, value) {
 /** Tags wrapping the structured summary inside the landed checkpoint node. */
 const SUMMARY_OPEN_TAG = "<compacted-summary>";
 const SUMMARY_CLOSE_TAG = "</compacted-summary>";
+/** Smallest checkpoint body that satisfies the summarizer's required section structure. */
+const MINIMUM_SUMMARY_TEXT = [
+	"## Primary Request and Intent",
+	"- (none)",
+	"",
+	"## Key Technical Concepts",
+	"- (none)",
+	"",
+	"## Files and Code",
+	"- (none)",
+	"",
+	"## Errors and Fixes",
+	"- (none)",
+	"",
+	"## Pending Jobs",
+	"- (none)",
+	"",
+	"## Current Work",
+	"- (none)",
+	"",
+	"## Next Step",
+	"- (none)",
+	"",
+	"## Critical Context",
+	"- (none)"
+].join("\n");
 /**
 * The summarization directive, delivered as the FINAL user message after the
 * replayed conversation rather than as a distinct summarizer system prompt.
@@ -301,12 +327,14 @@ async function summarizeWithLlm(ctx, config, input, agent, signal) {
 	} : void 0;
 	const target = configured ?? latest ?? agentTarget;
 	if (target === void 0) throw new Error("no provider/model available for summarization: set both BasicCompactionConfig summarization fields, route one request, or set both AgentOptions fields");
+	const modelInfo = await ctx.llm.resolveModelInfo(target.provider, target.model, signal);
+	const maxTokens = modelInfo.defaultMaxTokens === void 0 ? config.maxTokens : Math.min(config.maxTokens, modelInfo.defaultMaxTokens);
 	const assembler = new BlockAssembler();
 	const messages = [...input.messages, deepFreeze({
 		role: "user",
 		content: [{
 			type: "text",
-			text: COMPACTION_INSTRUCTION
+			text: compactionInstruction(input.summaryTokenBudget)
 		}]
 	})];
 	const options = {
@@ -315,7 +343,7 @@ async function summarizeWithLlm(ctx, config, input, agent, signal) {
 		messages,
 		toolHistory: agent.session.toolHistory(),
 		...input.tools === void 0 ? {} : { tools: [...input.tools] },
-		maxTokens: config.maxTokens,
+		maxTokens,
 		sessionId: agent.session.id,
 		purpose: "compaction",
 		...signal === void 0 ? {} : { signal }
@@ -332,7 +360,7 @@ async function summarizeWithLlm(ctx, config, input, agent, signal) {
 		llmStreamCall: true,
 		provider: options.provider,
 		model: options.model,
-		maxTokens: config.maxTokens,
+		maxTokens,
 		...assembler.usage === void 0 ? {} : { usage: assembler.usage }
 	};
 }
@@ -354,6 +382,21 @@ function frameSummary(summary) {
 		}
 	];
 }
+/**
+* Return the smallest body allowed by the structured-summary instruction.
+* @returns one fresh text block containing every required section.
+*/
+function minimumSummaryContent() {
+	return [{
+		type: "text",
+		text: MINIMUM_SUMMARY_TEXT
+	}];
+}
+/** Add the selected region's strict shrink budget to the model instruction. */
+function compactionInstruction(summaryTokenBudget) {
+	if (summaryTokenBudget === void 0) return COMPACTION_INSTRUCTION;
+	return `${COMPACTION_INSTRUCTION}\n- Keep the complete checkpoint body under ${summaryTokenBudget} estimated tokens. When space is tight, prioritize current work, the next step, constraints, and exact identifiers.`;
+}
 /** Map a terminal summarization finish to its fail-closed error. */
 function finishError(finish) {
 	switch (finish.kind) {
@@ -475,7 +518,7 @@ async function compactSurfaceRegion(dependencies, session, start, end, agent, op
 	let closing = false;
 	let stage = "summary";
 	try {
-		const summarized = await summarizeCompaction(dependencies, prepareCompaction(dependencies, session, selection), agent, compactionId, options.sourceCommandId, assertStable, signal);
+		const summarized = await summarizeCompaction(dependencies, prepareCompaction(dependencies.meter, session, selection), agent, compactionId, options.sourceCommandId, assertStable, signal);
 		if (options.owner === null) signal?.throwIfAborted();
 		assertStable(dependencies, session, summarized);
 		stage = "commit";
@@ -565,8 +608,8 @@ function validateSurfaceRegion(session, start, end) {
 	};
 }
 /** Snapshot pricing and replay input for a validated surface range. */
-function prepareCompaction(dependencies, session, selection) {
-	const measurement = dependencies.meter.measure(session);
+function prepareCompaction(meter, session, selection) {
+	const measurement = meter.measure(session);
 	const selectedNodes = measurement.nodes.slice(selection.startIdx, selection.endIdx + 1);
 	if (selectedNodes.length !== selection.shadowedSeqs.length || selectedNodes.some((node, index) => node.seq !== selection.shadowedSeqs[index])) throw new SurfaceChangedError("compaction: selected surface changed before summarization began");
 	return {
@@ -578,19 +621,50 @@ function prepareCompaction(dependencies, session, selection) {
 		input: buildSummarizationInput(session, selection.shadowedSeqs)
 	};
 }
+/** Price a framed checkpoint carrying the supplied summary body. */
+function framedSummaryTokenCount(meter, summary) {
+	return meter.estimateMessage(createUserMessage({
+		content: frameSummary(summary),
+		source: { kind: "user" }
+	}));
+}
+/** Maximum summary-body tokens that keep the framed checkpoint strictly smaller than the selected source. */
+function summaryTokenBudget(meter, shadowedRouteTokenCount) {
+	return shadowedRouteTokenCount - framedSummaryTokenCount(meter, [{
+		type: "text",
+		text: ""
+	}]) - 1;
+}
+/**
+* Determine whether the selected source can fit the minimum structured checkpoint with a strict token reduction.
+* @param meter - token meter that priced the selected conversation route.
+* @param session - session supplying the current surface.
+* @param start - inclusive first surface-node seq.
+* @param end - inclusive last surface-node seq.
+* @returns `true` when the minimum valid framed checkpoint is smaller than the selected source.
+*/
+function canCompactSurfaceRegion(meter, session, start, end) {
+	const prepared = prepareCompaction(meter, session, validateSurfaceRegion(session, start, end));
+	return framedSummaryTokenCount(meter, minimumSummaryContent()) < prepared.shadowedRouteTokenCount;
+}
 /** Run the summarizer and frame its replacement checkpoint. */
 async function summarizeCompaction(dependencies, prepared, agent, compactionId, sourceCommandId, assertStable, signal) {
 	let summaryResult;
 	for (;;) {
 		signal?.throwIfAborted();
 		try {
-			summaryResult = await dependencies.summarize(prepared.input, agent, signal);
+			const budget = summaryTokenBudget(dependencies.meter, prepared.shadowedRouteTokenCount);
+			if (budget < 1) throw new Error("selected content is too small to fit a smaller framed summary");
+			summaryResult = await dependencies.summarize({
+				...prepared.input,
+				summaryTokenBudget: budget
+			}, agent, signal);
 			break;
 		} catch (error) {
 			if (signal?.aborted === true) throw error;
 			assertStable(dependencies, agent.session, prepared);
 			if (!dependencies.recover(error, agent, prepared.shadowedSeqs, signal)) throw error;
-			prepared = prepareCompaction(dependencies, agent.session, validateSurfaceRegion(agent.session, prepared.start, prepared.end));
+			prepared = prepareCompaction(dependencies.meter, agent.session, validateSurfaceRegion(agent.session, prepared.start, prepared.end));
 		}
 	}
 	const checkpointMessage = createUserMessage({
@@ -989,8 +1063,10 @@ var BasicCompactionEngine = class extends CompactionEngine {
 				const operationSignal = AbortSignal.any([agentSignal, signal]);
 				try {
 					operationSignal.throwIfAborted();
+					assertNoActiveCompaction(agent.session, "manual compaction");
 					const range = selectCompactableRange(agent.session, this.ctx.tokenMeter.measure(agent.session), 0);
 					if (range === null) return null;
+					if (!canCompactSurfaceRegion(this.ctx.tokenMeter, agent.session, range.start, range.end)) return null;
 					return await compactSurfaceRegion(this.regionDependencies(), agent.session, range.start, range.end, agent, {
 						owner: null,
 						stability: "selected-span",

package/runtime/node_modules/@deepseek-ai/dsh-compaction-basic/lib/types/region.d.ts

@@ -62,5 +62,14 @@ export declare function compactSurfaceRegion(dependencies: RegionDependencies, s
  * @param stage - operation label included in the busy diagnostic.
  */
 export declare function assertNoActiveCompaction(session: Session, stage: string): void;
+/**
+ * Determine whether the selected source can fit the minimum structured checkpoint with a strict token reduction.
+ * @param meter - token meter that priced the selected conversation route.
+ * @param session - session supplying the current surface.
+ * @param start - inclusive first surface-node seq.
+ * @param end - inclusive last surface-node seq.
+ * @returns `true` when the minimum valid framed checkpoint is smaller than the selected source.
+ */
+export declare function canCompactSurfaceRegion(meter: TokenMeter, session: Session, start: SessionSeq, end: SessionSeq): boolean;
 export {};
 //# sourceMappingURL=region.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-compaction-basic/lib/types/summarizer.d.ts

@@ -22,6 +22,8 @@ export interface SummarizationInput {
     readonly tools?: readonly ToolSchema[];
     /** The derived system head, when present, followed by the shadowed region in surface order. */
     readonly messages: readonly Message[];
+    /** Maximum estimated tokens available to the returned summary text while keeping the framed checkpoint smaller than its source. */
+    readonly summaryTokenBudget?: number;
 }
 /** Safe summary content plus the exact auxiliary call envelope recorded with it. */
 export type SummaryResult = {
@@ -60,5 +62,10 @@ export declare function summarizeWithLlm(ctx: Context, config: SummaryConfig, in
  * @returns content for the synthesized replacement user message.
  */
 export declare function frameSummary(summary: readonly ContentBlock[]): ContentBlock[];
+/**
+ * Return the smallest body allowed by the structured-summary instruction.
+ * @returns one fresh text block containing every required section.
+ */
+export declare function minimumSummaryContent(): ContentBlock[];
 export {};
 //# sourceMappingURL=summarizer.d.ts.map