@royalcat/opencode-dcp-rc 0.0.0-stage → 4.0.1

package/lib/state/types.ts

@@ -0,0 +1,117 @@
+import type { CompressionTimingState } from "../compress/timing"
+import type { CompressionUsageTotals } from "../compress/usage"
+import type { IdFormat } from "../message-ids"
+import { Message, Part } from "@opencode-ai/sdk/v2"
+
+export interface WithParts {
+    info: Message
+    parts: Part[]
+}
+
+export type ToolStatus = "pending" | "running" | "completed" | "error"
+
+export interface ToolParameterEntry {
+    tool: string
+    parameters: any
+    metadata?: Record<string, unknown>
+    status?: ToolStatus
+    error?: string
+    turn: number
+    tokenCount?: number
+}
+
+export interface SessionStats {
+    pruneTokenCounter: number
+    totalPruneTokens: number
+    /** Token usage of the hidden compression (summary) requests. */
+    compressionUsage: CompressionUsageTotals
+}
+
+export interface PrunedMessageEntry {
+    tokenCount: number
+    allBlockIds: number[]
+    activeBlockIds: number[]
+}
+
+export type CompressionMode = "rc"
+
+export interface CompressionBlock {
+    blockId: number
+    runId: number
+    active: boolean
+    deactivatedByUser: boolean
+    compressedTokens: number
+    summaryTokens: number
+    durationMs: number
+    mode?: CompressionMode
+    topic: string
+    batchTopic?: string
+    startId: string
+    endId: string
+    anchorMessageId: string
+    compressMessageId: string
+    compressCallId?: string
+    includedBlockIds: number[]
+    consumedBlockIds: number[]
+    parentBlockIds: number[]
+    directMessageIds: string[]
+    directToolIds: string[]
+    effectiveMessageIds: string[]
+    effectiveToolIds: string[]
+    createdAt: number
+    deactivatedAt?: number
+    deactivatedByBlockId?: number
+    summary: string
+}
+
+export interface PruneMessagesState {
+    byMessageId: Map<string, PrunedMessageEntry>
+    blocksById: Map<number, CompressionBlock>
+    activeBlockIds: Set<number>
+    activeByAnchorMessageId: Map<string, number>
+    nextBlockId: number
+    nextRunId: number
+}
+
+export interface Prune {
+    tools: Map<string, number>
+    messages: PruneMessagesState
+}
+
+export interface PendingManualTrigger {
+    sessionId: string
+    prompt: string
+}
+
+export interface MessageIdState {
+    byRawId: Map<string, string>
+    byRef: Map<string, string>
+    nextRef: number
+}
+
+export interface Nudges {
+    contextLimitAnchors: Set<string>
+    turnNudgeAnchors: Set<string>
+    iterationNudgeAnchors: Set<string>
+}
+
+export interface SessionState {
+    idFormat: IdFormat
+    sessionId: string | null
+    isSubAgent: boolean
+    manualMode: false | "active" | "compress-pending"
+    compressPermission: "ask" | "allow" | "deny" | undefined
+    pendingManualTrigger: PendingManualTrigger | null
+    prune: Prune
+    nudges: Nudges
+    stats: SessionStats
+    compressionTiming: CompressionTimingState
+    toolParameters: Map<string, ToolParameterEntry>
+    subAgentResultCache: Map<string, string>
+    toolIdList: string[]
+    messageIds: MessageIdState
+    lastCompaction: number
+    currentTurn: number
+    modelContextLimit: number | undefined
+    systemPromptTokens: number | undefined
+}

package/lib/state/utils.ts

@@ -0,0 +1,345 @@
+import type {
+    CompressionBlock,
+    PruneMessagesState,
+    PrunedMessageEntry,
+    SessionState,
+    WithParts,
+} from "./types"
+import { isIgnoredUserMessage, messageHasCompress } from "../messages/query"
+import { isMessageWithInfo } from "../messages/shape"
+import { countTokens } from "../token-utils"
+
+export const isMessageCompacted = (state: SessionState, msg: WithParts): boolean => {
+    if (!isMessageWithInfo(msg)) {
+        return false
+    }
+
+    if (msg.info.time.created < state.lastCompaction) {
+        return true
+    }
+    const pruneEntry = state.prune.messages.byMessageId.get(msg.info.id)
+    if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
+        return true
+    }
+    return false
+}
+
+interface PersistedPruneMessagesState {
+    byMessageId: Record<string, PrunedMessageEntry>
+    blocksById: Record<string, CompressionBlock>
+    activeBlockIds: number[]
+    activeByAnchorMessageId: Record<string, number>
+    nextBlockId: number
+    nextRunId: number
+}
+
+export function serializePruneMessagesState(
+    messagesState: PruneMessagesState,
+): PersistedPruneMessagesState {
+    return {
+        byMessageId: Object.fromEntries(messagesState.byMessageId),
+        blocksById: Object.fromEntries(
+            Array.from(messagesState.blocksById.entries()).map(([blockId, block]) => [
+                String(blockId),
+                block,
+            ]),
+        ),
+        activeBlockIds: Array.from(messagesState.activeBlockIds),
+        activeByAnchorMessageId: Object.fromEntries(messagesState.activeByAnchorMessageId),
+        nextBlockId: messagesState.nextBlockId,
+        nextRunId: messagesState.nextRunId,
+    }
+}
+
+export async function isSubAgentSession(client: any, sessionID: string): Promise<boolean> {
+    try {
+        const result = await client.session.get({ path: { id: sessionID } })
+        return !!result.data?.parentID
+    } catch (error: any) {
+        return false
+    }
+}
+
+export function findLastCompactionTimestamp(messages: WithParts[]): number {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i]
+        if (!isMessageWithInfo(msg)) {
+            continue
+        }
+        if (msg.info.role === "assistant" && msg.info.summary === true) {
+            return msg.info.time.created
+        }
+    }
+    return 0
+}
+
+export function countTurns(state: SessionState, messages: WithParts[]): number {
+    let turnCount = 0
+    for (const msg of messages) {
+        if (!isMessageWithInfo(msg)) {
+            continue
+        }
+        if (isMessageCompacted(state, msg)) {
+            continue
+        }
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        for (const part of parts) {
+            if (part.type === "step-start") {
+                turnCount++
+            }
+        }
+    }
+    return turnCount
+}
+
+export function loadPruneMap(obj?: Record<string, number>): Map<string, number> {
+    if (!obj || typeof obj !== "object") {
+        return new Map()
+    }
+
+    const entries = Object.entries(obj).filter(
+        (entry): entry is [string, number] =>
+            typeof entry[0] === "string" && typeof entry[1] === "number",
+    )
+    return new Map(entries)
+}
+
+export function createPruneMessagesState(): PruneMessagesState {
+    return {
+        byMessageId: new Map<string, PrunedMessageEntry>(),
+        blocksById: new Map<number, CompressionBlock>(),
+        activeBlockIds: new Set<number>(),
+        activeByAnchorMessageId: new Map<string, number>(),
+        nextBlockId: 1,
+        nextRunId: 1,
+    }
+}
+
+export function loadPruneMessagesState(
+    persisted?: PersistedPruneMessagesState,
+): PruneMessagesState {
+    const state = createPruneMessagesState()
+    if (!persisted || typeof persisted !== "object") {
+        return state
+    }
+
+    if (typeof persisted.nextBlockId === "number" && Number.isInteger(persisted.nextBlockId)) {
+        state.nextBlockId = Math.max(1, persisted.nextBlockId)
+    }
+    if (typeof persisted.nextRunId === "number" && Number.isInteger(persisted.nextRunId)) {
+        state.nextRunId = Math.max(1, persisted.nextRunId)
+    }
+
+    if (persisted.byMessageId && typeof persisted.byMessageId === "object") {
+        for (const [messageId, entry] of Object.entries(persisted.byMessageId)) {
+            if (!entry || typeof entry !== "object") {
+                continue
+            }
+
+            const tokenCount = typeof entry.tokenCount === "number" ? entry.tokenCount : 0
+            const allBlockIds = Array.isArray(entry.allBlockIds)
+                ? [
+                      ...new Set(
+                          entry.allBlockIds.filter(
+                              (id): id is number => Number.isInteger(id) && id > 0,
+                          ),
+                      ),
+                  ]
+                : []
+            const activeBlockIds = Array.isArray(entry.activeBlockIds)
+                ? [
+                      ...new Set(
+                          entry.activeBlockIds.filter(
+                              (id): id is number => Number.isInteger(id) && id > 0,
+                          ),
+                      ),
+                  ]
+                : []
+
+            state.byMessageId.set(messageId, {
+                tokenCount,
+                allBlockIds,
+                activeBlockIds,
+            })
+        }
+    }
+
+    if (persisted.blocksById && typeof persisted.blocksById === "object") {
+        for (const [blockIdStr, block] of Object.entries(persisted.blocksById)) {
+            const blockId = Number.parseInt(blockIdStr, 10)
+            if (!Number.isInteger(blockId) || blockId < 1 || !block || typeof block !== "object") {
+                continue
+            }
+
+            const toNumberArray = (value: unknown): number[] =>
+                Array.isArray(value)
+                    ? [
+                          ...new Set(
+                              value.filter(
+                                  (item): item is number => Number.isInteger(item) && item > 0,
+                              ),
+                          ),
+                      ]
+                    : []
+            const toStringArray = (value: unknown): string[] =>
+                Array.isArray(value)
+                    ? [...new Set(value.filter((item): item is string => typeof item === "string"))]
+                    : []
+
+            state.blocksById.set(blockId, {
+                blockId,
+                runId:
+                    typeof block.runId === "number" &&
+                    Number.isInteger(block.runId) &&
+                    block.runId > 0
+                        ? block.runId
+                        : blockId,
+                active: block.active === true,
+                deactivatedByUser: block.deactivatedByUser === true,
+                compressedTokens:
+                    typeof block.compressedTokens === "number" &&
+                    Number.isFinite(block.compressedTokens)
+                        ? Math.max(0, block.compressedTokens)
+                        : 0,
+                summaryTokens:
+                    typeof block.summaryTokens === "number" && Number.isFinite(block.summaryTokens)
+                        ? Math.max(0, block.summaryTokens)
+                        : typeof block.summary === "string"
+                          ? countTokens(block.summary)
+                          : 0,
+                durationMs:
+                    typeof block.durationMs === "number" && Number.isFinite(block.durationMs)
+                        ? Math.max(0, block.durationMs)
+                        : 0,
+                mode: block.mode === "rc" ? "rc" : undefined,
+                topic: typeof block.topic === "string" ? block.topic : "",
+                batchTopic:
+                    typeof block.batchTopic === "string"
+                        ? block.batchTopic
+                        : typeof block.topic === "string"
+                          ? block.topic
+                          : "",
+                startId: typeof block.startId === "string" ? block.startId : "",
+                endId: typeof block.endId === "string" ? block.endId : "",
+                anchorMessageId:
+                    typeof block.anchorMessageId === "string" ? block.anchorMessageId : "",
+                compressMessageId:
+                    typeof block.compressMessageId === "string" ? block.compressMessageId : "",
+                compressCallId:
+                    typeof block.compressCallId === "string" ? block.compressCallId : undefined,
+                includedBlockIds: toNumberArray(block.includedBlockIds),
+                consumedBlockIds: toNumberArray(block.consumedBlockIds),
+                parentBlockIds: toNumberArray(block.parentBlockIds),
+                directMessageIds: toStringArray(block.directMessageIds),
+                directToolIds: toStringArray(block.directToolIds),
+                effectiveMessageIds: toStringArray(block.effectiveMessageIds),
+                effectiveToolIds: toStringArray(block.effectiveToolIds),
+                createdAt: typeof block.createdAt === "number" ? block.createdAt : 0,
+                deactivatedAt:
+                    typeof block.deactivatedAt === "number" ? block.deactivatedAt : undefined,
+                deactivatedByBlockId:
+                    typeof block.deactivatedByBlockId === "number" &&
+                    Number.isInteger(block.deactivatedByBlockId)
+                        ? block.deactivatedByBlockId
+                        : undefined,
+                summary: typeof block.summary === "string" ? block.summary : "",
+            })
+        }
+    }
+
+    if (Array.isArray(persisted.activeBlockIds)) {
+        for (const blockId of persisted.activeBlockIds) {
+            if (!Number.isInteger(blockId) || blockId < 1) {
+                continue
+            }
+            state.activeBlockIds.add(blockId)
+        }
+    }
+
+    if (
+        persisted.activeByAnchorMessageId &&
+        typeof persisted.activeByAnchorMessageId === "object"
+    ) {
+        for (const [anchorMessageId, blockId] of Object.entries(
+            persisted.activeByAnchorMessageId,
+        )) {
+            if (typeof blockId !== "number" || !Number.isInteger(blockId) || blockId < 1) {
+                continue
+            }
+            state.activeByAnchorMessageId.set(anchorMessageId, blockId)
+        }
+    }
+
+    for (const [blockId, block] of state.blocksById) {
+        if (block.active) {
+            state.activeBlockIds.add(blockId)
+            if (block.anchorMessageId) {
+                state.activeByAnchorMessageId.set(block.anchorMessageId, blockId)
+            }
+        }
+        if (blockId >= state.nextBlockId) {
+            state.nextBlockId = blockId + 1
+        }
+        if (block.runId >= state.nextRunId) {
+            state.nextRunId = block.runId + 1
+        }
+    }
+
+    return state
+}
+
+export function collectTurnNudgeAnchors(messages: WithParts[]): Set<string> {
+    const anchors = new Set<string>()
+    let pendingUserMessageId: string | null = null
+
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i]
+
+        if (messageHasCompress(message)) {
+            break
+        }
+
+        if (message.info.role === "user") {
+            if (!isIgnoredUserMessage(message)) {
+                pendingUserMessageId = message.info.id
+            }
+            continue
+        }
+
+        if (message.info.role === "assistant" && pendingUserMessageId) {
+            anchors.add(message.info.id)
+            anchors.add(pendingUserMessageId)
+            pendingUserMessageId = null
+        }
+    }
+
+    return anchors
+}
+
+export function getActiveSummaryTokenUsage(state: SessionState): number {
+    let total = 0
+    for (const blockId of state.prune.messages.activeBlockIds) {
+        const block = state.prune.messages.blocksById.get(blockId)
+        if (!block || !block.active) {
+            continue
+        }
+        total += block.summaryTokens
+    }
+    return total
+}
+
+export function resetOnCompaction(state: SessionState): void {
+    state.toolParameters.clear()
+    state.prune.tools = new Map<string, number>()
+    state.prune.messages = createPruneMessagesState()
+    state.messageIds = {
+        byRawId: new Map<string, string>(),
+        byRef: new Map<string, string>(),
+        nextRef: 1,
+    }
+    state.nudges = {
+        contextLimitAnchors: new Set<string>(),
+        turnNudgeAnchors: new Set<string>(),
+        iterationNudgeAnchors: new Set<string>(),
+    }
+}

package/lib/strategies/deduplication.ts

@@ -0,0 +1,125 @@
+import { PluginConfig } from "../config"
+import { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import { isToolProtected } from "../protected-patterns"
+import { getTotalToolTokens } from "../token-utils"
+
+/**
+ * Deduplication strategy - prunes older tool calls that have identical
+ * tool name and parameters, keeping only the most recent occurrence.
+ * Modifies the session state in place to add pruned tool call IDs.
+ */
+export const deduplicate = (
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    messages: WithParts[],
+): void => {
+    if (state.manualMode && !config.manualMode.automaticStrategies) {
+        return
+    }
+
+    if (!config.strategies.deduplication.enabled) {
+        return
+    }
+
+    const allToolIds = state.toolIdList
+    if (allToolIds.length === 0) {
+        return
+    }
+
+    // Filter out IDs already pruned
+    const unprunedIds = allToolIds.filter((id) => !state.prune.tools.has(id))
+
+    if (unprunedIds.length === 0) {
+        return
+    }
+
+    const protectedTools = config.strategies.deduplication.protectedTools
+
+    // Group by signature (tool name + normalized parameters)
+    const signatureMap = new Map<string, string[]>()
+
+    for (const id of unprunedIds) {
+        const metadata = state.toolParameters.get(id)
+        if (!metadata) {
+            // logger.warn(`Missing metadata for tool call ID: ${id}`)
+            continue
+        }
+
+        if (
+            isToolProtected(
+                metadata.tool,
+                metadata.parameters,
+                protectedTools,
+                config.protectedFilePatterns,
+                metadata.metadata,
+            )
+        ) {
+            continue
+        }
+
+        const signature = createToolSignature(metadata.tool, metadata.parameters)
+        if (!signatureMap.has(signature)) {
+            signatureMap.set(signature, [])
+        }
+        const ids = signatureMap.get(signature)
+        if (ids) {
+            ids.push(id)
+        }
+    }
+
+    // Find duplicates - keep only the most recent (last) in each group
+    const newPruneIds: string[] = []
+
+    for (const [, ids] of signatureMap.entries()) {
+        if (ids.length > 1) {
+            // All except last (most recent) should be pruned
+            const idsToRemove = ids.slice(0, -1)
+            newPruneIds.push(...idsToRemove)
+        }
+    }
+
+    state.stats.totalPruneTokens += getTotalToolTokens(state, newPruneIds)
+
+    if (newPruneIds.length > 0) {
+        for (const id of newPruneIds) {
+            const entry = state.toolParameters.get(id)
+            state.prune.tools.set(id, entry?.tokenCount ?? 0)
+        }
+        logger.debug(`Marked ${newPruneIds.length} duplicate tool calls for pruning`)
+    }
+}
+
+function createToolSignature(tool: string, parameters?: any): string {
+    if (!parameters) {
+        return tool
+    }
+    const normalized = normalizeParameters(parameters)
+    const sorted = sortObjectKeys(normalized)
+    return `${tool}::${JSON.stringify(sorted)}`
+}
+
+function normalizeParameters(params: any): any {
+    if (typeof params !== "object" || params === null) return params
+    if (Array.isArray(params)) return params
+
+    const normalized: any = {}
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) {
+            normalized[key] = value
+        }
+    }
+    return normalized
+}
+
+function sortObjectKeys(obj: any): any {
+    if (typeof obj !== "object" || obj === null) return obj
+    if (Array.isArray(obj)) return obj.map(sortObjectKeys)
+
+    const sorted: any = {}
+    for (const key of Object.keys(obj).sort()) {
+        sorted[key] = sortObjectKeys(obj[key])
+    }
+    return sorted
+}

package/lib/strategies/index.ts

@@ -0,0 +1,2 @@
+export { deduplicate } from "./deduplication"
+export { purgeErrors } from "./purge-errors"

package/lib/strategies/purge-errors.ts

@@ -0,0 +1,86 @@
+import { PluginConfig } from "../config"
+import { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import { isToolProtected } from "../protected-patterns"
+import { getTotalToolTokens } from "../token-utils"
+
+/**
+ * Purge Errors strategy - prunes tool inputs for tools that errored
+ * after they are older than a configurable number of turns.
+ * The error message is preserved, but the (potentially large) inputs
+ * are removed to save context.
+ *
+ * Modifies the session state in place to add pruned tool call IDs.
+ */
+export const purgeErrors = (
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    messages: WithParts[],
+): void => {
+    if (state.manualMode && !config.manualMode.automaticStrategies) {
+        return
+    }
+
+    if (!config.strategies.purgeErrors.enabled) {
+        return
+    }
+
+    const allToolIds = state.toolIdList
+    if (allToolIds.length === 0) {
+        return
+    }
+
+    // Filter out IDs already pruned
+    const unprunedIds = allToolIds.filter((id) => !state.prune.tools.has(id))
+
+    if (unprunedIds.length === 0) {
+        return
+    }
+
+    const protectedTools = config.strategies.purgeErrors.protectedTools
+    const turnThreshold = Math.max(1, config.strategies.purgeErrors.turns)
+
+    const newPruneIds: string[] = []
+
+    for (const id of unprunedIds) {
+        const metadata = state.toolParameters.get(id)
+        if (!metadata) {
+            continue
+        }
+
+        if (
+            isToolProtected(
+                metadata.tool,
+                metadata.parameters,
+                protectedTools,
+                config.protectedFilePatterns,
+                metadata.metadata,
+            )
+        ) {
+            continue
+        }
+
+        // Only process error tools
+        if (metadata.status !== "error") {
+            continue
+        }
+
+        // Check if the tool is old enough to prune
+        const turnAge = state.currentTurn - metadata.turn
+        if (turnAge >= turnThreshold) {
+            newPruneIds.push(id)
+        }
+    }
+
+    if (newPruneIds.length > 0) {
+        state.stats.totalPruneTokens += getTotalToolTokens(state, newPruneIds)
+        for (const id of newPruneIds) {
+            const entry = state.toolParameters.get(id)
+            state.prune.tools.set(id, entry?.tokenCount ?? 0)
+        }
+        logger.debug(
+            `Marked ${newPruneIds.length} error tool calls for pruning (older than ${turnThreshold} turns)`,
+        )
+    }
+}