Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@d20e58a353428bbb26f9674994da1f18933ba782

Author: github-actions[bot]

bun.lock

@@ -1,5 +1,6 @@
 import {
   createBunByokConnectionStore,
+  withEffectiveByokLimits,
 } from '@codebuff/sdk'
 import { create } from 'zustand'
 
@@ -113,11 +114,13 @@ export function saveSelectedByokConnection(
   )
 }
 
-/** Resolve only at run start so the secret never reaches chat state or logs. */
+/** Resolve only at run start so the secret never reaches chat state or logs.
+ *  Untouched default limits become the provider-reported window (see
+ *  withEffectiveByokLimits), so a run does not compact every few tool calls. */
 export async function resolveByokConnection(
   selected: SelectedByokConnection,
 ): Promise<ResolvedByokConnection> {
-  return getCliByokStore().resolve(selected)
+  return withEffectiveByokLimits(await getCliByokStore().resolve(selected))
 }
 
 export function describeByokConnection(connection: Pick<ByokConnection, 'name' | 'provider' | 'model'>): string {

cli/src/utils/byok.ts

@@ -475,6 +475,70 @@ describe('compactContext in loopAgentSteps', () => {
     ).toBe(false)
   })
 
+  // Desktop BYOK, 2026-09-24..27 ("compacts every 3-5 turns"): a 32k-default
+  // connection's budget is 25,804 tokens and its threshold 20,643, while the
+  // prompt and tool catalog take ~15k. Compacting at the threshold landed
+  // right back under it, so the next read or two compacted again.
+  describe('a small window under a large fixed prompt', () => {
+    const smallWindow = {
+      ...baseTemplate,
+      systemPrompt: 'Follow the project conventions carefully. '.repeat(1_100),
+      compactContext: { maxContextLength: 25_804, cacheExpiryMs: null },
+    } as AgentTemplate
+    const withReads = (count: number): Message[] => {
+      const history: Message[] = [
+        { ...userMessage('review the files'), tags: ['USER_PROMPT'] },
+      ]
+      for (let i = 0; i < count; i++) {
+        history.push(
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: `read-${i}`,
+                toolName: 'read_files',
+                input: { paths: [`file${i}.ts`] },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            toolName: 'read_files',
+            toolCallId: `read-${i}`,
+            content: [
+              {
+                type: 'json',
+                value: [
+                  { path: `file${i}.ts`, content: `READ ${i} BODY `.repeat(400) },
+                ],
+              },
+            ],
+          },
+        )
+      }
+      return history
+    }
+
+    it('keeps working past the threshold instead of compacting futilely', async () => {
+      // ~15k fixed + ~6k of reads: over the 20,643 threshold, under the budget.
+      const result = await runLoop(smallWindow, withReads(4))
+      expect(runtimeImpl.promptAiSdkStream).toHaveBeenCalledTimes(1)
+      const sent = JSON.stringify(seenMessages[0])
+      expect(sent.includes('<conversation_summary>')).toBe(false)
+      expect(sent.includes('READ 0 BODY')).toBe(true)
+      expect(result.output.type).not.toBe('error')
+    })
+
+    it('still compacts at the hard budget', async () => {
+      const result = await runLoop(smallWindow, withReads(8))
+      const sent = JSON.stringify(seenMessages[0])
+      expect(sent.includes('<conversation_summary>')).toBe(true)
+      expect(sent.includes('review the files')).toBe(true)
+      expect(result.output.type).not.toBe('error')
+    })
+  })
+
   it('a null TTL opts out of the opportunistic trigger', async () => {
     await runLoop(
       { ...baseTemplate, compactContext: { cacheExpiryMs: null } },

packages/agent-runtime/src/__tests__/compact-context-loop.test.ts

@@ -1,5 +1,7 @@
 import { expect, test } from 'bun:test'
 import {
+  automaticCompactionIsWorthwhile,
+  compactedContextCeiling,
   compactWithModel,
   compactWithModelOrFallback,
   COMPACTION_TAG,
@@ -422,3 +424,57 @@ test('compactWithModelOrFallback still propagates cancellation', async () => {
     }),
   ).rejects.toThrow()
 })
+
+// Desktop BYOK, 2026-09-24..27: a connection on the untouched 32k default
+// compacts at 80% of 90% of (32,768 - 4,096) = 20,643 tokens, and the Desktop
+// agent's prompt and tool catalog alone are ~15-20k. The best any compaction
+// can do there lands back near the threshold, so firing at it compacted every
+// few tool calls, each pass summarizing the previous summary.
+test('an automatic compaction that cannot clear its own threshold is not worthwhile', () => {
+  const byokDefault = { maxContextLength: 25_804, thresholdTokens: 20_643 }
+  expect(
+    automaticCompactionIsWorthwhile({ messages, ...byokDefault, fixedTokenCount: 16_000 }),
+  ).toBe(false)
+  // The same window with a small fixed prompt has room to work after a pass.
+  expect(
+    automaticCompactionIsWorthwhile({ messages, ...byokDefault, fixedTokenCount: 3_000 }),
+  ).toBe(true)
+  // Hosted budgets are unaffected: 400k budget, 320k threshold.
+  expect(
+    automaticCompactionIsWorthwhile({
+      messages,
+      maxContextLength: 400_000,
+      thresholdTokens: 320_000,
+      fixedTokenCount: 20_000,
+    }),
+  ).toBe(true)
+  // The ceiling is the fixed prefix, the verbatim live request and the summary budget.
+  const ceiling = compactedContextCeiling({ messages, maxContextLength: 400_000, fixedTokenCount: 20_000 })
+  expect(ceiling).toBe(20_000 + countTokensMessages([messages[0]]) + 6_000)
+})
+
+test('an automatic fallback aims below the trigger instead of refilling the whole budget', async () => {
+  const failing = async function* (): ReturnType<PromptAiSdkStreamFn> {
+    throw new Error('connection reset')
+  }
+  const params = {
+    messages,
+    system: 'You are a coding agent.',
+    maxContextLength: 16_384,
+    fixedTokenCount: 500,
+    signal: new AbortController().signal,
+    stream: failing,
+    logger: noopLogger,
+  }
+  const whole = await compactWithModelOrFallback(params)
+  const aimed = await compactWithModelOrFallback({ ...params, fallbackTargetTokens: 1_500 })
+  expect(whole?.fallback).toBe(true)
+  expect(aimed?.fallback).toBe(true)
+  expect(aimed!.postTokens).toBeLessThanOrEqual(1_500)
+  expect(aimed!.postTokens).toBeLessThan(whole!.postTokens)
+  expect(JSON.stringify(aimed!.messages)).toContain('Compare the time units in a.ts and b.ts.')
+  // A target that cannot hold the live request falls back to the whole budget
+  // rather than leaving the history uncompacted.
+  const tooSmall = await compactWithModelOrFallback({ ...params, fallbackTargetTokens: 400 })
+  expect(tooSmall?.postTokens).toBe(whole!.postTokens)
+})

packages/agent-runtime/src/__tests__/model-compaction.test.ts

@@ -98,6 +98,87 @@ export function hasCompactableHistory(messages: Message[]): boolean {
   )
 }
 
+/** The messages a model compaction keeps verbatim after its summary: the
+ *  latest instructions and the live user request (with its steering). */
+function compactionSuffix(messages: Message[]): Message[] {
+  const lastPrompt = messages.findLastIndex((m) =>
+    m.tags?.includes('USER_PROMPT'),
+  )
+  let promptStart = lastPrompt
+  while (
+    promptStart > 0 &&
+    messages[promptStart - 1].tags?.includes('USER_PROMPT')
+  )
+    promptStart--
+  const live =
+    promptStart < 0
+      ? []
+      : messages
+          .slice(promptStart)
+          .filter((m) => m.tags?.includes('USER_PROMPT'))
+  const instructions = messages.findLast((m) =>
+    m.tags?.includes('INSTRUCTIONS_PROMPT'),
+  )
+  return [...(instructions ? [instructions] : []), ...live]
+}
+
+function compactionSummaryBudget(params: {
+  maxContextLength: number
+  fixedTokenCount: number
+  suffixTokens: number
+}): number {
+  return Math.min(
+    SUMMARY_LIMIT,
+    Math.floor(
+      (params.maxContextLength - params.fixedTokenCount - params.suffixTokens) /
+        3,
+    ),
+  )
+}
+
+/**
+ * The share of the trigger threshold a compaction's result may occupy for the
+ * automatic trigger to be worth firing. Above it, the next tool result or two
+ * crosses the threshold again and the run compacts its own summary.
+ */
+export const COMPACTION_LOW_WATER = 0.85
+
+/**
+ * The largest context a model compaction can leave behind: the fixed prefix
+ * (system prompt, tool schemas), the live request it keeps verbatim, and the
+ * summary budget it asks for. None of it is compactable, so when this is not
+ * comfortably under the threshold, compacting at the threshold only buys a
+ * few thousand tokens before the next one: a 32k BYOK window with ~16k of
+ * Desktop tool schemas compacted every few tool calls, each pass summarizing
+ * the last summary.
+ */
+export function compactedContextCeiling(params: {
+  messages: Message[]
+  maxContextLength: number
+  fixedTokenCount: number
+}): number {
+  const suffixTokens = countTokensMessages(compactionSuffix(params.messages))
+  const summaryBudget = compactionSummaryBudget({ ...params, suffixTokens })
+  return params.fixedTokenCount + suffixTokens + Math.max(0, summaryBudget)
+}
+
+/**
+ * Whether an automatic compaction at `thresholdTokens` leaves real room to
+ * work in. When it cannot, the run keeps its history until the hard budget,
+ * where compaction is no longer optional.
+ */
+export function automaticCompactionIsWorthwhile(params: {
+  messages: Message[]
+  maxContextLength: number
+  thresholdTokens: number
+  fixedTokenCount: number
+}): boolean {
+  return (
+    compactedContextCeiling(params) <=
+    Math.floor(params.thresholdTokens * COMPACTION_LOW_WATER)
+  )
+}
+
 /** A model handoff, not a mechanical reduction of tool results. Nothing mutates
  * the source history until every section has a valid, bounded result. */
 export async function compactWithModel(params: {
@@ -121,34 +202,12 @@ export async function compactWithModel(params: {
     countTokensMessages(params.messages) + params.fixedTokenCount
   // A compact-only request never enters the history. Keep the actual current
   // user request verbatim, including steering and attachments.
-  const lastPrompt = params.messages.findLastIndex((m) =>
-    m.tags?.includes('USER_PROMPT'),
-  )
-  let promptStart = lastPrompt
-  while (
-    promptStart > 0 &&
-    params.messages[promptStart - 1].tags?.includes('USER_PROMPT')
-  )
-    promptStart--
-  const live =
-    promptStart < 0
-      ? []
-      : params.messages
-          .slice(promptStart)
-          .filter((m) => m.tags?.includes('USER_PROMPT'))
-  const instructions = params.messages.findLast((m) =>
-    m.tags?.includes('INSTRUCTIONS_PROMPT'),
-  )
-  const suffix = [...(instructions ? [instructions] : []), ...live]
-  const summaryBudget = Math.min(
-    SUMMARY_LIMIT,
-    Math.floor(
-      (params.maxContextLength -
-        params.fixedTokenCount -
-        countTokensMessages(suffix)) /
-        3,
-    ),
-  )
+  const suffix = compactionSuffix(params.messages)
+  const summaryBudget = compactionSummaryBudget({
+    maxContextLength: params.maxContextLength,
+    fixedTokenCount: params.fixedTokenCount,
+    suffixTokens: countTokensMessages(suffix),
+  })
   if (summaryBudget < 256)
     throw new Error(
       'The current request and instructions leave too little room to compact. Shorten the request or configure a larger context window.',
@@ -319,6 +378,14 @@ export async function compactWithModelOrFallback(
     runId?: string
     model?: string
     trigger?: string
+    /**
+     * Where the mechanical fallback should aim, below `maxContextLength`. That
+     * pass fills whatever budget it is given, so aimed at the hard budget it
+     * lands above an automatic trigger's threshold and the very next step
+     * compacts again. Falls back to `maxContextLength` when the target is too
+     * small to hold the live request.
+     */
+    fallbackTargetTokens?: number
   },
 ): Promise<{
   messages: Message[]
@@ -327,22 +394,41 @@ export async function compactWithModelOrFallback(
   postTokens: number
   fallback?: true
 } | null> {
-  const { logger, runId, model, trigger, ...modelParams } = params
+  const {
+    logger,
+    runId,
+    model,
+    trigger,
+    fallbackTargetTokens,
+    ...modelParams
+  } = params
   try {
     return await compactWithModel(modelParams)
   } catch (error) {
     if (params.signal.aborted || isAbortError(error)) throw error
     const errorMessage = error instanceof Error ? error.message : String(error)
     let fallback: ReturnType<typeof compactHistoryNow> = null
     let fallbackError: string | undefined
-    try {
-      fallback = compactHistoryNow({
+    const mechanical = (maxContextLength: number) =>
+      compactHistoryNow({
         messages: params.messages,
-        maxContextLength: params.maxContextLength,
+        maxContextLength,
         fixedTokenCount: params.fixedTokenCount,
         logger,
         runId,
       })
+    try {
+      if (
+        fallbackTargetTokens !== undefined &&
+        fallbackTargetTokens < params.maxContextLength
+      ) {
+        try {
+          fallback = mechanical(fallbackTargetTokens)
+        } catch {
+          // The live request does not fit the target; use the whole budget.
+        }
+      }
+      fallback ??= mechanical(params.maxContextLength)
     } catch (mechanicalError) {
       fallbackError =
         mechanicalError instanceof Error