@listdoing/core 0.1.3 → 0.1.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.mts +49 -14
- package/dist/index.d.ts +49 -14
- package/dist/index.js +219 -25
- package/dist/index.mjs +219 -25
- package/package.json +1 -1
package/dist/index.d.mts
CHANGED
|
@@ -496,6 +496,12 @@ type StreamEvent = {
|
|
|
496
496
|
type: 'graph:failed';
|
|
497
497
|
plan: GraphPlan;
|
|
498
498
|
failedNodes: string[];
|
|
499
|
+
} | {
|
|
500
|
+
type: 'context:compressed';
|
|
501
|
+
sessionId: string;
|
|
502
|
+
beforeTokens: number;
|
|
503
|
+
afterTokens: number;
|
|
504
|
+
reason: 'auto' | 'manual';
|
|
499
505
|
} | {
|
|
500
506
|
type: 'done';
|
|
501
507
|
reply: string;
|
|
@@ -543,8 +549,10 @@ interface ContextConfig {
|
|
|
543
549
|
outputReserve?: number;
|
|
544
550
|
autoCompress?: boolean;
|
|
545
551
|
compressThreshold?: number;
|
|
552
|
+
/** When true (default) and a summarizer is available, use LLM-based semantic summarization. */
|
|
553
|
+
useLLMSummary?: boolean;
|
|
546
554
|
historyStrategy?: {
|
|
547
|
-
type: 'sliding_window' | 'token_budget' | 'relevance' | 'summary' | 'hybrid';
|
|
555
|
+
type: 'sliding_window' | 'token_budget' | 'relevance' | 'summary' | 'hybrid' | 'llm_summary';
|
|
548
556
|
rules?: any[];
|
|
549
557
|
};
|
|
550
558
|
syncToServer?: boolean;
|
|
@@ -896,17 +904,40 @@ declare class SessionManager {
|
|
|
896
904
|
private createSummary;
|
|
897
905
|
}
|
|
898
906
|
|
|
907
|
+
/**
|
|
908
|
+
* A summarizer produces a compact semantic summary of a set of messages.
|
|
909
|
+
* Used by ContextManager to replace mechanical truncation with LLM-based
|
|
910
|
+
* summarization (Claude Code style auto-compact).
|
|
911
|
+
*/
|
|
912
|
+
type SummarizerFn = (messages: Message[], opts?: {
|
|
913
|
+
signal?: AbortSignal;
|
|
914
|
+
}) => Promise<string>;
|
|
915
|
+
|
|
899
916
|
interface BuildWindowResult {
|
|
900
917
|
messages: Message[];
|
|
901
918
|
usedTokens: number;
|
|
902
919
|
budget: number;
|
|
903
920
|
}
|
|
921
|
+
interface CompressResult {
|
|
922
|
+
messages: Message[];
|
|
923
|
+
beforeTokens: number;
|
|
924
|
+
afterTokens: number;
|
|
925
|
+
}
|
|
926
|
+
interface EnsureContextFitsResult {
|
|
927
|
+
messages: Message[];
|
|
928
|
+
wasCompressed: boolean;
|
|
929
|
+
beforeTokens?: number;
|
|
930
|
+
afterTokens?: number;
|
|
931
|
+
}
|
|
904
932
|
declare class ContextManager {
|
|
905
933
|
private config;
|
|
906
934
|
private model;
|
|
935
|
+
private summarizer?;
|
|
907
936
|
constructor(config?: ContextConfig, model?: string);
|
|
908
937
|
/** Update model (called when LLM config changes) */
|
|
909
938
|
setModel(model: string): void;
|
|
939
|
+
/** Inject an LLM-based summarizer. When set, auto-compression uses semantic summarization. */
|
|
940
|
+
setSummarizer(fn?: SummarizerFn): void;
|
|
910
941
|
/** Compute the token budget for the current model & config */
|
|
911
942
|
getBudget(): number;
|
|
912
943
|
/**
|
|
@@ -917,20 +948,24 @@ declare class ContextManager {
|
|
|
917
948
|
buildWindow(messages: Message[], systemPrompt?: string, tools?: ToolDef[], maxTokens?: number): BuildWindowResult;
|
|
918
949
|
/**
|
|
919
950
|
* Ensure context fits within budget. Triggers auto-compression when
|
|
920
|
-
* usage exceeds the configured threshold.
|
|
951
|
+
* usage exceeds the configured threshold. Prefers LLM-based semantic
|
|
952
|
+
* summarization (when a summarizer is set and enabled) over mechanical truncation.
|
|
921
953
|
*/
|
|
922
|
-
ensureContextFits(messages: Message[], systemPrompt: string | undefined, tools: ToolDef[], model?: string):
|
|
923
|
-
messages: Message[];
|
|
924
|
-
wasCompressed: boolean;
|
|
925
|
-
};
|
|
954
|
+
ensureContextFits(messages: Message[], systemPrompt: string | undefined, tools: ToolDef[], model?: string, signal?: AbortSignal): Promise<EnsureContextFitsResult>;
|
|
926
955
|
/**
|
|
927
|
-
* Compress context by summarizing older messages.
|
|
956
|
+
* Compress context by summarizing older messages. When strategy is
|
|
957
|
+
* 'llm_summary' (or resolved via config) it uses the injected summarizer,
|
|
958
|
+
* falling back to mechanical 'hybrid' truncation on failure.
|
|
928
959
|
*/
|
|
929
|
-
compress(messages: Message[], strategy?: 'sliding_window' | 'token_budget' | 'summary' | 'hybrid'):
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
960
|
+
compress(messages: Message[], strategy?: 'sliding_window' | 'token_budget' | 'summary' | 'hybrid' | 'llm_summary'): Promise<CompressResult>;
|
|
961
|
+
/** Mechanical (non-LLM) compression — the original truncation strategies. */
|
|
962
|
+
private compressSync;
|
|
963
|
+
/**
|
|
964
|
+
* LLM-based semantic summarization. Returns null when it cannot be performed
|
|
965
|
+
* (no summarizer, nothing to summarize, or the LLM call fails) so callers can
|
|
966
|
+
* fall back to mechanical compression.
|
|
967
|
+
*/
|
|
968
|
+
private compressWithLLM;
|
|
934
969
|
/**
|
|
935
970
|
* Search across messages for relevant content.
|
|
936
971
|
*/
|
|
@@ -1148,11 +1183,11 @@ declare class Ldoing {
|
|
|
1148
1183
|
content: string;
|
|
1149
1184
|
source: string;
|
|
1150
1185
|
}[];
|
|
1151
|
-
compressContext(sessionId: string, strategy?: 'sliding_window' | 'token_budget' | 'summary' | 'hybrid'): {
|
|
1186
|
+
compressContext(sessionId: string, strategy?: 'sliding_window' | 'token_budget' | 'summary' | 'hybrid' | 'llm_summary'): Promise<{
|
|
1152
1187
|
beforeTokens: number;
|
|
1153
1188
|
afterTokens: number;
|
|
1154
1189
|
compressionRatio: number;
|
|
1155
|
-
}
|
|
1190
|
+
}>;
|
|
1156
1191
|
configure(config: Partial<LdoingConfig>): void;
|
|
1157
1192
|
on(event: string, handler: EventHandler): void;
|
|
1158
1193
|
off(event: string, handler: EventHandler): void;
|
package/dist/index.d.ts
CHANGED
|
@@ -496,6 +496,12 @@ type StreamEvent = {
|
|
|
496
496
|
type: 'graph:failed';
|
|
497
497
|
plan: GraphPlan;
|
|
498
498
|
failedNodes: string[];
|
|
499
|
+
} | {
|
|
500
|
+
type: 'context:compressed';
|
|
501
|
+
sessionId: string;
|
|
502
|
+
beforeTokens: number;
|
|
503
|
+
afterTokens: number;
|
|
504
|
+
reason: 'auto' | 'manual';
|
|
499
505
|
} | {
|
|
500
506
|
type: 'done';
|
|
501
507
|
reply: string;
|
|
@@ -543,8 +549,10 @@ interface ContextConfig {
|
|
|
543
549
|
outputReserve?: number;
|
|
544
550
|
autoCompress?: boolean;
|
|
545
551
|
compressThreshold?: number;
|
|
552
|
+
/** When true (default) and a summarizer is available, use LLM-based semantic summarization. */
|
|
553
|
+
useLLMSummary?: boolean;
|
|
546
554
|
historyStrategy?: {
|
|
547
|
-
type: 'sliding_window' | 'token_budget' | 'relevance' | 'summary' | 'hybrid';
|
|
555
|
+
type: 'sliding_window' | 'token_budget' | 'relevance' | 'summary' | 'hybrid' | 'llm_summary';
|
|
548
556
|
rules?: any[];
|
|
549
557
|
};
|
|
550
558
|
syncToServer?: boolean;
|
|
@@ -896,17 +904,40 @@ declare class SessionManager {
|
|
|
896
904
|
private createSummary;
|
|
897
905
|
}
|
|
898
906
|
|
|
907
|
+
/**
|
|
908
|
+
* A summarizer produces a compact semantic summary of a set of messages.
|
|
909
|
+
* Used by ContextManager to replace mechanical truncation with LLM-based
|
|
910
|
+
* summarization (Claude Code style auto-compact).
|
|
911
|
+
*/
|
|
912
|
+
type SummarizerFn = (messages: Message[], opts?: {
|
|
913
|
+
signal?: AbortSignal;
|
|
914
|
+
}) => Promise<string>;
|
|
915
|
+
|
|
899
916
|
interface BuildWindowResult {
|
|
900
917
|
messages: Message[];
|
|
901
918
|
usedTokens: number;
|
|
902
919
|
budget: number;
|
|
903
920
|
}
|
|
921
|
+
interface CompressResult {
|
|
922
|
+
messages: Message[];
|
|
923
|
+
beforeTokens: number;
|
|
924
|
+
afterTokens: number;
|
|
925
|
+
}
|
|
926
|
+
interface EnsureContextFitsResult {
|
|
927
|
+
messages: Message[];
|
|
928
|
+
wasCompressed: boolean;
|
|
929
|
+
beforeTokens?: number;
|
|
930
|
+
afterTokens?: number;
|
|
931
|
+
}
|
|
904
932
|
declare class ContextManager {
|
|
905
933
|
private config;
|
|
906
934
|
private model;
|
|
935
|
+
private summarizer?;
|
|
907
936
|
constructor(config?: ContextConfig, model?: string);
|
|
908
937
|
/** Update model (called when LLM config changes) */
|
|
909
938
|
setModel(model: string): void;
|
|
939
|
+
/** Inject an LLM-based summarizer. When set, auto-compression uses semantic summarization. */
|
|
940
|
+
setSummarizer(fn?: SummarizerFn): void;
|
|
910
941
|
/** Compute the token budget for the current model & config */
|
|
911
942
|
getBudget(): number;
|
|
912
943
|
/**
|
|
@@ -917,20 +948,24 @@ declare class ContextManager {
|
|
|
917
948
|
buildWindow(messages: Message[], systemPrompt?: string, tools?: ToolDef[], maxTokens?: number): BuildWindowResult;
|
|
918
949
|
/**
|
|
919
950
|
* Ensure context fits within budget. Triggers auto-compression when
|
|
920
|
-
* usage exceeds the configured threshold.
|
|
951
|
+
* usage exceeds the configured threshold. Prefers LLM-based semantic
|
|
952
|
+
* summarization (when a summarizer is set and enabled) over mechanical truncation.
|
|
921
953
|
*/
|
|
922
|
-
ensureContextFits(messages: Message[], systemPrompt: string | undefined, tools: ToolDef[], model?: string):
|
|
923
|
-
messages: Message[];
|
|
924
|
-
wasCompressed: boolean;
|
|
925
|
-
};
|
|
954
|
+
ensureContextFits(messages: Message[], systemPrompt: string | undefined, tools: ToolDef[], model?: string, signal?: AbortSignal): Promise<EnsureContextFitsResult>;
|
|
926
955
|
/**
|
|
927
|
-
* Compress context by summarizing older messages.
|
|
956
|
+
* Compress context by summarizing older messages. When strategy is
|
|
957
|
+
* 'llm_summary' (or resolved via config) it uses the injected summarizer,
|
|
958
|
+
* falling back to mechanical 'hybrid' truncation on failure.
|
|
928
959
|
*/
|
|
929
|
-
compress(messages: Message[], strategy?: 'sliding_window' | 'token_budget' | 'summary' | 'hybrid'):
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
960
|
+
compress(messages: Message[], strategy?: 'sliding_window' | 'token_budget' | 'summary' | 'hybrid' | 'llm_summary'): Promise<CompressResult>;
|
|
961
|
+
/** Mechanical (non-LLM) compression — the original truncation strategies. */
|
|
962
|
+
private compressSync;
|
|
963
|
+
/**
|
|
964
|
+
* LLM-based semantic summarization. Returns null when it cannot be performed
|
|
965
|
+
* (no summarizer, nothing to summarize, or the LLM call fails) so callers can
|
|
966
|
+
* fall back to mechanical compression.
|
|
967
|
+
*/
|
|
968
|
+
private compressWithLLM;
|
|
934
969
|
/**
|
|
935
970
|
* Search across messages for relevant content.
|
|
936
971
|
*/
|
|
@@ -1148,11 +1183,11 @@ declare class Ldoing {
|
|
|
1148
1183
|
content: string;
|
|
1149
1184
|
source: string;
|
|
1150
1185
|
}[];
|
|
1151
|
-
compressContext(sessionId: string, strategy?: 'sliding_window' | 'token_budget' | 'summary' | 'hybrid'): {
|
|
1186
|
+
compressContext(sessionId: string, strategy?: 'sliding_window' | 'token_budget' | 'summary' | 'hybrid' | 'llm_summary'): Promise<{
|
|
1152
1187
|
beforeTokens: number;
|
|
1153
1188
|
afterTokens: number;
|
|
1154
1189
|
compressionRatio: number;
|
|
1155
|
-
}
|
|
1190
|
+
}>;
|
|
1156
1191
|
configure(config: Partial<LdoingConfig>): void;
|
|
1157
1192
|
on(event: string, handler: EventHandler): void;
|
|
1158
1193
|
off(event: string, handler: EventHandler): void;
|
package/dist/index.js
CHANGED
|
@@ -1153,6 +1153,10 @@ var ContextManager = class {
|
|
|
1153
1153
|
setModel(model) {
|
|
1154
1154
|
this.model = model;
|
|
1155
1155
|
}
|
|
1156
|
+
/** Inject an LLM-based summarizer. When set, auto-compression uses semantic summarization. */
|
|
1157
|
+
setSummarizer(fn) {
|
|
1158
|
+
this.summarizer = fn;
|
|
1159
|
+
}
|
|
1156
1160
|
/** Compute the token budget for the current model & config */
|
|
1157
1161
|
getBudget() {
|
|
1158
1162
|
const ctxLen = resolveModelContextLength(this.model, this.config.contextLength);
|
|
@@ -1210,33 +1214,64 @@ var ContextManager = class {
|
|
|
1210
1214
|
}
|
|
1211
1215
|
/**
|
|
1212
1216
|
* Ensure context fits within budget. Triggers auto-compression when
|
|
1213
|
-
* usage exceeds the configured threshold.
|
|
1217
|
+
* usage exceeds the configured threshold. Prefers LLM-based semantic
|
|
1218
|
+
* summarization (when a summarizer is set and enabled) over mechanical truncation.
|
|
1214
1219
|
*/
|
|
1215
|
-
ensureContextFits(messages, systemPrompt, tools, model) {
|
|
1220
|
+
async ensureContextFits(messages, systemPrompt, tools, model, signal) {
|
|
1216
1221
|
if (model) this.setModel(model);
|
|
1217
1222
|
const { usedTokens, budget } = this.buildWindow(messages, systemPrompt, tools);
|
|
1218
1223
|
const threshold = this.config.compressThreshold ?? 0.85;
|
|
1219
1224
|
if (usedTokens / budget <= threshold) {
|
|
1220
1225
|
return { messages, wasCompressed: false };
|
|
1221
1226
|
}
|
|
1222
|
-
const
|
|
1223
|
-
|
|
1227
|
+
const useLLM = this.config.useLLMSummary !== false && !!this.summarizer;
|
|
1228
|
+
let result;
|
|
1229
|
+
if (useLLM) {
|
|
1230
|
+
const llmResult = await this.compressWithLLM(messages, systemPrompt, tools, budget, signal);
|
|
1231
|
+
result = llmResult ?? this.compressSync(messages, "hybrid");
|
|
1232
|
+
} else {
|
|
1233
|
+
result = this.compressSync(messages, "hybrid");
|
|
1234
|
+
}
|
|
1235
|
+
const afterCheck = this.buildWindow(result.messages, systemPrompt, tools);
|
|
1224
1236
|
if (afterCheck.usedTokens / afterCheck.budget > 1) {
|
|
1225
1237
|
console.warn(`[listdoing] Context still exceeds budget after compression (${afterCheck.usedTokens}/${afterCheck.budget} tokens). Truncating to recent messages only.`);
|
|
1226
1238
|
const truncated = messages.slice(-3);
|
|
1227
|
-
return {
|
|
1239
|
+
return {
|
|
1240
|
+
messages: truncated,
|
|
1241
|
+
wasCompressed: true,
|
|
1242
|
+
beforeTokens: result.beforeTokens,
|
|
1243
|
+
afterTokens: truncated.reduce((sum, m) => sum + estimateMessageTokens(m), 0)
|
|
1244
|
+
};
|
|
1228
1245
|
}
|
|
1229
|
-
return {
|
|
1246
|
+
return {
|
|
1247
|
+
messages: result.messages,
|
|
1248
|
+
wasCompressed: true,
|
|
1249
|
+
beforeTokens: result.beforeTokens,
|
|
1250
|
+
afterTokens: result.afterTokens
|
|
1251
|
+
};
|
|
1230
1252
|
}
|
|
1231
1253
|
/**
|
|
1232
|
-
* Compress context by summarizing older messages.
|
|
1254
|
+
* Compress context by summarizing older messages. When strategy is
|
|
1255
|
+
* 'llm_summary' (or resolved via config) it uses the injected summarizer,
|
|
1256
|
+
* falling back to mechanical 'hybrid' truncation on failure.
|
|
1233
1257
|
*/
|
|
1234
|
-
compress(messages, strategy) {
|
|
1258
|
+
async compress(messages, strategy) {
|
|
1259
|
+
const strat = strategy ?? this.config.historyStrategy?.type ?? "hybrid";
|
|
1260
|
+
if (strat === "llm_summary") {
|
|
1261
|
+
if (!this.summarizer) {
|
|
1262
|
+
return this.compressSync(messages, "hybrid");
|
|
1263
|
+
}
|
|
1264
|
+
const llmResult = await this.compressWithLLM(messages, void 0, [], this.getBudget());
|
|
1265
|
+
return llmResult ?? this.compressSync(messages, "hybrid");
|
|
1266
|
+
}
|
|
1267
|
+
return this.compressSync(messages, strat);
|
|
1268
|
+
}
|
|
1269
|
+
/** Mechanical (non-LLM) compression — the original truncation strategies. */
|
|
1270
|
+
compressSync(messages, strategy) {
|
|
1235
1271
|
const estimateTokens = (msgs) => msgs.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
|
|
1236
1272
|
const beforeTokens = estimateTokens(messages);
|
|
1237
|
-
const strat = strategy ?? this.config.historyStrategy?.type ?? "hybrid";
|
|
1238
1273
|
let compressed;
|
|
1239
|
-
switch (
|
|
1274
|
+
switch (strategy) {
|
|
1240
1275
|
case "sliding_window": {
|
|
1241
1276
|
compressed = messages.slice(-10);
|
|
1242
1277
|
break;
|
|
@@ -1285,6 +1320,53 @@ ${summaryText}` },
|
|
|
1285
1320
|
const afterTokens = estimateTokens(compressed);
|
|
1286
1321
|
return { messages: compressed, beforeTokens, afterTokens };
|
|
1287
1322
|
}
|
|
1323
|
+
/**
|
|
1324
|
+
* LLM-based semantic summarization. Returns null when it cannot be performed
|
|
1325
|
+
* (no summarizer, nothing to summarize, or the LLM call fails) so callers can
|
|
1326
|
+
* fall back to mechanical compression.
|
|
1327
|
+
*/
|
|
1328
|
+
async compressWithLLM(messages, systemPrompt, tools, budget, signal) {
|
|
1329
|
+
if (!this.summarizer) return null;
|
|
1330
|
+
try {
|
|
1331
|
+
const estimateTokens = (msgs) => msgs.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
|
|
1332
|
+
const beforeTokens = estimateTokens(messages);
|
|
1333
|
+
let fixedTokens = 0;
|
|
1334
|
+
if (systemPrompt) fixedTokens += estimateTextTokens(systemPrompt) + 4;
|
|
1335
|
+
for (const t of tools ?? []) fixedTokens += estimateToolDefTokens(t);
|
|
1336
|
+
const summaryReserve = 2e3;
|
|
1337
|
+
const outputReserve = this.config.outputReserve ?? 1024;
|
|
1338
|
+
const remaining = budget - fixedTokens - summaryReserve - outputReserve;
|
|
1339
|
+
const kept = [];
|
|
1340
|
+
let used = 0;
|
|
1341
|
+
if (remaining > 0) {
|
|
1342
|
+
for (let i = messages.length - 1; i >= 0; i--) {
|
|
1343
|
+
const t = estimateMessageTokens(messages[i]);
|
|
1344
|
+
if (used + t > remaining) break;
|
|
1345
|
+
kept.unshift(messages[i]);
|
|
1346
|
+
used += t;
|
|
1347
|
+
}
|
|
1348
|
+
}
|
|
1349
|
+
const oldMessages = messages.slice(0, messages.length - kept.length);
|
|
1350
|
+
if (oldMessages.length === 0) {
|
|
1351
|
+
return null;
|
|
1352
|
+
}
|
|
1353
|
+
const summary = await this.summarizer(oldMessages, signal ? { signal } : void 0);
|
|
1354
|
+
const summaryMessage = { role: "user", content: `[\u4E0A\u4E0B\u6587\u6458\u8981]
|
|
1355
|
+
${summary}` };
|
|
1356
|
+
let result = [summaryMessage, ...kept];
|
|
1357
|
+
let afterTokens = estimateTokens(result);
|
|
1358
|
+
while (result.length > 2 && afterTokens > budget) {
|
|
1359
|
+
const trimmed = [summaryMessage, ...result.slice(2)];
|
|
1360
|
+
if (trimmed.length === result.length) break;
|
|
1361
|
+
result = trimmed;
|
|
1362
|
+
afterTokens = estimateTokens(result);
|
|
1363
|
+
}
|
|
1364
|
+
return { messages: result, beforeTokens, afterTokens };
|
|
1365
|
+
} catch (err) {
|
|
1366
|
+
console.warn("[listdoing] LLM summarization failed, falling back to mechanical compression:", err);
|
|
1367
|
+
return null;
|
|
1368
|
+
}
|
|
1369
|
+
}
|
|
1288
1370
|
/**
|
|
1289
1371
|
* Search across messages for relevant content.
|
|
1290
1372
|
*/
|
|
@@ -1307,6 +1389,87 @@ ${summaryText}` },
|
|
|
1307
1389
|
}
|
|
1308
1390
|
};
|
|
1309
1391
|
|
|
1392
|
+
// src/context/summarizer.ts
|
|
1393
|
+
var SUMMARIZE_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u5BF9\u8BDD\u4E0A\u4E0B\u6587\u538B\u7F29\u52A9\u624B\u3002\u8BF7\u9605\u8BFB\u4E0B\u9762\u7684\u5BF9\u8BDD\u7247\u6BB5\uFF0C\u751F\u6210\u4E00\u4EFD\u7ED3\u6784\u5316\u6458\u8981\uFF0C\u7528\u4E8E\u5728\u540E\u7EED\u5BF9\u8BDD\u4E2D\u4FDD\u7559\u5173\u952E\u4E0A\u4E0B\u6587\u3002
|
|
1394
|
+
|
|
1395
|
+
\u4E25\u683C\u6309\u4EE5\u4E0B\u7ED3\u6784\u8F93\u51FA\uFF08markdown\uFF09\uFF1A
|
|
1396
|
+
|
|
1397
|
+
## \u76EE\u6807
|
|
1398
|
+
\u7528\u6237\u60F3\u8981\u5B8C\u6210\u4EC0\u4E48
|
|
1399
|
+
|
|
1400
|
+
## \u5173\u952E\u51B3\u7B56
|
|
1401
|
+
\u5DF2\u505A\u7684\u51B3\u7B56\u53CA\u5176\u7406\u7531
|
|
1402
|
+
|
|
1403
|
+
## \u6D89\u53CA\u6587\u4EF6
|
|
1404
|
+
\u521B\u5EFA/\u4FEE\u6539/\u8BFB\u53D6\u7684\u6587\u4EF6\uFF0C\u7B80\u8FF0\u5176\u5185\u5BB9\u6216\u53D8\u66F4
|
|
1405
|
+
|
|
1406
|
+
## \u91CD\u8981\u53D1\u73B0
|
|
1407
|
+
\u7EE7\u7EED\u5DE5\u4F5C\u6240\u9700\u7684\u5173\u952E\u4E8B\u5B9E\uFF08\u6587\u4EF6\u7ED3\u6784\u3001\u6570\u636E\u3001\u641C\u7D22\u7ED3\u679C\u7B49\uFF09
|
|
1408
|
+
|
|
1409
|
+
## \u5F53\u524D\u72B6\u6001
|
|
1410
|
+
\u5BF9\u8BDD\u7247\u6BB5\u7ED3\u675F\u65F6\u6B63\u5728\u505A\u4EC0\u4E48
|
|
1411
|
+
|
|
1412
|
+
## \u5F85\u529E\u4E8B\u9879
|
|
1413
|
+
\u672A\u5B8C\u6210\u7684\u4EFB\u52A1\u6216\u660E\u786E\u7684\u4E0B\u4E00\u6B65
|
|
1414
|
+
|
|
1415
|
+
\u8981\u6C42\uFF1A
|
|
1416
|
+
- \u7B80\u6D01\uFF0C\u53EA\u4FDD\u7559\u7EE7\u7EED\u5DE5\u4F5C\u5FC5\u9700\u7684\u4FE1\u606F
|
|
1417
|
+
- \u4E0D\u8981\u8F93\u51FA\u4E0E\u4E0A\u8FF0\u7ED3\u6784\u65E0\u5173\u7684\u5185\u5BB9
|
|
1418
|
+
- \u7528\u4E0E\u5BF9\u8BDD\u5185\u5BB9\u76F8\u540C\u7684\u8BED\u8A00\u8F93\u51FA
|
|
1419
|
+
|
|
1420
|
+
--- \u5F85\u538B\u7F29\u7684\u5BF9\u8BDD ---`;
|
|
1421
|
+
function truncate(s, max) {
|
|
1422
|
+
return s.length > max ? s.slice(0, max) + "\u2026" : s;
|
|
1423
|
+
}
|
|
1424
|
+
function truncateMiddle(s, head, tail) {
|
|
1425
|
+
if (s.length <= head + tail) return s;
|
|
1426
|
+
return s.slice(0, head) + `
|
|
1427
|
+
\u2026[\u4E2D\u95F4 ${s.length - head - tail} \u5B57\u7B26\u5DF2\u7701\u7565]\u2026
|
|
1428
|
+
` + s.slice(-tail);
|
|
1429
|
+
}
|
|
1430
|
+
function formatMessagesForSummary(messages) {
|
|
1431
|
+
return messages.map((m) => {
|
|
1432
|
+
if (m.role === "user") return `\u7528\u6237: ${contentToString(m.content)}`;
|
|
1433
|
+
if (m.role === "assistant") {
|
|
1434
|
+
let s = `\u52A9\u624B: ${contentToString(m.content)}`;
|
|
1435
|
+
if (m.toolCalls?.length) {
|
|
1436
|
+
s += "\n" + m.toolCalls.map((tc) => ` [\u8C03\u7528\u5DE5\u5177 ${tc.name}: ${truncate(JSON.stringify(tc.arguments), 200)}]`).join("\n");
|
|
1437
|
+
}
|
|
1438
|
+
return s;
|
|
1439
|
+
}
|
|
1440
|
+
if (m.role === "tool") {
|
|
1441
|
+
return `\u5DE5\u5177\u7ED3\u679C: ${truncateMiddle(contentToString(m.content), 500, 200)}`;
|
|
1442
|
+
}
|
|
1443
|
+
if (m.role === "system") return `\u7CFB\u7EDF: ${contentToString(m.content)}`;
|
|
1444
|
+
return "";
|
|
1445
|
+
}).filter(Boolean).join("\n\n");
|
|
1446
|
+
}
|
|
1447
|
+
function createLLMSummarizer(adapter, options) {
|
|
1448
|
+
const timeoutMs = options?.timeoutMs ?? 3e4;
|
|
1449
|
+
return async (messages, opts) => {
|
|
1450
|
+
const formatted = formatMessagesForSummary(messages);
|
|
1451
|
+
const controller = new AbortController();
|
|
1452
|
+
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
|
1453
|
+
try {
|
|
1454
|
+
const response = await adapter.chat(
|
|
1455
|
+
[
|
|
1456
|
+
{ role: "system", content: SUMMARIZE_PROMPT },
|
|
1457
|
+
{ role: "user", content: formatted }
|
|
1458
|
+
],
|
|
1459
|
+
[],
|
|
1460
|
+
{ signal: opts?.signal ?? controller.signal }
|
|
1461
|
+
);
|
|
1462
|
+
const summary = (response.content ?? "").trim();
|
|
1463
|
+
if (!summary) {
|
|
1464
|
+
throw new Error("Summarizer returned empty content");
|
|
1465
|
+
}
|
|
1466
|
+
return summary;
|
|
1467
|
+
} finally {
|
|
1468
|
+
clearTimeout(timer);
|
|
1469
|
+
}
|
|
1470
|
+
};
|
|
1471
|
+
}
|
|
1472
|
+
|
|
1310
1473
|
// src/task/planner.ts
|
|
1311
1474
|
var TaskPlanner = class {
|
|
1312
1475
|
constructor(llmAdapter) {
|
|
@@ -2448,6 +2611,7 @@ var Ldoing = class {
|
|
|
2448
2611
|
this.mcpRouter = new McpRouter();
|
|
2449
2612
|
this.sessionManager = new SessionManager();
|
|
2450
2613
|
this.contextManager = new ContextManager(config.context, config.llm.model);
|
|
2614
|
+
this.contextManager.setSummarizer(createLLMSummarizer(this.llmAdapter));
|
|
2451
2615
|
if (config.serverUrl) {
|
|
2452
2616
|
this.transport = new HttpTransport(config.serverUrl, config.authToken, config.headers);
|
|
2453
2617
|
} else {
|
|
@@ -2584,15 +2748,21 @@ var Ldoing = class {
|
|
|
2584
2748
|
for (const name of this.computeAutoApproval(tools)) {
|
|
2585
2749
|
requireApproval.add(name);
|
|
2586
2750
|
}
|
|
2587
|
-
const ctxCheck = this.contextManager.ensureContextFits(
|
|
2751
|
+
const ctxCheck = await this.contextManager.ensureContextFits(
|
|
2588
2752
|
session2.messages,
|
|
2589
2753
|
systemPrompt,
|
|
2590
2754
|
tools,
|
|
2591
|
-
this.config.llm.model
|
|
2755
|
+
this.config.llm.model,
|
|
2756
|
+
controller.signal
|
|
2592
2757
|
);
|
|
2593
2758
|
if (ctxCheck.wasCompressed) {
|
|
2594
2759
|
session2.messages = ctxCheck.messages;
|
|
2595
|
-
this.emit("context:compress", {
|
|
2760
|
+
this.emit("context:compress", {
|
|
2761
|
+
sessionId,
|
|
2762
|
+
reason: "auto",
|
|
2763
|
+
beforeTokens: ctxCheck.beforeTokens,
|
|
2764
|
+
afterTokens: ctxCheck.afterTokens
|
|
2765
|
+
});
|
|
2596
2766
|
}
|
|
2597
2767
|
const contextMessages = this.contextManager.buildWindow(
|
|
2598
2768
|
session2.messages,
|
|
@@ -2606,17 +2776,22 @@ var Ldoing = class {
|
|
|
2606
2776
|
});
|
|
2607
2777
|
} catch (err) {
|
|
2608
2778
|
if (err.code === ACPErrorCodes.CONTEXT_OVERFLOW && !retried) {
|
|
2609
|
-
this.compressContext(sessionId, "
|
|
2779
|
+
await this.compressContext(sessionId, "llm_summary");
|
|
2610
2780
|
retried = true;
|
|
2611
2781
|
turn--;
|
|
2612
2782
|
continue;
|
|
2613
2783
|
}
|
|
2614
|
-
if (err.code === ACPErrorCodes.LLM_EMPTY_RESPONSE
|
|
2784
|
+
if (err.code === ACPErrorCodes.LLM_EMPTY_RESPONSE) {
|
|
2785
|
+
if (!retried) {
|
|
2786
|
+
this.sessionManager.addMessage(sessionId, { role: "assistant", content: "." });
|
|
2787
|
+
this.sessionManager.addMessage(sessionId, { role: "user", content: "System: \u521A\u521A\u8FD4\u56DE\u4E86\u7A7A\u5185\u5BB9\uFF0C\u8BF7\u751F\u6210\u6709\u6548\u56DE\u590D\u3002" });
|
|
2788
|
+
retried = true;
|
|
2789
|
+
turn--;
|
|
2790
|
+
continue;
|
|
2791
|
+
}
|
|
2615
2792
|
this.sessionManager.addMessage(sessionId, { role: "assistant", content: "." });
|
|
2616
|
-
|
|
2617
|
-
|
|
2618
|
-
turn--;
|
|
2619
|
-
continue;
|
|
2793
|
+
continueLoop = false;
|
|
2794
|
+
break;
|
|
2620
2795
|
}
|
|
2621
2796
|
throw new ACPError(ACPErrorCodes.LLM_CALL_FAILED, `LLM call failed: ${err.message}`, { turn });
|
|
2622
2797
|
}
|
|
@@ -2711,10 +2886,28 @@ var Ldoing = class {
|
|
|
2711
2886
|
for (const name of this.computeAutoApproval(tools)) {
|
|
2712
2887
|
requireApproval.add(name);
|
|
2713
2888
|
}
|
|
2714
|
-
const ctxCheck = this.contextManager.ensureContextFits(
|
|
2889
|
+
const ctxCheck = await this.contextManager.ensureContextFits(
|
|
2890
|
+
session2.messages,
|
|
2891
|
+
systemPrompt,
|
|
2892
|
+
tools,
|
|
2893
|
+
this.config.llm.model,
|
|
2894
|
+
controller.signal
|
|
2895
|
+
);
|
|
2715
2896
|
if (ctxCheck.wasCompressed) {
|
|
2716
2897
|
session2.messages = ctxCheck.messages;
|
|
2717
|
-
this.emit("context:compress", {
|
|
2898
|
+
this.emit("context:compress", {
|
|
2899
|
+
sessionId,
|
|
2900
|
+
reason: "auto",
|
|
2901
|
+
beforeTokens: ctxCheck.beforeTokens,
|
|
2902
|
+
afterTokens: ctxCheck.afterTokens
|
|
2903
|
+
});
|
|
2904
|
+
yield {
|
|
2905
|
+
type: "context:compressed",
|
|
2906
|
+
sessionId,
|
|
2907
|
+
beforeTokens: ctxCheck.beforeTokens ?? 0,
|
|
2908
|
+
afterTokens: ctxCheck.afterTokens ?? 0,
|
|
2909
|
+
reason: "auto"
|
|
2910
|
+
};
|
|
2718
2911
|
}
|
|
2719
2912
|
const contextMessages = this.contextManager.buildWindow(session2.messages, systemPrompt, tools).messages;
|
|
2720
2913
|
let llmResponse;
|
|
@@ -2733,7 +2926,7 @@ var Ldoing = class {
|
|
|
2733
2926
|
}
|
|
2734
2927
|
} catch (err) {
|
|
2735
2928
|
if (err.code === ACPErrorCodes.CONTEXT_OVERFLOW && !retried) {
|
|
2736
|
-
this.compressContext(sessionId, "
|
|
2929
|
+
await this.compressContext(sessionId, "llm_summary");
|
|
2737
2930
|
retried = true;
|
|
2738
2931
|
turn--;
|
|
2739
2932
|
continue;
|
|
@@ -3616,13 +3809,13 @@ ${resultLines.join("\n")}` : "Graph resumed but no nodes completed successfully.
|
|
|
3616
3809
|
}
|
|
3617
3810
|
return this.contextManager.search(allMessages, query, options);
|
|
3618
3811
|
}
|
|
3619
|
-
compressContext(sessionId, strategy) {
|
|
3812
|
+
async compressContext(sessionId, strategy) {
|
|
3620
3813
|
const session = this.sessionManager.getOrThrow(sessionId);
|
|
3621
|
-
const result = this.contextManager.compress(session.messages, strategy);
|
|
3814
|
+
const result = await this.contextManager.compress(session.messages, strategy);
|
|
3622
3815
|
session.messages = result.messages;
|
|
3623
3816
|
session.tokenCount = result.afterTokens;
|
|
3624
3817
|
session.updatedAt = Date.now();
|
|
3625
|
-
this.emit("context:compress", { sessionId, beforeTokens: result.beforeTokens, afterTokens: result.afterTokens });
|
|
3818
|
+
this.emit("context:compress", { sessionId, beforeTokens: result.beforeTokens, afterTokens: result.afterTokens, reason: "manual" });
|
|
3626
3819
|
return { beforeTokens: result.beforeTokens, afterTokens: result.afterTokens, compressionRatio: result.afterTokens / (result.beforeTokens || 1) };
|
|
3627
3820
|
}
|
|
3628
3821
|
// ---- Runtime Config ----
|
|
@@ -3631,6 +3824,7 @@ ${resultLines.join("\n")}` : "Graph resumed but no nodes completed successfully.
|
|
|
3631
3824
|
Object.assign(this.config.llm, config.llm);
|
|
3632
3825
|
this.llmAdapter = new OpenAIAdapter(this.config.llm);
|
|
3633
3826
|
this.contextManager.setModel(this.config.llm.model);
|
|
3827
|
+
this.contextManager.setSummarizer(createLLMSummarizer(this.llmAdapter));
|
|
3634
3828
|
}
|
|
3635
3829
|
if (config.serverUrl) {
|
|
3636
3830
|
this.config.serverUrl = config.serverUrl;
|
package/dist/index.mjs
CHANGED
|
@@ -1093,6 +1093,10 @@ var ContextManager = class {
|
|
|
1093
1093
|
setModel(model) {
|
|
1094
1094
|
this.model = model;
|
|
1095
1095
|
}
|
|
1096
|
+
/** Inject an LLM-based summarizer. When set, auto-compression uses semantic summarization. */
|
|
1097
|
+
setSummarizer(fn) {
|
|
1098
|
+
this.summarizer = fn;
|
|
1099
|
+
}
|
|
1096
1100
|
/** Compute the token budget for the current model & config */
|
|
1097
1101
|
getBudget() {
|
|
1098
1102
|
const ctxLen = resolveModelContextLength(this.model, this.config.contextLength);
|
|
@@ -1150,33 +1154,64 @@ var ContextManager = class {
|
|
|
1150
1154
|
}
|
|
1151
1155
|
/**
|
|
1152
1156
|
* Ensure context fits within budget. Triggers auto-compression when
|
|
1153
|
-
* usage exceeds the configured threshold.
|
|
1157
|
+
* usage exceeds the configured threshold. Prefers LLM-based semantic
|
|
1158
|
+
* summarization (when a summarizer is set and enabled) over mechanical truncation.
|
|
1154
1159
|
*/
|
|
1155
|
-
ensureContextFits(messages, systemPrompt, tools, model) {
|
|
1160
|
+
async ensureContextFits(messages, systemPrompt, tools, model, signal) {
|
|
1156
1161
|
if (model) this.setModel(model);
|
|
1157
1162
|
const { usedTokens, budget } = this.buildWindow(messages, systemPrompt, tools);
|
|
1158
1163
|
const threshold = this.config.compressThreshold ?? 0.85;
|
|
1159
1164
|
if (usedTokens / budget <= threshold) {
|
|
1160
1165
|
return { messages, wasCompressed: false };
|
|
1161
1166
|
}
|
|
1162
|
-
const
|
|
1163
|
-
|
|
1167
|
+
const useLLM = this.config.useLLMSummary !== false && !!this.summarizer;
|
|
1168
|
+
let result;
|
|
1169
|
+
if (useLLM) {
|
|
1170
|
+
const llmResult = await this.compressWithLLM(messages, systemPrompt, tools, budget, signal);
|
|
1171
|
+
result = llmResult ?? this.compressSync(messages, "hybrid");
|
|
1172
|
+
} else {
|
|
1173
|
+
result = this.compressSync(messages, "hybrid");
|
|
1174
|
+
}
|
|
1175
|
+
const afterCheck = this.buildWindow(result.messages, systemPrompt, tools);
|
|
1164
1176
|
if (afterCheck.usedTokens / afterCheck.budget > 1) {
|
|
1165
1177
|
console.warn(`[listdoing] Context still exceeds budget after compression (${afterCheck.usedTokens}/${afterCheck.budget} tokens). Truncating to recent messages only.`);
|
|
1166
1178
|
const truncated = messages.slice(-3);
|
|
1167
|
-
return {
|
|
1179
|
+
return {
|
|
1180
|
+
messages: truncated,
|
|
1181
|
+
wasCompressed: true,
|
|
1182
|
+
beforeTokens: result.beforeTokens,
|
|
1183
|
+
afterTokens: truncated.reduce((sum, m) => sum + estimateMessageTokens(m), 0)
|
|
1184
|
+
};
|
|
1168
1185
|
}
|
|
1169
|
-
return {
|
|
1186
|
+
return {
|
|
1187
|
+
messages: result.messages,
|
|
1188
|
+
wasCompressed: true,
|
|
1189
|
+
beforeTokens: result.beforeTokens,
|
|
1190
|
+
afterTokens: result.afterTokens
|
|
1191
|
+
};
|
|
1170
1192
|
}
|
|
1171
1193
|
/**
|
|
1172
|
-
* Compress context by summarizing older messages.
|
|
1194
|
+
* Compress context by summarizing older messages. When strategy is
|
|
1195
|
+
* 'llm_summary' (or resolved via config) it uses the injected summarizer,
|
|
1196
|
+
* falling back to mechanical 'hybrid' truncation on failure.
|
|
1173
1197
|
*/
|
|
1174
|
-
compress(messages, strategy) {
|
|
1198
|
+
async compress(messages, strategy) {
|
|
1199
|
+
const strat = strategy ?? this.config.historyStrategy?.type ?? "hybrid";
|
|
1200
|
+
if (strat === "llm_summary") {
|
|
1201
|
+
if (!this.summarizer) {
|
|
1202
|
+
return this.compressSync(messages, "hybrid");
|
|
1203
|
+
}
|
|
1204
|
+
const llmResult = await this.compressWithLLM(messages, void 0, [], this.getBudget());
|
|
1205
|
+
return llmResult ?? this.compressSync(messages, "hybrid");
|
|
1206
|
+
}
|
|
1207
|
+
return this.compressSync(messages, strat);
|
|
1208
|
+
}
|
|
1209
|
+
/** Mechanical (non-LLM) compression — the original truncation strategies. */
|
|
1210
|
+
compressSync(messages, strategy) {
|
|
1175
1211
|
const estimateTokens = (msgs) => msgs.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
|
|
1176
1212
|
const beforeTokens = estimateTokens(messages);
|
|
1177
|
-
const strat = strategy ?? this.config.historyStrategy?.type ?? "hybrid";
|
|
1178
1213
|
let compressed;
|
|
1179
|
-
switch (
|
|
1214
|
+
switch (strategy) {
|
|
1180
1215
|
case "sliding_window": {
|
|
1181
1216
|
compressed = messages.slice(-10);
|
|
1182
1217
|
break;
|
|
@@ -1225,6 +1260,53 @@ ${summaryText}` },
|
|
|
1225
1260
|
const afterTokens = estimateTokens(compressed);
|
|
1226
1261
|
return { messages: compressed, beforeTokens, afterTokens };
|
|
1227
1262
|
}
|
|
1263
|
+
/**
|
|
1264
|
+
* LLM-based semantic summarization. Returns null when it cannot be performed
|
|
1265
|
+
* (no summarizer, nothing to summarize, or the LLM call fails) so callers can
|
|
1266
|
+
* fall back to mechanical compression.
|
|
1267
|
+
*/
|
|
1268
|
+
async compressWithLLM(messages, systemPrompt, tools, budget, signal) {
|
|
1269
|
+
if (!this.summarizer) return null;
|
|
1270
|
+
try {
|
|
1271
|
+
const estimateTokens = (msgs) => msgs.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
|
|
1272
|
+
const beforeTokens = estimateTokens(messages);
|
|
1273
|
+
let fixedTokens = 0;
|
|
1274
|
+
if (systemPrompt) fixedTokens += estimateTextTokens(systemPrompt) + 4;
|
|
1275
|
+
for (const t of tools ?? []) fixedTokens += estimateToolDefTokens(t);
|
|
1276
|
+
const summaryReserve = 2e3;
|
|
1277
|
+
const outputReserve = this.config.outputReserve ?? 1024;
|
|
1278
|
+
const remaining = budget - fixedTokens - summaryReserve - outputReserve;
|
|
1279
|
+
const kept = [];
|
|
1280
|
+
let used = 0;
|
|
1281
|
+
if (remaining > 0) {
|
|
1282
|
+
for (let i = messages.length - 1; i >= 0; i--) {
|
|
1283
|
+
const t = estimateMessageTokens(messages[i]);
|
|
1284
|
+
if (used + t > remaining) break;
|
|
1285
|
+
kept.unshift(messages[i]);
|
|
1286
|
+
used += t;
|
|
1287
|
+
}
|
|
1288
|
+
}
|
|
1289
|
+
const oldMessages = messages.slice(0, messages.length - kept.length);
|
|
1290
|
+
if (oldMessages.length === 0) {
|
|
1291
|
+
return null;
|
|
1292
|
+
}
|
|
1293
|
+
const summary = await this.summarizer(oldMessages, signal ? { signal } : void 0);
|
|
1294
|
+
const summaryMessage = { role: "user", content: `[\u4E0A\u4E0B\u6587\u6458\u8981]
|
|
1295
|
+
${summary}` };
|
|
1296
|
+
let result = [summaryMessage, ...kept];
|
|
1297
|
+
let afterTokens = estimateTokens(result);
|
|
1298
|
+
while (result.length > 2 && afterTokens > budget) {
|
|
1299
|
+
const trimmed = [summaryMessage, ...result.slice(2)];
|
|
1300
|
+
if (trimmed.length === result.length) break;
|
|
1301
|
+
result = trimmed;
|
|
1302
|
+
afterTokens = estimateTokens(result);
|
|
1303
|
+
}
|
|
1304
|
+
return { messages: result, beforeTokens, afterTokens };
|
|
1305
|
+
} catch (err) {
|
|
1306
|
+
console.warn("[listdoing] LLM summarization failed, falling back to mechanical compression:", err);
|
|
1307
|
+
return null;
|
|
1308
|
+
}
|
|
1309
|
+
}
|
|
1228
1310
|
/**
|
|
1229
1311
|
* Search across messages for relevant content.
|
|
1230
1312
|
*/
|
|
@@ -1247,6 +1329,87 @@ ${summaryText}` },
|
|
|
1247
1329
|
}
|
|
1248
1330
|
};
|
|
1249
1331
|
|
|
1332
|
+
// src/context/summarizer.ts
|
|
1333
|
+
var SUMMARIZE_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u5BF9\u8BDD\u4E0A\u4E0B\u6587\u538B\u7F29\u52A9\u624B\u3002\u8BF7\u9605\u8BFB\u4E0B\u9762\u7684\u5BF9\u8BDD\u7247\u6BB5\uFF0C\u751F\u6210\u4E00\u4EFD\u7ED3\u6784\u5316\u6458\u8981\uFF0C\u7528\u4E8E\u5728\u540E\u7EED\u5BF9\u8BDD\u4E2D\u4FDD\u7559\u5173\u952E\u4E0A\u4E0B\u6587\u3002
|
|
1334
|
+
|
|
1335
|
+
\u4E25\u683C\u6309\u4EE5\u4E0B\u7ED3\u6784\u8F93\u51FA\uFF08markdown\uFF09\uFF1A
|
|
1336
|
+
|
|
1337
|
+
## \u76EE\u6807
|
|
1338
|
+
\u7528\u6237\u60F3\u8981\u5B8C\u6210\u4EC0\u4E48
|
|
1339
|
+
|
|
1340
|
+
## \u5173\u952E\u51B3\u7B56
|
|
1341
|
+
\u5DF2\u505A\u7684\u51B3\u7B56\u53CA\u5176\u7406\u7531
|
|
1342
|
+
|
|
1343
|
+
## \u6D89\u53CA\u6587\u4EF6
|
|
1344
|
+
\u521B\u5EFA/\u4FEE\u6539/\u8BFB\u53D6\u7684\u6587\u4EF6\uFF0C\u7B80\u8FF0\u5176\u5185\u5BB9\u6216\u53D8\u66F4
|
|
1345
|
+
|
|
1346
|
+
## \u91CD\u8981\u53D1\u73B0
|
|
1347
|
+
\u7EE7\u7EED\u5DE5\u4F5C\u6240\u9700\u7684\u5173\u952E\u4E8B\u5B9E\uFF08\u6587\u4EF6\u7ED3\u6784\u3001\u6570\u636E\u3001\u641C\u7D22\u7ED3\u679C\u7B49\uFF09
|
|
1348
|
+
|
|
1349
|
+
## \u5F53\u524D\u72B6\u6001
|
|
1350
|
+
\u5BF9\u8BDD\u7247\u6BB5\u7ED3\u675F\u65F6\u6B63\u5728\u505A\u4EC0\u4E48
|
|
1351
|
+
|
|
1352
|
+
## \u5F85\u529E\u4E8B\u9879
|
|
1353
|
+
\u672A\u5B8C\u6210\u7684\u4EFB\u52A1\u6216\u660E\u786E\u7684\u4E0B\u4E00\u6B65
|
|
1354
|
+
|
|
1355
|
+
\u8981\u6C42\uFF1A
|
|
1356
|
+
- \u7B80\u6D01\uFF0C\u53EA\u4FDD\u7559\u7EE7\u7EED\u5DE5\u4F5C\u5FC5\u9700\u7684\u4FE1\u606F
|
|
1357
|
+
- \u4E0D\u8981\u8F93\u51FA\u4E0E\u4E0A\u8FF0\u7ED3\u6784\u65E0\u5173\u7684\u5185\u5BB9
|
|
1358
|
+
- \u7528\u4E0E\u5BF9\u8BDD\u5185\u5BB9\u76F8\u540C\u7684\u8BED\u8A00\u8F93\u51FA
|
|
1359
|
+
|
|
1360
|
+
--- \u5F85\u538B\u7F29\u7684\u5BF9\u8BDD ---`;
|
|
1361
|
+
function truncate(s, max) {
|
|
1362
|
+
return s.length > max ? s.slice(0, max) + "\u2026" : s;
|
|
1363
|
+
}
|
|
1364
|
+
function truncateMiddle(s, head, tail) {
|
|
1365
|
+
if (s.length <= head + tail) return s;
|
|
1366
|
+
return s.slice(0, head) + `
|
|
1367
|
+
\u2026[\u4E2D\u95F4 ${s.length - head - tail} \u5B57\u7B26\u5DF2\u7701\u7565]\u2026
|
|
1368
|
+
` + s.slice(-tail);
|
|
1369
|
+
}
|
|
1370
|
+
function formatMessagesForSummary(messages) {
|
|
1371
|
+
return messages.map((m) => {
|
|
1372
|
+
if (m.role === "user") return `\u7528\u6237: ${contentToString(m.content)}`;
|
|
1373
|
+
if (m.role === "assistant") {
|
|
1374
|
+
let s = `\u52A9\u624B: ${contentToString(m.content)}`;
|
|
1375
|
+
if (m.toolCalls?.length) {
|
|
1376
|
+
s += "\n" + m.toolCalls.map((tc) => ` [\u8C03\u7528\u5DE5\u5177 ${tc.name}: ${truncate(JSON.stringify(tc.arguments), 200)}]`).join("\n");
|
|
1377
|
+
}
|
|
1378
|
+
return s;
|
|
1379
|
+
}
|
|
1380
|
+
if (m.role === "tool") {
|
|
1381
|
+
return `\u5DE5\u5177\u7ED3\u679C: ${truncateMiddle(contentToString(m.content), 500, 200)}`;
|
|
1382
|
+
}
|
|
1383
|
+
if (m.role === "system") return `\u7CFB\u7EDF: ${contentToString(m.content)}`;
|
|
1384
|
+
return "";
|
|
1385
|
+
}).filter(Boolean).join("\n\n");
|
|
1386
|
+
}
|
|
1387
|
+
function createLLMSummarizer(adapter, options) {
|
|
1388
|
+
const timeoutMs = options?.timeoutMs ?? 3e4;
|
|
1389
|
+
return async (messages, opts) => {
|
|
1390
|
+
const formatted = formatMessagesForSummary(messages);
|
|
1391
|
+
const controller = new AbortController();
|
|
1392
|
+
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
|
1393
|
+
try {
|
|
1394
|
+
const response = await adapter.chat(
|
|
1395
|
+
[
|
|
1396
|
+
{ role: "system", content: SUMMARIZE_PROMPT },
|
|
1397
|
+
{ role: "user", content: formatted }
|
|
1398
|
+
],
|
|
1399
|
+
[],
|
|
1400
|
+
{ signal: opts?.signal ?? controller.signal }
|
|
1401
|
+
);
|
|
1402
|
+
const summary = (response.content ?? "").trim();
|
|
1403
|
+
if (!summary) {
|
|
1404
|
+
throw new Error("Summarizer returned empty content");
|
|
1405
|
+
}
|
|
1406
|
+
return summary;
|
|
1407
|
+
} finally {
|
|
1408
|
+
clearTimeout(timer);
|
|
1409
|
+
}
|
|
1410
|
+
};
|
|
1411
|
+
}
|
|
1412
|
+
|
|
1250
1413
|
// src/task/planner.ts
|
|
1251
1414
|
var TaskPlanner = class {
|
|
1252
1415
|
constructor(llmAdapter) {
|
|
@@ -2388,6 +2551,7 @@ var Ldoing = class {
|
|
|
2388
2551
|
this.mcpRouter = new McpRouter();
|
|
2389
2552
|
this.sessionManager = new SessionManager();
|
|
2390
2553
|
this.contextManager = new ContextManager(config.context, config.llm.model);
|
|
2554
|
+
this.contextManager.setSummarizer(createLLMSummarizer(this.llmAdapter));
|
|
2391
2555
|
if (config.serverUrl) {
|
|
2392
2556
|
this.transport = new HttpTransport(config.serverUrl, config.authToken, config.headers);
|
|
2393
2557
|
} else {
|
|
@@ -2524,15 +2688,21 @@ var Ldoing = class {
|
|
|
2524
2688
|
for (const name of this.computeAutoApproval(tools)) {
|
|
2525
2689
|
requireApproval.add(name);
|
|
2526
2690
|
}
|
|
2527
|
-
const ctxCheck = this.contextManager.ensureContextFits(
|
|
2691
|
+
const ctxCheck = await this.contextManager.ensureContextFits(
|
|
2528
2692
|
session2.messages,
|
|
2529
2693
|
systemPrompt,
|
|
2530
2694
|
tools,
|
|
2531
|
-
this.config.llm.model
|
|
2695
|
+
this.config.llm.model,
|
|
2696
|
+
controller.signal
|
|
2532
2697
|
);
|
|
2533
2698
|
if (ctxCheck.wasCompressed) {
|
|
2534
2699
|
session2.messages = ctxCheck.messages;
|
|
2535
|
-
this.emit("context:compress", {
|
|
2700
|
+
this.emit("context:compress", {
|
|
2701
|
+
sessionId,
|
|
2702
|
+
reason: "auto",
|
|
2703
|
+
beforeTokens: ctxCheck.beforeTokens,
|
|
2704
|
+
afterTokens: ctxCheck.afterTokens
|
|
2705
|
+
});
|
|
2536
2706
|
}
|
|
2537
2707
|
const contextMessages = this.contextManager.buildWindow(
|
|
2538
2708
|
session2.messages,
|
|
@@ -2546,17 +2716,22 @@ var Ldoing = class {
|
|
|
2546
2716
|
});
|
|
2547
2717
|
} catch (err) {
|
|
2548
2718
|
if (err.code === ACPErrorCodes.CONTEXT_OVERFLOW && !retried) {
|
|
2549
|
-
this.compressContext(sessionId, "
|
|
2719
|
+
await this.compressContext(sessionId, "llm_summary");
|
|
2550
2720
|
retried = true;
|
|
2551
2721
|
turn--;
|
|
2552
2722
|
continue;
|
|
2553
2723
|
}
|
|
2554
|
-
if (err.code === ACPErrorCodes.LLM_EMPTY_RESPONSE
|
|
2724
|
+
if (err.code === ACPErrorCodes.LLM_EMPTY_RESPONSE) {
|
|
2725
|
+
if (!retried) {
|
|
2726
|
+
this.sessionManager.addMessage(sessionId, { role: "assistant", content: "." });
|
|
2727
|
+
this.sessionManager.addMessage(sessionId, { role: "user", content: "System: \u521A\u521A\u8FD4\u56DE\u4E86\u7A7A\u5185\u5BB9\uFF0C\u8BF7\u751F\u6210\u6709\u6548\u56DE\u590D\u3002" });
|
|
2728
|
+
retried = true;
|
|
2729
|
+
turn--;
|
|
2730
|
+
continue;
|
|
2731
|
+
}
|
|
2555
2732
|
this.sessionManager.addMessage(sessionId, { role: "assistant", content: "." });
|
|
2556
|
-
|
|
2557
|
-
|
|
2558
|
-
turn--;
|
|
2559
|
-
continue;
|
|
2733
|
+
continueLoop = false;
|
|
2734
|
+
break;
|
|
2560
2735
|
}
|
|
2561
2736
|
throw new ACPError(ACPErrorCodes.LLM_CALL_FAILED, `LLM call failed: ${err.message}`, { turn });
|
|
2562
2737
|
}
|
|
@@ -2651,10 +2826,28 @@ var Ldoing = class {
|
|
|
2651
2826
|
for (const name of this.computeAutoApproval(tools)) {
|
|
2652
2827
|
requireApproval.add(name);
|
|
2653
2828
|
}
|
|
2654
|
-
const ctxCheck = this.contextManager.ensureContextFits(
|
|
2829
|
+
const ctxCheck = await this.contextManager.ensureContextFits(
|
|
2830
|
+
session2.messages,
|
|
2831
|
+
systemPrompt,
|
|
2832
|
+
tools,
|
|
2833
|
+
this.config.llm.model,
|
|
2834
|
+
controller.signal
|
|
2835
|
+
);
|
|
2655
2836
|
if (ctxCheck.wasCompressed) {
|
|
2656
2837
|
session2.messages = ctxCheck.messages;
|
|
2657
|
-
this.emit("context:compress", {
|
|
2838
|
+
this.emit("context:compress", {
|
|
2839
|
+
sessionId,
|
|
2840
|
+
reason: "auto",
|
|
2841
|
+
beforeTokens: ctxCheck.beforeTokens,
|
|
2842
|
+
afterTokens: ctxCheck.afterTokens
|
|
2843
|
+
});
|
|
2844
|
+
yield {
|
|
2845
|
+
type: "context:compressed",
|
|
2846
|
+
sessionId,
|
|
2847
|
+
beforeTokens: ctxCheck.beforeTokens ?? 0,
|
|
2848
|
+
afterTokens: ctxCheck.afterTokens ?? 0,
|
|
2849
|
+
reason: "auto"
|
|
2850
|
+
};
|
|
2658
2851
|
}
|
|
2659
2852
|
const contextMessages = this.contextManager.buildWindow(session2.messages, systemPrompt, tools).messages;
|
|
2660
2853
|
let llmResponse;
|
|
@@ -2673,7 +2866,7 @@ var Ldoing = class {
|
|
|
2673
2866
|
}
|
|
2674
2867
|
} catch (err) {
|
|
2675
2868
|
if (err.code === ACPErrorCodes.CONTEXT_OVERFLOW && !retried) {
|
|
2676
|
-
this.compressContext(sessionId, "
|
|
2869
|
+
await this.compressContext(sessionId, "llm_summary");
|
|
2677
2870
|
retried = true;
|
|
2678
2871
|
turn--;
|
|
2679
2872
|
continue;
|
|
@@ -3556,13 +3749,13 @@ ${resultLines.join("\n")}` : "Graph resumed but no nodes completed successfully.
|
|
|
3556
3749
|
}
|
|
3557
3750
|
return this.contextManager.search(allMessages, query, options);
|
|
3558
3751
|
}
|
|
3559
|
-
compressContext(sessionId, strategy) {
|
|
3752
|
+
async compressContext(sessionId, strategy) {
|
|
3560
3753
|
const session = this.sessionManager.getOrThrow(sessionId);
|
|
3561
|
-
const result = this.contextManager.compress(session.messages, strategy);
|
|
3754
|
+
const result = await this.contextManager.compress(session.messages, strategy);
|
|
3562
3755
|
session.messages = result.messages;
|
|
3563
3756
|
session.tokenCount = result.afterTokens;
|
|
3564
3757
|
session.updatedAt = Date.now();
|
|
3565
|
-
this.emit("context:compress", { sessionId, beforeTokens: result.beforeTokens, afterTokens: result.afterTokens });
|
|
3758
|
+
this.emit("context:compress", { sessionId, beforeTokens: result.beforeTokens, afterTokens: result.afterTokens, reason: "manual" });
|
|
3566
3759
|
return { beforeTokens: result.beforeTokens, afterTokens: result.afterTokens, compressionRatio: result.afterTokens / (result.beforeTokens || 1) };
|
|
3567
3760
|
}
|
|
3568
3761
|
// ---- Runtime Config ----
|
|
@@ -3571,6 +3764,7 @@ ${resultLines.join("\n")}` : "Graph resumed but no nodes completed successfully.
|
|
|
3571
3764
|
Object.assign(this.config.llm, config.llm);
|
|
3572
3765
|
this.llmAdapter = new OpenAIAdapter(this.config.llm);
|
|
3573
3766
|
this.contextManager.setModel(this.config.llm.model);
|
|
3767
|
+
this.contextManager.setSummarizer(createLLMSummarizer(this.llmAdapter));
|
|
3574
3768
|
}
|
|
3575
3769
|
if (config.serverUrl) {
|
|
3576
3770
|
this.config.serverUrl = config.serverUrl;
|