775 lines
23 KiB
JavaScript
775 lines
23 KiB
JavaScript
/**
|
|
* Advanced context-window compaction for /bin/agent.
|
|
* Tiered rollover: shrink fat tool payloads → digest older turns →
|
|
* rolling summary message → hard trim fallback.
|
|
*/
|
|
|
|
/**
|
|
* @param {unknown} value
|
|
*/
|
|
function bareAgentCompactEstimateTokens(value) {
|
|
if (typeof bareAgentEstimateTokens === 'function') {
|
|
return bareAgentEstimateTokens(value)
|
|
}
|
|
try {
|
|
return Math.max(0, Math.ceil(JSON.stringify(value == null ? '' : value).length / 4))
|
|
} catch {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {unknown} msg
|
|
* @returns {string}
|
|
*/
|
|
function bareAgentMessagePlainText(msg) {
|
|
if (!msg || typeof msg !== 'object') return ''
|
|
const m = /** @type {Record<string, unknown>} */ (msg)
|
|
const c = m.content
|
|
if (typeof c === 'string') return c
|
|
if (Array.isArray(c)) {
|
|
/** @type {string[]} */
|
|
const parts = []
|
|
for (const part of c) {
|
|
if (typeof part === 'string') parts.push(part)
|
|
else if (part && typeof part === 'object') {
|
|
const p = /** @type {Record<string, unknown>} */ (part)
|
|
if (typeof p.text === 'string') parts.push(p.text)
|
|
else if (typeof p.content === 'string') parts.push(p.content)
|
|
}
|
|
}
|
|
return parts.join('\n')
|
|
}
|
|
if (m.tool_calls && Array.isArray(m.tool_calls)) {
|
|
/** @type {string[]} */
|
|
const names = []
|
|
for (const tc of m.tool_calls) {
|
|
if (!tc || typeof tc !== 'object') continue
|
|
const fn = /** @type {Record<string, unknown>} */ (tc).function
|
|
if (fn && typeof fn === 'object') {
|
|
const n = /** @type {Record<string, unknown>} */ (fn).name
|
|
if (typeof n === 'string' && n) names.push(n)
|
|
}
|
|
}
|
|
if (names.length) return 'tool_calls: ' + names.join(', ')
|
|
}
|
|
return ''
|
|
}
|
|
|
|
/**
|
|
* @param {string} s
|
|
* @param {number} max
|
|
*/
|
|
function bareAgentClipText(s, max) {
|
|
const t = String(s || '').replace(/\s+/g, ' ').trim()
|
|
if (t.length <= max) return t
|
|
if (max < 24) return t.slice(0, max)
|
|
const head = Math.floor(max * 0.62)
|
|
const tail = Math.max(8, max - head - 5)
|
|
return t.slice(0, head) + ' … ' + t.slice(-tail)
|
|
}
|
|
|
|
/**
|
|
* Shrink oversized tool / assistant payloads in-place (clone).
|
|
* @param {unknown[]} msgs
|
|
* @param {number} toolMaxChars
|
|
* @returns {unknown[]}
|
|
*/
|
|
function bareAgentShrinkFatMessages(msgs, toolMaxChars) {
|
|
const max = Math.max(240, Math.floor(toolMaxChars || 1600))
|
|
/** @type {unknown[]} */
|
|
const out = []
|
|
for (const msg of msgs) {
|
|
if (!msg || typeof msg !== 'object') {
|
|
out.push(msg)
|
|
continue
|
|
}
|
|
const m = /** @type {Record<string, unknown>} */ (msg)
|
|
const role = String(m.role || '')
|
|
if (role === 'tool' && typeof m.content === 'string' && m.content.length > max) {
|
|
out.push({
|
|
...m,
|
|
content:
|
|
bareAgentClipText(m.content, max) +
|
|
'\n[tool output compacted ' +
|
|
String(m.content.length) +
|
|
'→' +
|
|
String(max) +
|
|
' chars]'
|
|
})
|
|
continue
|
|
}
|
|
if (
|
|
(role === 'assistant' || role === 'user') &&
|
|
typeof m.content === 'string' &&
|
|
m.content.length > max * 4
|
|
) {
|
|
out.push({
|
|
...m,
|
|
content:
|
|
bareAgentClipText(m.content, max * 4) +
|
|
'\n[message compacted]'
|
|
})
|
|
continue
|
|
}
|
|
out.push(msg)
|
|
}
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* Group chat into [system?] + turn groups (user | assistant+tools*).
|
|
* @param {unknown[]} msgs
|
|
* @returns {{ system: unknown | null, groups: unknown[][] }}
|
|
*/
|
|
function bareAgentGroupMessageTurns(msgs) {
|
|
/** @type {unknown | null} */
|
|
let system = null
|
|
/** @type {unknown[][]} */
|
|
const groups = []
|
|
/** @type {unknown[]} */
|
|
let cur = []
|
|
|
|
function flush() {
|
|
if (cur.length) {
|
|
groups.push(cur)
|
|
cur = []
|
|
}
|
|
}
|
|
|
|
for (const msg of Array.isArray(msgs) ? msgs : []) {
|
|
if (!msg || typeof msg !== 'object') continue
|
|
const role = String(/** @type {Record<string, unknown>} */ (msg).role || '')
|
|
if (role === 'system' && system == null && groups.length === 0 && !cur.length) {
|
|
system = msg
|
|
continue
|
|
}
|
|
if (role === 'user') {
|
|
flush()
|
|
cur = [msg]
|
|
continue
|
|
}
|
|
if (role === 'assistant' || role === 'tool') {
|
|
if (!cur.length) cur = [msg]
|
|
else cur.push(msg)
|
|
continue
|
|
}
|
|
// unknown roles — attach to current or solo group
|
|
if (!cur.length) cur = [msg]
|
|
else cur.push(msg)
|
|
}
|
|
flush()
|
|
return { system, groups }
|
|
}
|
|
|
|
/**
|
|
* True if message is a prior compaction summary we injected.
|
|
* @param {unknown} msg
|
|
*/
|
|
function bareAgentIsCompactionMessage(msg) {
|
|
if (!msg || typeof msg !== 'object') return false
|
|
const m = /** @type {Record<string, unknown>} */ (msg)
|
|
if (m.bare_os_compaction === true) return true
|
|
const c = typeof m.content === 'string' ? m.content : ''
|
|
const t = c.trim()
|
|
return (
|
|
String(m.role || '') === 'user' &&
|
|
(/^\[context compaction\]/i.test(t) ||
|
|
/^This session is being continued from a previous conversation/i.test(t) ||
|
|
m.bare_os_reminder === true)
|
|
)
|
|
}
|
|
|
|
/** Grok-style continuation carrier minimum (extractive; slightly below LLM 500). */
|
|
var BARE_AGENT_MIN_SUMMARY_SEED_CHARS = 160
|
|
|
|
/**
|
|
* Strip drafting tags and neutralize leftover <summary>/<analysis> tokens
|
|
* so they cannot prime the next turn (Grok format_compact_summary).
|
|
* @param {string} raw
|
|
*/
|
|
function bareAgentFormatCompactSummary(raw) {
|
|
let result = String(raw || '')
|
|
result = result.replace(/<analysis>[\s\S]*?<\/analysis>/gi, '')
|
|
result = result.replace(/<\/?summary>/gi, '')
|
|
result = result
|
|
.replace(/<\/summary>/g, '<\u200b/summary>')
|
|
.replace(/<summary>/g, '<\u200bsummary>')
|
|
.replace(/<\/analysis>/g, '<\u200b/analysis>')
|
|
.replace(/<analysis>/g, '<\u200banalysis>')
|
|
while (result.indexOf('\n\n\n') >= 0) result = result.replace(/\n\n\n/g, '\n\n')
|
|
return result.trim()
|
|
}
|
|
|
|
/**
|
|
* @param {string} raw
|
|
*/
|
|
function bareAgentFormatCompactSummaryContent(raw) {
|
|
const cleaned = bareAgentFormatCompactSummary(raw)
|
|
return (
|
|
'This session is being continued from a previous conversation that ran out of context. ' +
|
|
'The summary below covers the earlier portion of the conversation.\n\n' +
|
|
cleaned
|
|
)
|
|
}
|
|
|
|
/**
|
|
* @param {string} text
|
|
*/
|
|
function bareAgentWrapUserQuery(text) {
|
|
const t = String(text || '').trim()
|
|
if (!t) return ''
|
|
if (/^<user_query>/.test(t)) return t
|
|
return '<user_query>\n' + t + '\n</user_query>'
|
|
}
|
|
|
|
/**
|
|
* @param {string} raw
|
|
*/
|
|
function bareAgentIsDegenerateSummary(raw) {
|
|
return bareAgentFormatCompactSummary(raw).length < BARE_AGENT_MIN_SUMMARY_SEED_CHARS
|
|
}
|
|
|
|
/**
|
|
* Collect unique path-like and command tokens for the artifacts section.
|
|
* @param {string} text
|
|
* @param {number} max
|
|
*/
|
|
function bareAgentExtractPathTokens(text, max) {
|
|
const s = String(text || '')
|
|
const found = []
|
|
const re = /(?:~|\/)[A-Za-z0-9._+\-@/]+/g
|
|
let m
|
|
while ((m = re.exec(s)) && found.length < max) {
|
|
const p = m[0]
|
|
if (p.length < 3 || found.indexOf(p) >= 0) continue
|
|
found.push(p)
|
|
}
|
|
return found
|
|
}
|
|
|
|
/**
|
|
* One-line digest for a message (extractive).
|
|
* @param {unknown} msg
|
|
* @param {number} max
|
|
*/
|
|
function bareAgentDigestMessage(msg, max) {
|
|
if (!msg || typeof msg !== 'object') return ''
|
|
const m = /** @type {Record<string, unknown>} */ (msg)
|
|
const role = String(m.role || '?')
|
|
const text = bareAgentMessagePlainText(m)
|
|
if (role === 'tool') {
|
|
const name =
|
|
typeof m.name === 'string'
|
|
? m.name
|
|
: typeof m.tool_call_id === 'string'
|
|
? m.tool_call_id.slice(0, 12)
|
|
: 'tool'
|
|
return '- tool:' + name + ' ' + bareAgentClipText(text, Math.max(40, max - 24))
|
|
}
|
|
if (role === 'assistant') {
|
|
return '- assistant ' + bareAgentClipText(text || '(tools only)', max)
|
|
}
|
|
if (role === 'user') {
|
|
if (bareAgentIsCompactionMessage(m)) {
|
|
return '- prior-compaction ' + bareAgentClipText(text.replace(/^\[context compaction\][^\n]*\n?/i, ''), max)
|
|
}
|
|
return '- user ' + bareAgentClipText(text, max)
|
|
}
|
|
return '- ' + role + ' ' + bareAgentClipText(text, max)
|
|
}
|
|
|
|
/**
|
|
* Grok-style 7-section extractive summary of older turn groups.
|
|
* @param {unknown[][]} groups
|
|
* @param {{ maxChars?: number, perMsg?: number }} [opts]
|
|
*/
|
|
function bareAgentBuildStructuredSummary(groups, opts) {
|
|
const maxChars = Math.max(400, Math.floor((opts && opts.maxChars) || 3500))
|
|
const perMsg = Math.max(60, Math.floor((opts && opts.perMsg) || 180))
|
|
/** @type {string[]} */
|
|
const userMsgs = []
|
|
/** @type {string[]} */
|
|
const tools = []
|
|
/** @type {string[]} */
|
|
const errors = []
|
|
/** @type {string[]} */
|
|
const solves = []
|
|
/** @type {string[]} */
|
|
const concepts = []
|
|
/** @type {string[]} */
|
|
const files = []
|
|
|
|
function pushUnique(arr, s, cap) {
|
|
const t = String(s || '').trim()
|
|
if (!t || arr.indexOf(t) >= 0) return
|
|
if (arr.length >= cap) return
|
|
arr.push(t)
|
|
}
|
|
|
|
for (const g of groups) {
|
|
for (const msg of g) {
|
|
if (!msg || typeof msg !== 'object') continue
|
|
const m = /** @type {Record<string, unknown>} */ (msg)
|
|
const role = String(m.role || '')
|
|
const text = bareAgentMessagePlainText(m)
|
|
for (const p of bareAgentExtractPathTokens(text, 8)) pushUnique(files, p, 24)
|
|
if (role === 'user' && !bareAgentIsCompactionMessage(m)) {
|
|
pushUnique(userMsgs, bareAgentClipText(text, perMsg + 80), 16)
|
|
} else if (role === 'tool') {
|
|
const name = typeof m.name === 'string' ? m.name : 'tool'
|
|
pushUnique(tools, name + ': ' + bareAgentClipText(text, perMsg), 20)
|
|
if (/error|fail|denied|not found|ENOENT|EXIT:[1-9]/i.test(text)) {
|
|
pushUnique(errors, name + ' ' + bareAgentClipText(text, 140), 12)
|
|
}
|
|
} else if (role === 'assistant') {
|
|
if (m.tool_calls && Array.isArray(m.tool_calls)) {
|
|
for (const tc of m.tool_calls) {
|
|
if (!tc || typeof tc !== 'object') continue
|
|
const fn = /** @type {Record<string, unknown>} */ (tc).function
|
|
if (fn && typeof fn === 'object') {
|
|
const n = /** @type {Record<string, unknown>} */ (fn).name
|
|
if (typeof n === 'string' && n) pushUnique(concepts, n, 16)
|
|
}
|
|
}
|
|
}
|
|
if (text) pushUnique(solves, bareAgentClipText(text, perMsg), 12)
|
|
}
|
|
}
|
|
}
|
|
|
|
const intent = userMsgs.length ? userMsgs[0] : '(no explicit user request in compacted prefix)'
|
|
/** @type {string[]} */
|
|
const lines = [
|
|
'1. Primary Request and Intent:',
|
|
' ' + intent,
|
|
'',
|
|
'2. Key Technical Concepts:',
|
|
concepts.length ? concepts.map((c) => ' - ' + c).join('\n') : ' - (none extracted)',
|
|
'',
|
|
'3. Tool Usage & Verification:',
|
|
tools.length ? tools.map((c) => ' - ' + c).join('\n') : ' - (none)',
|
|
'',
|
|
'4. Files & Code Artifacts:',
|
|
files.length ? files.map((c) => ' - ' + c).join('\n') : ' - (none)',
|
|
'',
|
|
'5. Errors and Fixes:',
|
|
errors.length ? errors.map((c) => ' - ' + c).join('\n') : ' - (none recorded)',
|
|
'',
|
|
'6. Problem Solving:',
|
|
solves.length ? solves.map((c) => ' - ' + c).join('\n') : ' - (in progress)',
|
|
'',
|
|
'7. User Messages:',
|
|
userMsgs.length ? userMsgs.map((c) => ' - ' + c).join('\n') : ' - (none)'
|
|
]
|
|
let body = lines.join('\n')
|
|
if (body.length > maxChars) body = body.slice(0, maxChars - 20) + '\n… truncated'
|
|
return body
|
|
}
|
|
|
|
/**
|
|
* Build a rolling summary from older turn groups.
|
|
* @param {unknown[][]} groups
|
|
* @param {{ maxChars?: number, perMsg?: number }} [opts]
|
|
*/
|
|
function bareAgentBuildCompactionSummary(groups, opts) {
|
|
const structured = bareAgentBuildStructuredSummary(groups, opts)
|
|
return bareAgentFormatCompactSummaryContent(structured)
|
|
}
|
|
|
|
/**
|
|
* Post-compaction <system-reminder> (Grok reminder.rs analogue).
|
|
* @param {{
|
|
* autonomous?: { active?: boolean, goal?: string, status?: string, remainingMs?: number },
|
|
* droppedGroups?: number,
|
|
* afterTokens?: number,
|
|
* budget?: number
|
|
* }} [opts]
|
|
*/
|
|
function bareAgentBuildSystemReminder(opts) {
|
|
const o = opts && typeof opts === 'object' ? opts : {}
|
|
/** @type {string[]} */
|
|
const parts = []
|
|
const auto = o.autonomous
|
|
if (auto && auto.active) {
|
|
parts.push(
|
|
'Autonomous run: ' +
|
|
String(auto.goal || '(goal)').slice(0, 240) +
|
|
' (status=' +
|
|
String(auto.status || 'running') +
|
|
(typeof auto.remainingMs === 'number'
|
|
? ', remaining=' + String(Math.max(0, Math.round(auto.remainingMs / 1000))) + 's'
|
|
: '') +
|
|
'). Keep using tools until task_complete.'
|
|
)
|
|
}
|
|
if (typeof o.droppedGroups === 'number' && o.droppedGroups > 0) {
|
|
parts.push(
|
|
'Context compacted: ' +
|
|
String(o.droppedGroups) +
|
|
' older turns summarized. Recent messages after the last user query are verbatim.'
|
|
)
|
|
}
|
|
if (typeof o.afterTokens === 'number' && typeof o.budget === 'number' && o.budget > 0) {
|
|
parts.push(
|
|
'Context usage after compact: ' +
|
|
String(o.afterTokens) +
|
|
'/' +
|
|
String(o.budget) +
|
|
' tokens (est.).'
|
|
)
|
|
}
|
|
if (!parts.length) return ''
|
|
return '<system-reminder>\n' + parts.join('\n') + '\n</system-reminder>'
|
|
}
|
|
|
|
/**
|
|
* Grok assemble: [system, last user query, recent after that turn, summary, reminder].
|
|
* @param {{
|
|
* system?: unknown | null,
|
|
* lastUserQuery?: string,
|
|
* recent?: unknown[],
|
|
* summaryText?: string,
|
|
* reminder?: string
|
|
* }} parts
|
|
* @returns {unknown[]}
|
|
*/
|
|
function bareAgentAssembleCompactedHistory(parts) {
|
|
const p = parts && typeof parts === 'object' ? parts : {}
|
|
/** @type {unknown[]} */
|
|
const out = []
|
|
if (p.system) out.push(p.system)
|
|
const q = String(p.lastUserQuery || '').trim()
|
|
if (q) {
|
|
out.push({
|
|
role: 'user',
|
|
content: bareAgentWrapUserQuery(q),
|
|
bare_os_user_query: true
|
|
})
|
|
}
|
|
if (Array.isArray(p.recent)) {
|
|
for (const m of p.recent) out.push(m)
|
|
}
|
|
const summary = String(p.summaryText || '').trim()
|
|
if (summary) {
|
|
out.push({
|
|
role: 'user',
|
|
content: summary,
|
|
bare_os_compaction: true
|
|
})
|
|
}
|
|
const rem = String(p.reminder || '').trim()
|
|
if (rem) {
|
|
out.push({
|
|
role: 'user',
|
|
content: rem,
|
|
bare_os_compaction: true,
|
|
bare_os_reminder: true
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* Last non-compaction user text + messages after that turn.
|
|
* @param {unknown[][]} groups
|
|
*/
|
|
function bareAgentSplitLastUserAndRecent(groups) {
|
|
let lastUserIdx = -1
|
|
let lastUserText = ''
|
|
for (let i = groups.length - 1; i >= 0; i--) {
|
|
const g = groups[i]
|
|
if (!g || !g.length) continue
|
|
const first = g[0]
|
|
if (!first || typeof first !== 'object') continue
|
|
const m = /** @type {Record<string, unknown>} */ (first)
|
|
if (String(m.role || '') !== 'user') continue
|
|
if (bareAgentIsCompactionMessage(m)) continue
|
|
lastUserIdx = i
|
|
lastUserText = bareAgentMessagePlainText(m)
|
|
break
|
|
}
|
|
if (lastUserIdx < 0) {
|
|
return { lastUserText: '', older: groups, recent: /** @type {unknown[]} */ ([]) }
|
|
}
|
|
const older = groups.slice(0, lastUserIdx)
|
|
/** @type {unknown[]} */
|
|
const recent = []
|
|
const lastGroup = groups[lastUserIdx] || []
|
|
for (let i = 1; i < lastGroup.length; i++) recent.push(lastGroup[i])
|
|
for (let i = lastUserIdx + 1; i < groups.length; i++) {
|
|
for (const m of groups[i]) recent.push(m)
|
|
}
|
|
return { lastUserText, older, recent }
|
|
}
|
|
|
|
/**
|
|
* @param {unknown[]} msgs
|
|
* @param {number} ctxSize
|
|
* @param {{
|
|
* tools?: unknown[],
|
|
* reserveCompletion?: number,
|
|
* keepRecent?: number,
|
|
* toolMaxChars?: number,
|
|
* summaryMaxChars?: number,
|
|
* softRatio?: number,
|
|
* mode?: 'auto' | 'off' | 'aggressive',
|
|
* autonomous?: { active?: boolean, goal?: string, status?: string, remainingMs?: number }
|
|
* }} [opts]
|
|
* @returns {{
|
|
* messages: unknown[],
|
|
* meta: {
|
|
* compacted: boolean,
|
|
* mode: string,
|
|
* beforeTokens: number,
|
|
* afterTokens: number,
|
|
* budget: number,
|
|
* droppedGroups: number,
|
|
* tiers: string[]
|
|
* }
|
|
* }}
|
|
*/
|
|
function bareAgentCompactMessagesForCtx(msgs, ctxSize, opts) {
|
|
const modeRaw = String((opts && opts.mode) || 'auto').trim().toLowerCase()
|
|
const mode =
|
|
modeRaw === 'off' || modeRaw === 'aggressive' ? modeRaw : 'auto'
|
|
/** @type {string[]} */
|
|
const tiers = []
|
|
|
|
const ctx = Math.max(2048, Math.floor(Number(ctxSize) || 4096))
|
|
const reserve =
|
|
opts && Number.isFinite(Number(opts.reserveCompletion))
|
|
? Math.max(256, Math.floor(Number(opts.reserveCompletion)))
|
|
: Math.min(2048, Math.max(256, Math.floor(ctx * 0.12)))
|
|
const toolsTok = bareAgentCompactEstimateTokens(
|
|
opts && Array.isArray(opts.tools) && opts.tools.length ? opts.tools : []
|
|
)
|
|
const budget = Math.max(512, ctx - reserve - toolsTok)
|
|
const softRatio =
|
|
mode === 'aggressive'
|
|
? 0.7
|
|
: Math.min(0.95, Math.max(0.55, Number(opts && opts.softRatio) || 0.85))
|
|
const softBudget = Math.floor(budget * softRatio)
|
|
|
|
const keepRecentDefault = mode === 'aggressive' ? 4 : 8
|
|
let keepRecent = Math.max(
|
|
2,
|
|
Math.floor(
|
|
Number(opts && opts.keepRecent) > 0
|
|
? Number(opts.keepRecent)
|
|
: keepRecentDefault
|
|
)
|
|
)
|
|
const toolMax =
|
|
mode === 'aggressive'
|
|
? Math.min(900, Number(opts && opts.toolMaxChars) || 900)
|
|
: Math.max(400, Number(opts && opts.toolMaxChars) || 1600)
|
|
const summaryMax =
|
|
mode === 'aggressive'
|
|
? Math.min(2200, Number(opts && opts.summaryMaxChars) || 2200)
|
|
: Math.max(800, Number(opts && opts.summaryMaxChars) || 3500)
|
|
|
|
const input = Array.isArray(msgs) ? msgs.slice() : []
|
|
const beforeTokens = bareAgentCompactEstimateTokens(input)
|
|
|
|
if (mode === 'off') {
|
|
const trimmed =
|
|
typeof bareAgentTrimMessagesForCtx === 'function'
|
|
? bareAgentTrimMessagesForCtx(input, ctxSize, opts)
|
|
: input
|
|
return {
|
|
messages: trimmed,
|
|
meta: {
|
|
compacted: false,
|
|
mode,
|
|
beforeTokens,
|
|
afterTokens: bareAgentCompactEstimateTokens(trimmed),
|
|
budget,
|
|
droppedGroups: 0,
|
|
tiers: ['off']
|
|
}
|
|
}
|
|
}
|
|
|
|
/** @type {unknown[]} */
|
|
let out = bareAgentShrinkFatMessages(input, toolMax)
|
|
if (out !== input && bareAgentCompactEstimateTokens(out) < beforeTokens) {
|
|
tiers.push('shrink-tools')
|
|
}
|
|
|
|
// Already fits soft budget — keep light shrink only.
|
|
if (bareAgentCompactEstimateTokens(out) <= softBudget) {
|
|
return {
|
|
messages: out,
|
|
meta: {
|
|
compacted: tiers.length > 0,
|
|
mode,
|
|
beforeTokens,
|
|
afterTokens: bareAgentCompactEstimateTokens(out),
|
|
budget,
|
|
droppedGroups: 0,
|
|
tiers: tiers.length ? tiers : ['noop']
|
|
}
|
|
}
|
|
}
|
|
|
|
const { system, groups } = bareAgentGroupMessageTurns(out)
|
|
let droppedGroups = 0
|
|
|
|
function applyFullReplace(allGroups, keep) {
|
|
const split = bareAgentSplitLastUserAndRecent(allGroups)
|
|
/** @type {unknown[][]} */
|
|
let older = split.older
|
|
/** @type {unknown[]} */
|
|
let recent = split.recent
|
|
// If "recent after last user" is huge, keep only the tail of those messages
|
|
// by regrouping them and folding extras into older.
|
|
if (keep > 0 && recent.length > keep * 4) {
|
|
const tail = recent.slice(-(keep * 3))
|
|
const head = recent.slice(0, Math.max(0, recent.length - tail.length))
|
|
if (head.length) older = older.concat([head])
|
|
recent = tail
|
|
}
|
|
const summaryText = bareAgentBuildCompactionSummary(older, {
|
|
maxChars: summaryMax,
|
|
perMsg: mode === 'aggressive' ? 120 : 180
|
|
})
|
|
if (older.length && bareAgentIsDegenerateSummary(summaryText)) {
|
|
tiers.push('degenerate-keep')
|
|
return null
|
|
}
|
|
const reminder = bareAgentBuildSystemReminder({
|
|
autonomous: opts && opts.autonomous,
|
|
droppedGroups: older.length,
|
|
afterTokens: 0,
|
|
budget
|
|
})
|
|
droppedGroups += older.length
|
|
return bareAgentAssembleCompactedHistory({
|
|
system: system,
|
|
lastUserQuery: split.lastUserText,
|
|
recent: recent,
|
|
summaryText: summaryText,
|
|
reminder: reminder
|
|
})
|
|
}
|
|
|
|
if (groups.length > keepRecent) {
|
|
const next = applyFullReplace(groups, keepRecent)
|
|
if (next) {
|
|
out = next
|
|
tiers.push('full-replace')
|
|
}
|
|
}
|
|
|
|
let guard = 0
|
|
while (
|
|
bareAgentCompactEstimateTokens(out) > budget &&
|
|
keepRecent > 2 &&
|
|
guard < 8
|
|
) {
|
|
keepRecent--
|
|
guard++
|
|
const again = bareAgentGroupMessageTurns(out)
|
|
if (again.groups.length <= keepRecent) break
|
|
const next = applyFullReplace(again.groups, keepRecent)
|
|
if (!next) break
|
|
out = next
|
|
tiers.push('tighten-keep=' + String(keepRecent))
|
|
}
|
|
|
|
// Hard fallback
|
|
if (bareAgentCompactEstimateTokens(out) > budget) {
|
|
tiers.push('hard-trim')
|
|
out =
|
|
typeof bareAgentTrimMessagesForCtx === 'function'
|
|
? bareAgentTrimMessagesForCtx(out, ctxSize, opts)
|
|
: out
|
|
}
|
|
|
|
const afterTokens = bareAgentCompactEstimateTokens(out)
|
|
return {
|
|
messages: out,
|
|
meta: {
|
|
compacted: tiers.some((t) => t !== 'noop'),
|
|
mode,
|
|
beforeTokens,
|
|
afterTokens,
|
|
budget,
|
|
droppedGroups,
|
|
tiers
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Disk history compaction: shrink tools + optional rolling summary when huge.
|
|
* @param {unknown[]} msgs
|
|
* @param {number} maxBytes
|
|
* @param {{ keepRecent?: number }} [opts]
|
|
*/
|
|
function bareAgentCompactMessagesForDisk(msgs, maxBytes, opts) {
|
|
const cap = Math.max(20_000, Math.floor(maxBytes || 500_000))
|
|
let out = bareAgentShrinkFatMessages(
|
|
Array.isArray(msgs) ? msgs : [],
|
|
2400
|
|
)
|
|
if (JSON.stringify(out).length <= cap) return out
|
|
|
|
// Approximate tokens from byte budget (chars/4).
|
|
const approxCtx = Math.max(4096, Math.floor(cap / 4))
|
|
const packed = bareAgentCompactMessagesForCtx(out, approxCtx, {
|
|
mode: 'aggressive',
|
|
keepRecent: (opts && opts.keepRecent) || 12,
|
|
reserveCompletion: 256,
|
|
toolMaxChars: 1200,
|
|
summaryMaxChars: 6000
|
|
})
|
|
out = packed.messages
|
|
if (
|
|
typeof bareAgentTrimMessages === 'function' &&
|
|
JSON.stringify(out).length > cap
|
|
) {
|
|
out = bareAgentTrimMessages(out, cap)
|
|
}
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* Resolve compaction settings from agent config + env.
|
|
* @param {Record<string, unknown>} cfg
|
|
* @param {Record<string, string>} [env]
|
|
*/
|
|
function bareAgentCompactionSettings(cfg, env) {
|
|
const e = env && typeof env === 'object' ? env : {}
|
|
const envMode = String(e.BARE_OS_AGENT_COMPACTION || '').trim().toLowerCase()
|
|
const cfgMode = String(
|
|
(cfg && cfg.context_compaction) || ''
|
|
)
|
|
.trim()
|
|
.toLowerCase()
|
|
let mode = envMode || cfgMode || 'auto'
|
|
if (mode !== 'off' && mode !== 'aggressive' && mode !== 'auto') mode = 'auto'
|
|
const keepRecent = Number(
|
|
e.BARE_OS_AGENT_COMPACTION_KEEP ||
|
|
(cfg && cfg.compaction_keep_recent) ||
|
|
0
|
|
)
|
|
const toolMaxChars = Number(
|
|
e.BARE_OS_AGENT_COMPACTION_TOOL_CHARS ||
|
|
(cfg && cfg.compaction_tool_chars) ||
|
|
0
|
|
)
|
|
return {
|
|
mode: /** @type {'auto'|'off'|'aggressive'} */ (mode),
|
|
keepRecent:
|
|
Number.isFinite(keepRecent) && keepRecent > 0
|
|
? Math.min(32, Math.floor(keepRecent))
|
|
: undefined,
|
|
toolMaxChars:
|
|
Number.isFinite(toolMaxChars) && toolMaxChars > 0
|
|
? Math.min(8000, Math.floor(toolMaxChars))
|
|
: undefined
|
|
}
|
|
}
|