@tarquinen/opencode-dcp 3.2.3-beta0 → 3.2.5-beta0

package/lib/state/state.ts

@@ -1,190 +0,0 @@
-import type { SessionState, ToolParameterEntry, WithParts } from "./types"
-import type { Logger } from "../logger"
-import { applyPendingCompressionDurations } from "../compress/timing"
-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,
-        },
-        compressionTiming: {
-            startsByCallId: new Map<string, number>(),
-            pendingByCallId: new Map(),
-        },
-        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,
-    }
-
-    const applied = applyPendingCompressionDurations(state)
-    if (applied > 0) {
-        await saveSessionState(state, logger)
-    }
-}

package/lib/state/tool-cache.ts

@@ -1,98 +0,0 @@
-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

@@ -1,112 +0,0 @@
-import type { CompressionTimingState } from "../compress/timing"
-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
-    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 {
-    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
-    variant: string | undefined
-    modelContextLimit: number | undefined
-    systemPromptTokens: number | undefined
-}