@serkanalgur/opencodev2-slim 2.0.14 → 2.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencodev2-slim",
-  "version": "2.0.14",
+  "version": "2.0.15",
   "description": "Smart context management plugin for OpenCode v2 - semantic compression, cost-aware pruning, adaptive thresholds",
   "keywords": [
     "opencode",

package/src/index.ts

@@ -16,6 +16,7 @@ import {
     pruneInPlace,
     injectLimitNudges,
     findLastUserMessage,
+    autoCompress,
 } from "./lib/strategies"
 import { getSystemPrompt, getCompressToolDescription } from "./lib/prompts"
 import { buildPanelData, renderPanel } from "./lib/tui"
@@ -385,12 +386,12 @@ export default Plugin.define({
             event.system.push({ type: "text", text: getSystemPrompt() })
         })
 
-        // ─── Messages Transform Hook (sync) ──────────────────────────────
+        // ─── Messages Transform Hook (sync → async) ─────────────────────────
         // DCP pipeline for every outgoing request: sync compression blocks,
         // replace covered ranges with summary placeholders, prune (dedup +
         // purge errored tool inputs), then apply DCP limit rules as anchored
         // nudges. Session history is never modified — only this request.
-        await ctx.session.hook("context", (event) => {
+        await ctx.session.hook("context", async (event) => {
             const sessionId = event.sessionID
             const config = getConfig(sessionId)
             if (!config.enabled) return
@@ -442,6 +443,17 @@ export default Plugin.define({
             const limits = resolveCompressLimits(config, state, providerId, modelId)
             injectLimitNudges(state, config, event.messages, totalTokens, limits)
 
+            // 5) Auto-compress: when over the max limit, directly compress old
+            //    messages without waiting for the model to call the compress tool.
+            //    Registers a compression block so future requests use the summary.
+            if (totalTokens > limits.max) {
+                try {
+                    await autoCompress(state, config, event.messages, totalTokens, limits)
+                } catch {
+                    // Best-effort: auto-compress failure should never break the request.
+                }
+            }
+
             saveSessionState(state, config.persistence.directory)
         })
 

package/src/lib/config.ts

@@ -19,6 +19,7 @@ const DEFAULT_CONFIG: SlimConfig = {
         nudgeForce: "soft",
         protectUserMessages: false,
         protectedTools: ["task", "skill", "todowrite", "todoread"],
+        keepRecent: 5,
     },
     strategies: {
         deduplication: {

package/src/lib/strategies.ts

@@ -1,6 +1,7 @@
 import type { MessageWithParts, SlimConfig, SessionState, CompressionBlock } from "./types"
-import { getToolName, getMessageText } from "./compress"
+import { getToolName, getMessageText, getToolResultContent, countTokens } from "./compress"
 import { contextLimitNudge, turnNudge, iterationNudge, NUDGE_MARKERS } from "./prompts"
+import { addCompressionRecord } from "./state"
 
 // ─── DCP-style Compression Blocks ───────────────────────────────────────────
 //
@@ -608,4 +609,128 @@ export function injectLimitNudges(
     )
 
     state.nudges = nudges
+}
+
+// ─── Auto-compress: directly compress when over limit ───────────────────────
+
+/**
+ * Automatically compresses old messages when context exceeds the max limit.
+ * Called from the context hook when overMax is true — no model cooperation needed.
+ * Registers a compression block so future requests use the summary instead.
+ */
+export async function autoCompress(
+    state: SessionState,
+    config: SlimConfig,
+    messages: any[],
+    currentTokens: number,
+    limits: { max: number; min: number },
+): Promise<{ compressed: boolean; messageCount?: number; tokensSaved?: number }> {
+    if (config.compress.permission === "deny") return { compressed: false }
+    if (state.manualMode) return { compressed: false }
+    if (limits.max <= 0) return { compressed: false }
+    if (currentTokens <= limits.max) return { compressed: false }
+
+    // Throttle: don't auto-compress more than once every 5 minutes
+    const now = Date.now()
+    const lastAuto = (state as any).lastAutoCompressTime ?? 0
+    if (now - lastAuto < 5 * 60 * 1000) return { compressed: false }
+
+    // Don't auto-compress if the model just compressed in the last assistant turn
+    const lastAssistant = [...messages].reverse().find((m: any) => m?.role === "assistant")
+    if (lastAssistant && messageHasCompress(lastAssistant)) return { compressed: false }
+
+    const keepRecent = Math.max(2, config.compress.keepRecent ?? 5)
+    const messageWithParts: MessageWithParts[] = messages.map((m: any) => ({
+        info: {
+            id: m?.id ?? m?.info?.id ?? "",
+            role: m?.role ?? m?.info?.role ?? "user",
+            sessionID: m?.sessionID ?? m?.info?.sessionID ?? "",
+            time: { created: Date.now() },
+        } as any,
+        parts: m?.parts ?? m?.content ?? [],
+    }))
+
+    // Select messages to compress: all except recent ones, with >100 tokens
+    const targetIndices: number[] = []
+    let inputTokens = 0
+    for (let i = 0; i < messageWithParts.length - keepRecent; i++) {
+        const msg = messageWithParts[i]
+        const text = getMessageText(msg) + getToolResultContent(msg)
+        const tokens = await countTokens(text)
+        if (tokens < 100) continue
+        targetIndices.push(i)
+        inputTokens += tokens
+    }
+
+    if (targetIndices.length === 0) {
+        ;(state as any).lastAutoCompressTime = now
+        return { compressed: false }
+    }
+
+    // Build summary
+    const targetMessages = targetIndices.map((i) => messageWithParts[i])
+    const summary = await buildCompressionSummary(
+        targetMessages,
+        "auto-compress: context limit exceeded",
+        config.compress.protectedTools,
+        config.compress.protectUserMessages,
+    )
+    const outputTokens = await countTokens(summary)
+
+    // Register compression block
+    const sorted = [...targetIndices].sort((a, b) => a - b)
+    const coveredIndices = new Set(sorted)
+    let anchorIndex = sorted[sorted.length - 1] + 1
+    if (anchorIndex >= messageWithParts.length) {
+        anchorIndex = messageWithParts.length - 1
+        coveredIndices.delete(anchorIndex)
+    }
+    if (anchorIndex < 0 || anchorIndex >= messageWithParts.length) {
+        ;(state as any).lastAutoCompressTime = now
+        return { compressed: false }
+    }
+
+    const anchorId = messageWithParts[anchorIndex].info?.id
+    if (!anchorId) {
+        ;(state as any).lastAutoCompressTime = now
+        return { compressed: false }
+    }
+
+    const coveredIds = [...coveredIndices]
+        .map((i) => messageWithParts[i].info?.id)
+        .filter((id): id is string => typeof id === "string" && id.length > 0)
+    if (coveredIds.length === 0) {
+        ;(state as any).lastAutoCompressTime = now
+        return { compressed: false }
+    }
+
+    registerCompressionBlock(state, {
+        coveredIds,
+        anchorMessageId: anchorId,
+        summary,
+        topic: "auto-compress",
+        summaryTokens: outputTokens,
+    })
+
+    // Record compression stats
+    const ratio = inputTokens > 0 ? 1 - outputTokens / inputTokens : 0
+    addCompressionRecord(
+        state,
+        {
+            timestamp: now,
+            inputTokens,
+            outputTokens,
+            ratio,
+            messageCount: targetMessages.length,
+            success: true,
+        },
+        config.adaptive.learningRate,
+    )
+
+    ;(state as any).lastAutoCompressTime = now
+    return {
+        compressed: true,
+        messageCount: targetMessages.length,
+        tokensSaved: inputTokens - outputTokens,
+    }
 }

package/src/lib/types.ts

@@ -28,6 +28,8 @@ export interface SlimConfig {
         nudgeForce?: "strong" | "soft"
         protectUserMessages: boolean
         protectedTools: string[]
+        /** Number of recent messages to always keep during auto-compress (default: 5) */
+        keepRecent?: number
     }
 
     // Strategy settings