@tarquinen/opencode-dcp 3.2.0-beta0 → 3.2.2-beta0

package/lib/state/state.ts

@@ -0,0 +1,180 @@
+import type { SessionState, ToolParameterEntry, WithParts } from "./types"
+import type { Logger } from "../logger"
+import { loadSessionState, saveSessionState } from "./persistence"
+import {
+    isSubAgentSession,
+    findLastCompactionTimestamp,
+    countTurns,
+    resetOnCompaction,
+    createPruneMessagesState,
+    loadPruneMessagesState,
+    loadPruneMap,
+    collectTurnNudgeAnchors,
+} from "./utils"
+import { getLastUserMessage } from "../messages/query"
+
+export const checkSession = async (
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    messages: WithParts[],
+    manualModeDefault: boolean,
+): Promise<void> => {
+    const lastUserMessage = getLastUserMessage(messages)
+    if (!lastUserMessage) {
+        return
+    }
+
+    const lastSessionId = lastUserMessage.info.sessionID
+
+    if (state.sessionId === null || state.sessionId !== lastSessionId) {
+        logger.info(`Session changed: ${state.sessionId} -> ${lastSessionId}`)
+        try {
+            await ensureSessionInitialized(
+                client,
+                state,
+                lastSessionId,
+                logger,
+                messages,
+                manualModeDefault,
+            )
+        } catch (err: any) {
+            logger.error("Failed to initialize session state", { error: err.message })
+        }
+    }
+
+    const lastCompactionTimestamp = findLastCompactionTimestamp(messages)
+    if (lastCompactionTimestamp > state.lastCompaction) {
+        state.lastCompaction = lastCompactionTimestamp
+        resetOnCompaction(state)
+        logger.info("Detected compaction - reset stale state", {
+            timestamp: lastCompactionTimestamp,
+        })
+
+        saveSessionState(state, logger).catch((error) => {
+            logger.warn("Failed to persist state reset after compaction", {
+                error: error instanceof Error ? error.message : String(error),
+            })
+        })
+    }
+
+    state.currentTurn = countTurns(state, messages)
+}
+
+export function createSessionState(): SessionState {
+    return {
+        sessionId: null,
+        isSubAgent: false,
+        manualMode: false,
+        compressPermission: undefined,
+        pendingManualTrigger: null,
+        prune: {
+            tools: new Map<string, number>(),
+            messages: createPruneMessagesState(),
+        },
+        nudges: {
+            contextLimitAnchors: new Set<string>(),
+            turnNudgeAnchors: new Set<string>(),
+            iterationNudgeAnchors: new Set<string>(),
+        },
+        stats: {
+            pruneTokenCounter: 0,
+            totalPruneTokens: 0,
+        },
+        toolParameters: new Map<string, ToolParameterEntry>(),
+        subAgentResultCache: new Map<string, string>(),
+        toolIdList: [],
+        messageIds: {
+            byRawId: new Map<string, string>(),
+            byRef: new Map<string, string>(),
+            nextRef: 1,
+        },
+        lastCompaction: 0,
+        currentTurn: 0,
+        variant: undefined,
+        modelContextLimit: undefined,
+        systemPromptTokens: undefined,
+    }
+}
+
+export function resetSessionState(state: SessionState): void {
+    state.sessionId = null
+    state.isSubAgent = false
+    state.manualMode = false
+    state.compressPermission = undefined
+    state.pendingManualTrigger = null
+    state.prune = {
+        tools: new Map<string, number>(),
+        messages: createPruneMessagesState(),
+    }
+    state.nudges = {
+        contextLimitAnchors: new Set<string>(),
+        turnNudgeAnchors: new Set<string>(),
+        iterationNudgeAnchors: new Set<string>(),
+    }
+    state.stats = {
+        pruneTokenCounter: 0,
+        totalPruneTokens: 0,
+    }
+    state.toolParameters.clear()
+    state.subAgentResultCache.clear()
+    state.toolIdList = []
+    state.messageIds = {
+        byRawId: new Map<string, string>(),
+        byRef: new Map<string, string>(),
+        nextRef: 1,
+    }
+    state.lastCompaction = 0
+    state.currentTurn = 0
+    state.variant = undefined
+    state.modelContextLimit = undefined
+    state.systemPromptTokens = undefined
+}
+
+export async function ensureSessionInitialized(
+    client: any,
+    state: SessionState,
+    sessionId: string,
+    logger: Logger,
+    messages: WithParts[],
+    manualModeEnabled: boolean,
+): Promise<void> {
+    if (state.sessionId === sessionId) {
+        return
+    }
+
+    // logger.info("session ID = " + sessionId)
+    // logger.info("Initializing session state", { sessionId: sessionId })
+
+    resetSessionState(state)
+    state.manualMode = manualModeEnabled ? "active" : false
+    state.sessionId = sessionId
+
+    const isSubAgent = await isSubAgentSession(client, sessionId)
+    state.isSubAgent = isSubAgent
+    // logger.info("isSubAgent = " + isSubAgent)
+
+    state.lastCompaction = findLastCompactionTimestamp(messages)
+    state.currentTurn = countTurns(state, messages)
+    state.nudges.turnNudgeAnchors = collectTurnNudgeAnchors(messages)
+
+    const persisted = await loadSessionState(sessionId, logger)
+    if (persisted === null) {
+        return
+    }
+
+    state.prune.tools = loadPruneMap(persisted.prune.tools)
+    state.prune.messages = loadPruneMessagesState(persisted.prune.messages)
+    state.nudges.contextLimitAnchors = new Set<string>(persisted.nudges.contextLimitAnchors || [])
+    state.nudges.turnNudgeAnchors = new Set<string>([
+        ...state.nudges.turnNudgeAnchors,
+        ...(persisted.nudges.turnNudgeAnchors || []),
+    ])
+    state.nudges.iterationNudgeAnchors = new Set<string>(
+        persisted.nudges.iterationNudgeAnchors || [],
+    )
+    state.stats = {
+        pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
+        totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+    }
+}

package/lib/state/tool-cache.ts

@@ -0,0 +1,98 @@
+import type { SessionState, ToolStatus, WithParts } from "./index"
+import type { Logger } from "../logger"
+import { PluginConfig } from "../config"
+import { isMessageCompacted } from "./utils"
+import { countToolTokens } from "../token-utils"
+
+const MAX_TOOL_CACHE_SIZE = 1000
+
+/**
+ * Sync tool parameters from session messages.
+ */
+export function syncToolCache(
+    state: SessionState,
+    config: PluginConfig,
+    logger: Logger,
+    messages: WithParts[],
+): void {
+    try {
+        logger.info("Syncing tool parameters from OpenCode messages")
+
+        let turnCounter = 0
+
+        for (const msg of messages) {
+            if (isMessageCompacted(state, msg)) {
+                continue
+            }
+
+            const parts = Array.isArray(msg.parts) ? msg.parts : []
+            for (const part of parts) {
+                if (part.type === "step-start") {
+                    turnCounter++
+                    continue
+                }
+
+                if (part.type !== "tool" || !part.callID) {
+                    continue
+                }
+
+                const turnProtectionEnabled = config.turnProtection.enabled
+                const turnProtectionTurns = config.turnProtection.turns
+                const isProtectedByTurn =
+                    turnProtectionEnabled &&
+                    turnProtectionTurns > 0 &&
+                    state.currentTurn - turnCounter < turnProtectionTurns
+
+                if (state.toolParameters.has(part.callID)) {
+                    continue
+                }
+
+                if (isProtectedByTurn) {
+                    continue
+                }
+
+                const tokenCount = countToolTokens(part)
+
+                state.toolParameters.set(part.callID, {
+                    tool: part.tool,
+                    parameters: part.state?.input ?? {},
+                    status: part.state.status as ToolStatus | undefined,
+                    error: part.state.status === "error" ? part.state.error : undefined,
+                    turn: turnCounter,
+                    tokenCount,
+                })
+                logger.info(
+                    `Cached tool id: ${part.callID} (turn ${turnCounter}${tokenCount !== undefined ? `, ${tokenCount} tokens` : ""})`,
+                )
+            }
+        }
+
+        logger.info(
+            `Synced cache - size: ${state.toolParameters.size}, currentTurn: ${state.currentTurn}`,
+        )
+        trimToolParametersCache(state)
+    } catch (error) {
+        logger.warn("Failed to sync tool parameters from OpenCode", {
+            error: error instanceof Error ? error.message : String(error),
+        })
+    }
+}
+
+/**
+ * Trim the tool parameters cache to prevent unbounded memory growth.
+ * Uses FIFO eviction - removes oldest entries first.
+ */
+export function trimToolParametersCache(state: SessionState): void {
+    if (state.toolParameters.size <= MAX_TOOL_CACHE_SIZE) {
+        return
+    }
+
+    const keysToRemove = Array.from(state.toolParameters.keys()).slice(
+        0,
+        state.toolParameters.size - MAX_TOOL_CACHE_SIZE,
+    )
+
+    for (const key of keysToRemove) {
+        state.toolParameters.delete(key)
+    }
+}

package/lib/state/types.ts

@@ -0,0 +1,108 @@
+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
+    status?: ToolStatus
+    error?: string
+    turn: number
+    tokenCount?: number
+}
+
+export interface SessionStats {
+    pruneTokenCounter: number
+    totalPruneTokens: number
+}
+
+export interface PrunedMessageEntry {
+    tokenCount: number
+    allBlockIds: number[]
+    activeBlockIds: number[]
+}
+
+export type CompressionMode = "range" | "message"
+
+export interface CompressionBlock {
+    blockId: number
+    runId: number
+    active: boolean
+    deactivatedByUser: boolean
+    compressedTokens: number
+    summaryTokens: number
+    mode?: CompressionMode
+    topic: string
+    batchTopic?: string
+    startId: string
+    endId: string
+    anchorMessageId: string
+    compressMessageId: 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 {
+    sessionId: string | null
+    isSubAgent: boolean
+    manualMode: false | "active" | "compress-pending"
+    compressPermission: "ask" | "allow" | "deny" | undefined
+    pendingManualTrigger: PendingManualTrigger | null
+    prune: Prune
+    nudges: Nudges
+    stats: SessionStats
+    toolParameters: Map<string, ToolParameterEntry>
+    subAgentResultCache: Map<string, string>
+    toolIdList: string[]
+    messageIds: MessageIdState
+    lastCompaction: number
+    currentTurn: number
+    variant: string | undefined
+    modelContextLimit: number | undefined
+    systemPromptTokens: number | undefined
+}

package/lib/state/utils.ts

@@ -0,0 +1,310 @@
+import type {
+    CompressionBlock,
+    PruneMessagesState,
+    PrunedMessageEntry,
+    SessionState,
+    WithParts,
+} from "./types"
+import { isIgnoredUserMessage, messageHasCompress } from "../messages/query"
+import { countTokens } from "../token-utils"
+
+export const isMessageCompacted = (state: SessionState, msg: WithParts): boolean => {
+    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 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 (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 (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,
+                mode: block.mode === "range" || block.mode === "message" ? block.mode : 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 : "",
+                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>(),
+    }
+}