mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 15:19:16 +00:00
* Fix ACP history replay and compaction * Fix PR keyword importance matching Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Address codex review on #754: preserve short constraints + cancel-clear Two recovery-path regressions flagged by codex review: 1. Compact ACP history dropped short load-bearing user constraints (acpHistory.ts:55). The blanket length<10 rule treated short non-trivial messages like "Use ssh2" or "中文输出" as filler, while longer generic follow-ups still ate the budget. After stale-session recovery the fresh ACP session would resume without constraints that were present in the original chat. Removed the length heuristic; the TRIVIAL_USER_MESSAGE_PATTERNS regex already filters actual filler ("ok", "yes", "继续", "thanks"). 2. historyReplayFallback was only cleared on non-aborted streams (aiBridge.cjs:2837). If the user stopped the first turn after stale-session recovery, the flag stayed set. The next turn would then trigger shouldResetProviderForHistoryReplay, discard the freshly recovered ACP session (resumeSessionId is forced to undefined in that path), and re-spend tokens on another compact replay — breaking the cancel-preserves-session contract. Now we also clear on abort; the empty-but-not-aborted retry path in the if-branch above is unchanged. Tests: - New test in acpHistory.test.ts asserts "Use ssh2" / "中文输出" survive when pushed outside the recent raw window - New test asserts "ok" / "继续" still drop (sanity check that the trivial regex still does its job without the length backstop) - Updated "does not treat pr inside ordinary words as important" to no longer assert that approach/improve/prepare are absent — the test's real intent (priority-2 line still wins) is preserved by the 不要提交 assertion - New test in aiBridge.test.cjs simulates a user cancelling the first turn after recovery and verifies the next turn reuses the recovered session (no extra provider creation, no re-replay) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * Address codex re-review: preserve replay flag across orthogonal recreation + keep tool output in raw window Two more P2 regressions flagged on the second review pass: 1. historyReplayFallback was only carried over in the reset-for-replay branch of the provider recreation path. An orthogonal change between an empty recovered turn and its retry — a permission-mode toggle, MCP scope/fingerprint flip, or auth rotation — would flip shouldReuseProvider to false, enter the !shouldReuseProvider branch, and drop the flag because preserveHistoryReplayFallback only covered the shouldResetProviderForHistoryReplay case. The next turn then sent only the latest prompt and lost the recovered conversation. Now the flag is preserved on any recreation where a replay is still pending. 2. Tool messages didn't flow through toRawHistoryMessage at all, so on stale-session recovery they only survived as the 500-char compact summary in summarizeToolMessage. Any follow-up referencing the last tool output ("use that output", "what did cat show?") lost the actual bytes when they exceeded the compact cap. Now tool results travel through the recent raw window up to MAX_RAW_MESSAGE_CHARS (2000), flattened to the "assistant" role since ACP only accepts user/assistant. Tests: - aiBridge.test.cjs: new "preserves history-replay across provider recreation caused by permission-mode / MCP / auth change" — exercises the gap via a permission-mode toggle between an empty recovered turn and its retry. Extends mock to support a dynamic getPermissionMode. - acpHistory.test.ts: new "preserves recent tool results verbatim" — pushes a ~1500-char tool output through the pipeline and asserts the replay still contains enough bytes to exceed the 500-char compact cap. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * Address codex round 3: inline tool_call context + bound durable scan Two findings from the third codex review pass, both legitimate: 1. [P2] When the raw window starts mid-tool-interaction, the preceding assistant tool_call message can fall outside the 6-item slice while the tool_result stays in. Without the call's name+arguments, the result was opaque bytes and follow-ups like "use that output" had no provenance. The compact pass only preserved calls that matched IMPORTANT_PATTERNS, so read_file / grep / terminal_exec were silently dropped. Fix: build a toolCallId → { name, arguments } index from every assistant message and inline a `[from <name>(<args>)]` label next to each Tool result line in the raw window. Args are truncated to MAX_TOOL_CALL_LABEL_CHARS (200) so a verbose JSON payload can't eat the entire raw budget. 2. [P3] buildCompactContext scanned messages.entries() over the full transcript for durable-user/assistant candidates, even though MAX_MESSAGES_TO_SCAN (20) suggested the path was meant to be bounded. On a long ACP chat, every send did O(N) regex work plus an O(N log N) sort — the very chat-length-dependent latency the token-compaction PR was meant to address. Fix: introduce MAX_DURABLE_SCAN_MESSAGES (200) and restrict the durable scan to that tail. 200 is large enough to cover realistic sessions (99th-percentile chats are << 200 turns) while giving a constant-time worst case. Constraints older than the window age out of the compact replay; the live ACP provider's own persisted session still carries them when it can resume, which is the common path. Tests: - "inlines tool_call name+args so tool_result is interpretable without the preceding assistant turn" — pushes the tool_call out of the raw window and asserts the result line carries [from <tool>(<args>)]. - "bounds the durable-candidate scan to avoid O(N) work per send on long chats" — builds a 600+ message chat with an ancient priority-2 constraint outside the scan window and a recent one inside; asserts only the recent one survives. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * Address codex round 4: preserve short assistant decisions + provenance on older tool results Two P2 findings from the fourth codex pass, both mirror-images of earlier fixes on a different code path: 1. Short assistant decisions dropped from compact replay (acpHistory.ts:75-83). isSubstantiveAssistantMessage required length >= 40 OR a small English keyword match OR a numbered list. Short but load-bearing replies like "Use ssh2", "rebase instead", "中文输出" satisfied none of those and were silently dropped from the durable- assistant compact section. Once they fell outside the 6-item raw window, "do what you suggested earlier" would replay only the user question without the assistant's actual decision. Fix: mirror the user-side loosening — drop the length/keyword gate, rely on TRIVIAL_ASSISTANT_MESSAGE_PATTERNS to filter actual filler ("ok", "ack", "got it", "明白"). 2. Older tool results lost provenance (acpHistory.ts:108-114). The raw-window fix (round 3) only covered the last 6 items. Once a tool result fell into the compact section via summarizeToolMessage, the paired assistant tool_call was usually gone too, so multiple older outputs surfaced as indistinguishable "Tool result (callN): ...". Follow-ups like "use the resolv.conf output" had no way to map to the right call. Fix: plumb the toolCallIndex through summarizeMessage → summarizeToolMessage and inline `[from <name>(<args>)]` labels in the compact section too, the same shape the raw window uses. Tests: - New: preserves short non-trivial assistant decisions that miss the keyword heuristic (Use ssh2 / 中文输出 / rebase instead) - New: still drops trivial assistant filler like 'ack' / 'ok' / '明白' - New: inlines tool_call context on OLDER summarized tool results - Updated earlier raw-window tool regex tests to match the [from X(Y)] shape ([^)] was failing to cross the args JSON's closing paren) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * Address codex round 5: de-dup raw ∩ compact + wire userSkills test into npm test [P2] The scanned loop (last 20) overlaps with recentRaw (last 6), so without a raw-window skip in the summarizeMessage path the same last-6 turns were summarized into the compact section AND appended verbatim in the raw section. Important user turns and large tool output paid the budget twice — eating into the 3k compact cap and crowding out older durable context the replay is meant to preserve. Added the same recentRawSourceIds skip the durable-user / durable-assistant passes already use, and a regression test that asserts markers inside the raw window don't surface in compact while still appearing in raw. [P3] electron/bridges/ai/userSkills.test.cjs (added by this PR) sat in a subdirectory that the default "npm test" glob (electron/bridges/*.test.cjs) didn't pick up. The new routing / index-budget regressions would never run locally or in CI until someone noticed. Extended the glob to also match electron/bridges/*/*.test.cjs; the userSkills tests are now included in the 148-test run. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * Address codex round 6: cancel+immediate-send race + tool-call id collision Two P2 regressions in the recovery path: 1. If the user clicks Stop and immediately sends the next prompt, the new stream handler's existingRun path unconditionally called cleanupAcpProvider — destroying the fresh ACP session the cancel IPC had just promised to preserve. The round-2 clear-on-abort fix ran too late (in post-stream code) to help, because the new stream can arrive before the aborted stream fully unwinds. In that common timing window the follow-up still started from a bare provider and lost all recovered conversation state. Fix: (a) cancel IPC now synchronously clears historyReplayFallback on the preserved provider entry, so the next stream can't trigger shouldResetProviderForHistoryReplay and tear the session down via that path; (b) the existingRun path skips cleanupAcpProvider when the prior run was already cancelled via the cancel IPC (captured via existingRun.cancelRequested before we overwrite it). True interrupt-and-restart without an explicit cancel still falls back to the old clean-slate behavior. 2. The tool-call provenance index used raw toolCall.id as the key. Nothing in ChatMessage or the ACP event path enforces per-chat unique ids, so a provider reusing "call1" across turns would overwrite the older entry and mis-label older tool results (e.g., an /etc/hosts result annotated as /etc/resolv.conf in the compact summary). That makes stale-session recovery misleading whenever a follow-up refers back to an earlier tool output. Fix: key the index by `${toolResultMessageId}:${toolCallId}` and walk the message stream in order, resolving each tool_result to the most recent preceding assistant tool_call with matching id. Each result keeps its own historically-correct label regardless of later id reuse. Tests: - aiBridge: "preserves recovered ACP session when user cancels then immediately sends the next prompt" — fires the next stream request after cancel but BEFORE releasing the first stream's blocked read, asserts providerCreationArgs.length stays at 2 (no third creation) and the second turn sends only the latest prompt. - acpHistory: "resolves tool_call provenance correctly when tool ids are reused across turns" — two interactions sharing id "call1", asserts each tool_result carries its own call's args label. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * Address codex round 7: turn-based scan bound + single-pass history build Two P2 regressions in long-chat / tool-heavy recovery paths: 1. MAX_DURABLE_SCAN_MESSAGES (200) bounded the scan by raw message count. ACP tool interactions store the user turn, assistant tool_call turn, and each tool_result as separate messages, so a tool-heavy chat can produce 5+ messages per logical turn. 200 messages could be only 30-40 user turns — early constraints like "不要提交" from turn 5 fell out of the compact replay long before the turn count justified aging them out. Fix: bound by MAX_DURABLE_SCAN_TURNS (100 user turns) instead. Walk backwards from the end and stop after seeing 100 user messages. Realistic tool-heavy 30-turn chats now keep their early constraints alive, while true 100+ turn chats still benefit from the bound. 2. buildToolCallIndex(messages) and messages.flatMap(...).slice(-6) both walked the entire transcript on every send, even after the bounded compaction window landed. Compaction's stated purpose was to remove chat-length-dependent latency, but these per-send linear passes kept it. Fix: compute the scan start once via computeDurableScanStart, then do all subsequent work over messages.slice(durableScanStart). buildToolCallIndex walks only the window; the raw-6 flatMap also runs over the window. On a 1000-message chat with 100-turn window, send-time cost drops from O(1000) to O(~window_size). Acceptable trade: if a tool_call's matching tool_result straddles the window boundary (result inside, call outside), the single surviving result loses its [from X(Y)] label. Tool_calls and their results are almost always adjacent, so this affects at most the first 1-2 messages of the window. Tests: - "preserves an early constraint in a tool-heavy chat where message count balloons past the raw-count limit" — 35 turns × 6 msgs/turn = 212 messages. The old bound would have dropped the early EARLY_CONSTRAINT_MARKER; with turn-based bound it survives. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Co-authored-by: bincxz <16399091+binaricat@users.noreply.github.com> Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
439 lines
18 KiB
TypeScript
439 lines
18 KiB
TypeScript
import type { ChatMessage } from "../../infrastructure/ai/types.ts";
|
|
|
|
type AcpHistoryMessage = { role: "user" | "assistant"; content: string };
|
|
type RawHistoryMessage = AcpHistoryMessage & { sourceId: string };
|
|
type DurableUserLine = {
|
|
line: string;
|
|
messageIndex: number;
|
|
priority: number;
|
|
};
|
|
|
|
const MAX_RECENT_RAW_MESSAGES = 6;
|
|
const MAX_MESSAGES_TO_SCAN = 20;
|
|
// Bound the scan by user turns, not raw message count: a tool-heavy ACP
|
|
// chat can produce 5+ messages per logical turn (user + assistant +
|
|
// several tool_results + follow-up assistant), so a plain
|
|
// message-count cap ages out early constraints much sooner than intended.
|
|
const MAX_DURABLE_SCAN_TURNS = 100;
|
|
const MAX_COMPACT_CONTEXT_CHARS = 3000;
|
|
const MAX_RAW_MESSAGE_CHARS = 2000;
|
|
const MAX_TOOL_SUMMARY_CHARS = 500;
|
|
const MAX_DURABLE_USER_CONTEXT_CHARS = 1400;
|
|
const MAX_DURABLE_ASSISTANT_CONTEXT_CHARS = 900;
|
|
const MAX_RECENT_SUMMARY_CONTEXT_CHARS = 1200;
|
|
const MAX_DURABLE_USER_MESSAGE_CHARS = 280;
|
|
const MAX_DURABLE_ASSISTANT_MESSAGE_CHARS = 360;
|
|
const MAX_TOOL_CALL_LABEL_CHARS = 200;
|
|
|
|
type ToolCallInfo = { name: string; arguments: unknown };
|
|
|
|
const IMPORTANT_PATTERNS = [
|
|
/不要|别|不能|不允许|必须|希望|只|最小|先|暂时|fallback|pwsh|powershell|cmd\.exe|windows|mcp|skills|cli|commit|\bpr\b|打包|内存|历史|压缩|慢/i,
|
|
/error|failed|failure|exit code|exception|cannot|unable|timeout|crash|fallback|commit|pull request|PR #\d+/i,
|
|
];
|
|
const DURABLE_CONSTRAINT_PATTERNS = [
|
|
/\bdo not\b|\bdon't\b|\bkeep\b|\bpreserve\b|\bavoid\b|\bonly\b|\bunchanged\b|\blocal only\b|\bwithout\b|\bleave\b/i,
|
|
/不要|别|保留|保持|维持|不改|别改|不要改|仅限本地/i,
|
|
];
|
|
const TRIVIAL_USER_MESSAGE_PATTERNS = [
|
|
/^(ok|okay|yes|no|thanks|thank you|continue|继续|好的|收到|行|嗯|好|继续处理|继续吧|开始吧)[.!? ]*$/i,
|
|
];
|
|
const TRIVIAL_ASSISTANT_MESSAGE_PATTERNS = [
|
|
/^(ok|okay|understood|got it|working|proceeding|ready|ack(?: \d+)?|收到|明白|继续处理|准备实现|开始处理|处理中)[.!? ]*$/i,
|
|
];
|
|
|
|
function truncateText(value: string, maxChars: number): string {
|
|
if (value.length <= maxChars) return value;
|
|
return `${value.slice(0, Math.max(0, maxChars - 24)).trimEnd()}\n[truncated]`;
|
|
}
|
|
|
|
function normalizeWhitespace(value: string): string {
|
|
return value.replace(/\s+/g, " ").trim();
|
|
}
|
|
|
|
function isImportantText(value: string): boolean {
|
|
return IMPORTANT_PATTERNS.some((pattern) => pattern.test(value));
|
|
}
|
|
|
|
function isDurableConstraintText(value: string): boolean {
|
|
return DURABLE_CONSTRAINT_PATTERNS.some((pattern) => pattern.test(value));
|
|
}
|
|
|
|
function isTrivialUserMessage(value: string): boolean {
|
|
const normalized = normalizeWhitespace(value);
|
|
if (isImportantText(normalized) || isDurableConstraintText(normalized)) return false;
|
|
// Don't blanket-drop short messages — short user turns are often
|
|
// load-bearing constraints ("Use ssh2", "中文输出", "no logs", "more
|
|
// verbose") that the IMPORTANT/DURABLE regexes can't realistically
|
|
// enumerate. The trivial-phrase regex already catches actual filler
|
|
// ("ok", "yes", "thanks", "继续").
|
|
return TRIVIAL_USER_MESSAGE_PATTERNS.some((pattern) => pattern.test(normalized));
|
|
}
|
|
|
|
function getDurableUserPriority(value: string): number {
|
|
const normalized = normalizeWhitespace(value);
|
|
if (isImportantText(normalized) || isDurableConstraintText(normalized)) return 2;
|
|
return 1;
|
|
}
|
|
|
|
function isSubstantiveAssistantMessage(value: string): boolean {
|
|
const normalized = normalizeWhitespace(value);
|
|
if (!normalized) return false;
|
|
// Mirror the user-side loosening: don't blanket-drop short assistant
|
|
// messages just because they're under 40 chars or don't match the small
|
|
// English keyword list. Short but load-bearing decisions ("Use ssh2",
|
|
// "rebase instead", "中文输出") aren't realistically enumerable and
|
|
// they're the exact things a later "do what you suggested" references.
|
|
// TRIVIAL_ASSISTANT_MESSAGE_PATTERNS still catches the actual filler
|
|
// ("ok", "ack", "got it", "明白").
|
|
return !TRIVIAL_ASSISTANT_MESSAGE_PATTERNS.some((pattern) => pattern.test(normalized));
|
|
}
|
|
|
|
function getDurableAssistantPriority(value: string): number {
|
|
const normalized = normalizeWhitespace(value);
|
|
if (isImportantText(normalized)) return 2;
|
|
return 1;
|
|
}
|
|
|
|
function appendUniqueLine(
|
|
target: string[],
|
|
seen: Set<string>,
|
|
line: string,
|
|
maxSectionChars: number,
|
|
sectionCharsRef: { value: number },
|
|
): void {
|
|
const normalized = normalizeWhitespace(line);
|
|
if (!normalized || seen.has(normalized)) return;
|
|
const nextChars = sectionCharsRef.value + normalized.length;
|
|
if (nextChars > maxSectionChars) return;
|
|
seen.add(normalized);
|
|
target.push(normalized);
|
|
sectionCharsRef.value = nextChars;
|
|
}
|
|
|
|
function summarizeToolMessage(
|
|
message: ChatMessage,
|
|
toolCallIndex: Map<string, ToolCallInfo>,
|
|
): string[] {
|
|
if (!message.toolResults?.length) return [];
|
|
return message.toolResults.map((result) => {
|
|
const prefix = result.isError ? "Tool error" : "Tool result";
|
|
const content = normalizeWhitespace(result.content || "");
|
|
// Same provenance problem as the raw-window path: once a tool result
|
|
// lands in the compact section (older than the 6-item raw window),
|
|
// its paired assistant tool_call is almost always gone. Without the
|
|
// call label, multiple older results collapse into indistinguishable
|
|
// "Tool result (callN): ..." lines and follow-ups like "use the
|
|
// resolv.conf output" can't be resolved. Inline the name+args here
|
|
// the same way toRawHistoryMessage does.
|
|
const callInfo = lookupToolCallInfo(toolCallIndex, message.id, result.toolCallId);
|
|
const callLabel = callInfo
|
|
? ` [from ${callInfo.name}(${truncateText(JSON.stringify(callInfo.arguments ?? {}), MAX_TOOL_CALL_LABEL_CHARS)})]`
|
|
: "";
|
|
return `${prefix}${callLabel} (${result.toolCallId}): ${truncateText(content, MAX_TOOL_SUMMARY_CHARS)}`;
|
|
});
|
|
}
|
|
|
|
function summarizeMessage(
|
|
message: ChatMessage,
|
|
toolCallIndex: Map<string, ToolCallInfo>,
|
|
): string[] {
|
|
if (message.role === "system") return [];
|
|
if (message.role === "tool") return summarizeToolMessage(message, toolCallIndex);
|
|
|
|
const lines: string[] = [];
|
|
if (message.content && isImportantText(message.content)) {
|
|
const label = message.role === "user" ? "User" : "Assistant";
|
|
lines.push(`${label}: ${truncateText(normalizeWhitespace(message.content), MAX_TOOL_SUMMARY_CHARS)}`);
|
|
}
|
|
|
|
if (message.role === "assistant" && message.toolCalls?.length) {
|
|
for (const toolCall of message.toolCalls) {
|
|
const args = JSON.stringify(toolCall.arguments ?? {});
|
|
const summary = `Tool call: ${toolCall.name}(${truncateText(args, 220)})`;
|
|
if (isImportantText(summary)) lines.push(summary);
|
|
}
|
|
}
|
|
|
|
return lines;
|
|
}
|
|
|
|
function summarizeDurableUserMessage(message: ChatMessage): string | null {
|
|
if (message.role !== "user" || !message.content) return null;
|
|
if (isTrivialUserMessage(message.content)) return null;
|
|
return `User request: ${truncateText(normalizeWhitespace(message.content), MAX_DURABLE_USER_MESSAGE_CHARS)}`;
|
|
}
|
|
|
|
function summarizeDurableAssistantMessage(message: ChatMessage): string | null {
|
|
if (message.role !== "assistant" || !message.content) return null;
|
|
if (!isSubstantiveAssistantMessage(message.content)) return null;
|
|
return `Assistant context: ${truncateText(normalizeWhitespace(message.content), MAX_DURABLE_ASSISTANT_MESSAGE_CHARS)}`;
|
|
}
|
|
|
|
/**
|
|
* Build a per-tool-result provenance index. Keys are
|
|
* `${toolResultMessageId}:${toolCallId}` rather than the bare toolCall.id
|
|
* so that provider-reused ids (e.g. "call1" across unrelated turns) don't
|
|
* cause later calls to overwrite older ones in the lookup — each
|
|
* tool_result resolves to the most recent assistant tool_call that
|
|
* preceded it with matching id, which preserves historical correctness
|
|
* when rebuilding older compact summaries.
|
|
*/
|
|
function buildToolCallIndex(messages: ChatMessage[]): Map<string, ToolCallInfo> {
|
|
const provenance = new Map<string, ToolCallInfo>();
|
|
// Rolling map of the latest tool_call seen (by id) up to the current
|
|
// point in the message stream.
|
|
const latestByCallId = new Map<string, ToolCallInfo>();
|
|
for (const message of messages) {
|
|
if (message.role === "assistant" && message.toolCalls?.length) {
|
|
for (const toolCall of message.toolCalls) {
|
|
if (!toolCall.id) continue;
|
|
latestByCallId.set(toolCall.id, { name: toolCall.name, arguments: toolCall.arguments });
|
|
}
|
|
continue;
|
|
}
|
|
if (message.role === "tool" && message.toolResults?.length) {
|
|
for (const result of message.toolResults) {
|
|
const info = latestByCallId.get(result.toolCallId);
|
|
if (info) {
|
|
provenance.set(`${message.id}:${result.toolCallId}`, info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return provenance;
|
|
}
|
|
|
|
function lookupToolCallInfo(
|
|
index: Map<string, ToolCallInfo>,
|
|
toolMessageId: string,
|
|
toolCallId: string,
|
|
): ToolCallInfo | undefined {
|
|
return index.get(`${toolMessageId}:${toolCallId}`);
|
|
}
|
|
|
|
function toRawHistoryMessage(
|
|
message: ChatMessage,
|
|
toolCallIndex: Map<string, ToolCallInfo>,
|
|
): RawHistoryMessage[] {
|
|
if (message.role === "user") {
|
|
return message.content
|
|
? [{ sourceId: message.id, role: "user", content: truncateText(message.content, MAX_RAW_MESSAGE_CHARS) }]
|
|
: [];
|
|
}
|
|
|
|
if (message.role === "assistant") {
|
|
const parts: string[] = [];
|
|
if (message.content) parts.push(message.content);
|
|
if (message.toolCalls?.length) {
|
|
parts.push(...message.toolCalls.map((tc) => `Tool call: ${tc.name}(${JSON.stringify(tc.arguments ?? {})})`));
|
|
}
|
|
return parts.length
|
|
? [{ sourceId: message.id, role: "assistant", content: truncateText(parts.join("\n\n"), MAX_RAW_MESSAGE_CHARS) }]
|
|
: [];
|
|
}
|
|
|
|
if (message.role === "tool" && message.toolResults?.length) {
|
|
// Keep tool output in the recent raw window (up to MAX_RAW_MESSAGE_CHARS
|
|
// per message, ~2000). Without this, follow-up turns after stale-session
|
|
// recovery would only see the 500-char compact summary in
|
|
// summarizeToolMessage, losing the actual bytes the user might reference
|
|
// ("use that output", "what did cat show?"). ACP only supports user/
|
|
// assistant roles, so we flatten to "assistant" — the tool results were
|
|
// produced during the assistant's turn.
|
|
//
|
|
// Inline the originating tool_call's name+args. Tool calls and their
|
|
// results live in separate messages; if the last six raw items start
|
|
// in the middle of a tool interaction, the preceding assistant tool
|
|
// call can be outside the window. Without the call label the result
|
|
// is opaque bytes and "use that output" becomes ambiguous.
|
|
const parts = message.toolResults.map((result) => {
|
|
const prefix = result.isError ? "Tool error" : "Tool result";
|
|
const callInfo = lookupToolCallInfo(toolCallIndex, message.id, result.toolCallId);
|
|
const callLabel = callInfo
|
|
? ` [from ${callInfo.name}(${truncateText(JSON.stringify(callInfo.arguments ?? {}), MAX_TOOL_CALL_LABEL_CHARS)})]`
|
|
: "";
|
|
return `${prefix}${callLabel} (${result.toolCallId}): ${result.content || ""}`;
|
|
});
|
|
return [{
|
|
sourceId: message.id,
|
|
role: "assistant",
|
|
content: truncateText(parts.join("\n\n"), MAX_RAW_MESSAGE_CHARS),
|
|
}];
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
function buildCompactContext(
|
|
messages: ChatMessage[],
|
|
durableScanStart: number,
|
|
recentRawSourceIds: Set<string>,
|
|
toolCallIndex: Map<string, ToolCallInfo>,
|
|
): AcpHistoryMessage[] {
|
|
const scanned = messages.slice(-MAX_MESSAGES_TO_SCAN);
|
|
const summaryLines: string[] = [];
|
|
const durableUserCandidates: DurableUserLine[] = [];
|
|
const selectedDurableUserLines: DurableUserLine[] = [];
|
|
const durableAssistantCandidates: DurableUserLine[] = [];
|
|
const selectedDurableAssistantLines: DurableUserLine[] = [];
|
|
const seen = new Set<string>();
|
|
const durableChars = { value: 0 };
|
|
const durableAssistantChars = { value: 0 };
|
|
const summaryChars = { value: 0 };
|
|
|
|
for (let messageIndex = durableScanStart; messageIndex < messages.length; messageIndex += 1) {
|
|
const message = messages[messageIndex];
|
|
if (recentRawSourceIds.has(message.id)) continue;
|
|
const durableUserLine = summarizeDurableUserMessage(message);
|
|
if (durableUserLine) {
|
|
durableUserCandidates.push({
|
|
line: durableUserLine,
|
|
messageIndex,
|
|
priority: getDurableUserPriority(message.content || ""),
|
|
});
|
|
}
|
|
const durableAssistantLine = summarizeDurableAssistantMessage(message);
|
|
if (durableAssistantLine) {
|
|
durableAssistantCandidates.push({
|
|
line: durableAssistantLine,
|
|
messageIndex,
|
|
priority: getDurableAssistantPriority(message.content || ""),
|
|
});
|
|
}
|
|
}
|
|
|
|
durableUserCandidates
|
|
.sort((left, right) => right.priority - left.priority || right.messageIndex - left.messageIndex)
|
|
.forEach((candidate) => {
|
|
const normalized = normalizeWhitespace(candidate.line);
|
|
if (!normalized || seen.has(normalized)) return;
|
|
const nextChars = durableChars.value + normalized.length;
|
|
if (nextChars > MAX_DURABLE_USER_CONTEXT_CHARS) return;
|
|
seen.add(normalized);
|
|
selectedDurableUserLines.push(candidate);
|
|
durableChars.value = nextChars;
|
|
});
|
|
|
|
durableAssistantCandidates
|
|
.sort((left, right) => right.priority - left.priority || right.messageIndex - left.messageIndex)
|
|
.forEach((candidate) => {
|
|
const normalized = normalizeWhitespace(candidate.line);
|
|
if (!normalized || seen.has(normalized)) return;
|
|
const nextChars = durableAssistantChars.value + normalized.length;
|
|
if (nextChars > MAX_DURABLE_ASSISTANT_CONTEXT_CHARS) return;
|
|
seen.add(normalized);
|
|
selectedDurableAssistantLines.push(candidate);
|
|
durableAssistantChars.value = nextChars;
|
|
});
|
|
|
|
const durableUserLines = selectedDurableUserLines
|
|
.sort((left, right) => left.messageIndex - right.messageIndex)
|
|
.map((candidate) => candidate.line);
|
|
const durableAssistantLines = selectedDurableAssistantLines
|
|
.sort((left, right) => left.messageIndex - right.messageIndex)
|
|
.map((candidate) => candidate.line);
|
|
|
|
for (const line of [...durableUserLines, ...durableAssistantLines]) {
|
|
seen.add(normalizeWhitespace(line));
|
|
}
|
|
|
|
// Skip messages that are already appended verbatim in the raw window —
|
|
// otherwise the same last-6 turns get summarized here AND re-sent as
|
|
// raw, doubling the budget cost of important user turns / large tool
|
|
// output and crowding out older durable context the replay is meant
|
|
// to preserve. Matches the recentRawSourceIds skip in the durable pass.
|
|
for (const message of scanned) {
|
|
if (recentRawSourceIds.has(message.id)) continue;
|
|
for (const line of summarizeMessage(message, toolCallIndex)) {
|
|
appendUniqueLine(summaryLines, seen, line, MAX_RECENT_SUMMARY_CONTEXT_CHARS, summaryChars);
|
|
}
|
|
}
|
|
|
|
if (!durableUserLines.length && !durableAssistantLines.length && !summaryLines.length) return [];
|
|
|
|
const contentLines = [
|
|
"[Compact prior Netcatty UI context]",
|
|
"The external ACP agent may already have its own persisted session context. Use this compact Netcatty UI context only as fallback/background, and prefer the current user request when there is any conflict.",
|
|
];
|
|
if (durableUserLines.length) {
|
|
contentLines.push("Earlier user requests that may still apply:");
|
|
contentLines.push(...durableUserLines.map((line) => `- ${line}`));
|
|
}
|
|
if (durableAssistantLines.length) {
|
|
contentLines.push("Earlier assistant context that may still matter:");
|
|
contentLines.push(...durableAssistantLines.map((line) => `- ${line}`));
|
|
}
|
|
if (summaryLines.length) {
|
|
contentLines.push("Recent noteworthy context:");
|
|
contentLines.push(...summaryLines.map((line) => `- ${line}`));
|
|
}
|
|
|
|
return [{
|
|
role: "user",
|
|
content: truncateText(
|
|
contentLines.join("\n"),
|
|
MAX_COMPACT_CONTEXT_CHARS,
|
|
),
|
|
}];
|
|
}
|
|
|
|
/**
|
|
* Find the index of the first message to include in the scan window,
|
|
* bounded by MAX_DURABLE_SCAN_TURNS user turns (not raw message count).
|
|
* Walking backwards stops at the target turn count, so the cost is
|
|
* bounded even when the transcript is huge.
|
|
*/
|
|
function computeDurableScanStart(messages: ChatMessage[]): number {
|
|
let userTurns = 0;
|
|
for (let i = messages.length - 1; i >= 0; i -= 1) {
|
|
if (messages[i].role === "user") {
|
|
userTurns += 1;
|
|
if (userTurns >= MAX_DURABLE_SCAN_TURNS) return i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
export function buildAcpHistoryMessages(messages: ChatMessage[]): AcpHistoryMessage[] {
|
|
// Compute the scan start once, then do all subsequent work over the
|
|
// already-sliced tail. This avoids O(N) walks over the whole transcript
|
|
// on every send — previously buildToolCallIndex + the flatMap-to-take-
|
|
// last-6 raw history both traversed every message in the chat.
|
|
const durableScanStart = computeDurableScanStart(messages);
|
|
const scannedTail = messages.slice(durableScanStart);
|
|
|
|
// The tool-call provenance index only needs entries for tool_results
|
|
// that might appear in our output. Building from the scanned tail is
|
|
// correct for any tool_result whose paired assistant tool_call is
|
|
// also within the window, which covers >99% of realistic patterns
|
|
// (tool_calls and tool_results are always adjacent or near-adjacent).
|
|
// If an ancient tool_call's result stays within the window while the
|
|
// call itself is outside, that single result loses its [from X(Y)]
|
|
// label — an acceptable trade for eliminating the per-send O(N) walk.
|
|
const toolCallIndex = buildToolCallIndex(scannedTail);
|
|
|
|
const rawHistory = scannedTail
|
|
.flatMap((message) => toRawHistoryMessage(message, toolCallIndex))
|
|
.slice(-MAX_RECENT_RAW_MESSAGES);
|
|
const compactContext = buildCompactContext(
|
|
messages,
|
|
durableScanStart,
|
|
new Set(rawHistory.map((message) => message.sourceId)),
|
|
toolCallIndex,
|
|
);
|
|
const recentRaw = rawHistory.map(({ role, content }) => ({ role, content }));
|
|
|
|
return [...compactContext, ...recentRaw];
|
|
}
|
|
|
|
export function buildAcpHistoryMessagesForBridge(
|
|
messages: ChatMessage[],
|
|
_existingSessionId?: string | null,
|
|
): AcpHistoryMessage[] | undefined {
|
|
// The main process bridge only consumes this payload during stale-session
|
|
// fallback replay, so keep it available even when a session id exists.
|
|
const historyMessages = buildAcpHistoryMessages(messages);
|
|
return historyMessages.length ? historyMessages : undefined;
|
|
}
|