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

package/lib/messages/prune.ts

@@ -0,0 +1,238 @@
+import type { SessionState, WithParts } from "../state"
+import type { Logger } from "../logger"
+import { isMessageCompacted } from "../state/utils"
+import { createSyntheticUserMessage } from "./utils"
+import { getLastUserMessage } from "./query"
+import type { UserMessage } from "@opencode-ai/sdk/v2"
+import { formatBlockRef } from "../message-ids"
+
+const PRUNED_TOOL_OUTPUT_REPLACEMENT =
+    "[Output removed to save context - information superseded or no longer needed]"
+const PRUNED_TOOL_ERROR_INPUT_REPLACEMENT = "[input removed due to failed tool call]"
+const PRUNED_QUESTION_INPUT_REPLACEMENT = "[questions removed - see output for user's answers]"
+
+export const prune = (
+    state: SessionState,
+    logger: Logger,
+    messages: WithParts[],
+    summaryBase?: WithParts,
+): void => {
+    filterCompressedRanges(state, logger, messages, summaryBase)
+    // pruneFullTool(state, logger, messages)
+    pruneToolOutputs(state, logger, messages)
+    pruneToolInputs(state, logger, messages)
+    pruneToolErrors(state, logger, messages)
+}
+
+const pruneFullTool = (state: SessionState, logger: Logger, messages: WithParts[]): void => {
+    const messagesToRemove: string[] = []
+
+    for (const msg of messages) {
+        if (isMessageCompacted(state, msg)) {
+            continue
+        }
+
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        const partsToRemove: string[] = []
+
+        for (const part of parts) {
+            if (part.type !== "tool") {
+                continue
+            }
+
+            if (!state.prune.tools.has(part.callID)) {
+                continue
+            }
+            if (part.tool !== "edit" && part.tool !== "write") {
+                continue
+            }
+
+            partsToRemove.push(part.callID)
+        }
+
+        if (partsToRemove.length === 0) {
+            continue
+        }
+
+        msg.parts = parts.filter(
+            (part) => part.type !== "tool" || !partsToRemove.includes(part.callID),
+        )
+
+        if (msg.parts.length === 0) {
+            messagesToRemove.push(msg.info.id)
+        }
+    }
+
+    if (messagesToRemove.length > 0) {
+        const result = messages.filter((msg) => !messagesToRemove.includes(msg.info.id))
+        messages.length = 0
+        messages.push(...result)
+    }
+}
+
+const pruneToolOutputs = (state: SessionState, logger: Logger, messages: WithParts[]): void => {
+    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 !== "tool") {
+                continue
+            }
+            if (!state.prune.tools.has(part.callID)) {
+                continue
+            }
+            if (part.state.status !== "completed") {
+                continue
+            }
+            if (part.tool === "question" || part.tool === "edit" || part.tool === "write") {
+                continue
+            }
+
+            part.state.output = PRUNED_TOOL_OUTPUT_REPLACEMENT
+        }
+    }
+}
+
+const pruneToolInputs = (state: SessionState, logger: Logger, messages: WithParts[]): void => {
+    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 !== "tool") {
+                continue
+            }
+
+            if (!state.prune.tools.has(part.callID)) {
+                continue
+            }
+            if (part.state.status !== "completed") {
+                continue
+            }
+            if (part.tool !== "question") {
+                continue
+            }
+
+            if (part.state.input?.questions !== undefined) {
+                part.state.input.questions = PRUNED_QUESTION_INPUT_REPLACEMENT
+            }
+        }
+    }
+}
+
+const pruneToolErrors = (state: SessionState, logger: Logger, messages: WithParts[]): void => {
+    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 !== "tool") {
+                continue
+            }
+            if (!state.prune.tools.has(part.callID)) {
+                continue
+            }
+            if (part.state.status !== "error") {
+                continue
+            }
+
+            // Prune all string inputs for errored tools
+            const input = part.state.input
+            if (input && typeof input === "object") {
+                for (const key of Object.keys(input)) {
+                    if (typeof input[key] === "string") {
+                        input[key] = PRUNED_TOOL_ERROR_INPUT_REPLACEMENT
+                    }
+                }
+            }
+        }
+    }
+}
+
+const filterCompressedRanges = (
+    state: SessionState,
+    logger: Logger,
+    messages: WithParts[],
+    summaryBase?: WithParts,
+): void => {
+    if (
+        state.prune.messages.byMessageId.size === 0 &&
+        state.prune.messages.activeByAnchorMessageId.size === 0
+    ) {
+        return
+    }
+
+    const result: WithParts[] = []
+
+    for (const msg of messages) {
+        const msgId = msg.info.id
+
+        // Check if there's a summary to inject at this anchor point
+        const blockId = state.prune.messages.activeByAnchorMessageId.get(msgId)
+        const summary =
+            blockId !== undefined ? state.prune.messages.blocksById.get(blockId) : undefined
+        if (summary) {
+            const rawSummaryContent = (summary as { summary?: unknown }).summary
+            if (
+                summary.active !== true ||
+                typeof rawSummaryContent !== "string" ||
+                rawSummaryContent.length === 0
+            ) {
+                logger.warn("Skipping malformed compress summary", {
+                    anchorMessageId: msgId,
+                    blockId: (summary as { blockId?: unknown }).blockId,
+                })
+            } else {
+                // Find user message for variant and as base for synthetic message
+                const msgIndex = messages.indexOf(msg)
+                const userMessage = getLastUserMessage(messages, msgIndex) ?? summaryBase
+
+                if (userMessage) {
+                    const userInfo = userMessage.info as UserMessage
+                    // Persisted summaries can outlive the host's tag format.
+                    let renderedSummary = rawSummaryContent
+                    if (state.idFormat === "compact") {
+                        renderedSummary = renderedSummary.replace(
+                            /<dcp-message-id>b(\d+)<\/dcp-message-id>\s*$/i,
+                            (_, id) => formatBlockRef(Number(id), "compact"),
+                        )
+                    }
+                    const summaryContent = renderedSummary
+                    const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`
+                    result.push(
+                        createSyntheticUserMessage(userMessage, summaryContent, summarySeed),
+                    )
+
+                    logger.info("Injected compress summary", {
+                        anchorMessageId: msgId,
+                        summaryLength: summaryContent.length,
+                    })
+                } else {
+                    logger.warn("No user message found for compress summary", {
+                        anchorMessageId: msgId,
+                    })
+                }
+            }
+        }
+
+        // Skip messages that are in the prune list
+        const pruneEntry = state.prune.messages.byMessageId.get(msgId)
+        if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
+            continue
+        }
+
+        // Normal message, include it
+        result.push(msg)
+    }
+
+    // Replace messages array contents
+    messages.length = 0
+    messages.push(...result)
+}

package/lib/messages/query.ts

@@ -0,0 +1,71 @@
+import type { PluginConfig } from "../config"
+import type { WithParts } from "../state"
+import { isMessageWithInfo } from "./shape"
+
+export const getLastUserMessage = (
+    messages: WithParts[],
+    startIndex?: number,
+): WithParts | null => {
+    const start = startIndex ?? messages.length - 1
+    for (let i = start; i >= 0; i--) {
+        const msg = messages[i]
+        if (!isMessageWithInfo(msg)) {
+            continue
+        }
+        if (msg.info.role === "user" && !isIgnoredUserMessage(msg)) {
+            return msg
+        }
+    }
+    return null
+}
+
+export const messageHasCompress = (message: WithParts): boolean => {
+    if (!isMessageWithInfo(message)) {
+        return false
+    }
+
+    if (message.info.role !== "assistant") {
+        return false
+    }
+
+    const parts = Array.isArray(message.parts) ? message.parts : []
+    return parts.some(
+        (part) =>
+            part.type === "tool" && part.tool === "compress" && part.state?.status === "completed",
+    )
+}
+
+export const isIgnoredUserMessage = (message: WithParts): boolean => {
+    if (!isMessageWithInfo(message)) {
+        return false
+    }
+
+    if (message.info.role !== "user") {
+        return false
+    }
+
+    const parts = Array.isArray(message.parts) ? message.parts : []
+    if (parts.length === 0) {
+        return true
+    }
+
+    for (const part of parts) {
+        if (!(part as any).ignored) {
+            return false
+        }
+    }
+
+    return true
+}
+
+export function isProtectedUserMessage(config: PluginConfig, message: WithParts): boolean {
+    if (!isMessageWithInfo(message)) {
+        return false
+    }
+
+    return (
+        config.compress.protectUserMessages &&
+        message.info.role === "user" &&
+        !isIgnoredUserMessage(message)
+    )
+}

package/lib/messages/reasoning-strip.ts

@@ -0,0 +1,40 @@
+import type { WithParts } from "../state"
+import { getLastUserMessage } from "./query"
+
+/**
+ * Mirrors opencode's differentModel handling by preserving part content while
+ * dropping provider metadata on assistant parts that came from a different
+ * model/provider than the current turn's user message.
+ */
+export function stripStaleMetadata(messages: WithParts[]): void {
+    const lastUserMessage = getLastUserMessage(messages)
+    if (lastUserMessage?.info.role !== "user") {
+        return
+    }
+
+    const modelID = lastUserMessage.info.model.modelID
+    const providerID = lastUserMessage.info.model.providerID
+
+    messages.forEach((message) => {
+        if (message.info.role !== "assistant") {
+            return
+        }
+
+        if (message.info.modelID === modelID && message.info.providerID === providerID) {
+            return
+        }
+
+        message.parts = message.parts.map((part) => {
+            if (part.type !== "text" && part.type !== "tool" && part.type !== "reasoning") {
+                return part
+            }
+
+            if (!("metadata" in part)) {
+                return part
+            }
+
+            const { metadata: _metadata, ...rest } = part
+            return rest
+        })
+    })
+}

package/lib/messages/shape.ts

@@ -0,0 +1,50 @@
+import type { WithParts } from "../state"
+
+export function isMessageWithInfo(message: unknown): message is WithParts {
+    if (!message || typeof message !== "object") {
+        return false
+    }
+
+    const info = (message as any).info
+    const parts = (message as any).parts
+    if (!info || typeof info !== "object") {
+        return false
+    }
+
+    return (
+        typeof info.id === "string" &&
+        info.id.length > 0 &&
+        typeof info.sessionID === "string" &&
+        info.sessionID.length > 0 &&
+        (info.role === "user" || info.role === "assistant") &&
+        info.time &&
+        typeof info.time === "object" &&
+        typeof info.time.created === "number" &&
+        Array.isArray(parts)
+    )
+}
+
+export function filterMessages(messages: unknown): WithParts[] {
+    if (!Array.isArray(messages)) {
+        return []
+    }
+
+    return messages.filter(isMessageWithInfo)
+}
+
+export function filterMessagesInPlace(messages: unknown): WithParts[] {
+    if (!Array.isArray(messages)) {
+        return []
+    }
+
+    let writeIndex = 0
+
+    for (const message of messages) {
+        if (isMessageWithInfo(message)) {
+            messages[writeIndex++] = message
+        }
+    }
+
+    messages.length = writeIndex
+    return messages as WithParts[]
+}

package/lib/messages/sync.ts

@@ -0,0 +1,124 @@
+import type { SessionState, WithParts } from "../state"
+import type { Logger } from "../logger"
+
+function sortBlocksByCreation(
+    a: { createdAt: number; blockId: number },
+    b: { createdAt: number; blockId: number },
+): number {
+    const createdAtDiff = a.createdAt - b.createdAt
+    if (createdAtDiff !== 0) {
+        return createdAtDiff
+    }
+    return a.blockId - b.blockId
+}
+
+export const syncCompressionBlocks = (
+    state: SessionState,
+    logger: Logger,
+    messages: WithParts[],
+): void => {
+    const messagesState = state.prune.messages
+    if (!messagesState?.blocksById?.size) {
+        return
+    }
+
+    const messageIds = new Set(messages.map((msg) => msg.info.id))
+    const previousActiveBlockIds = new Set<number>(
+        Array.from(messagesState.blocksById.values())
+            .filter((block) => block.active)
+            .map((block) => block.blockId),
+    )
+
+    messagesState.activeBlockIds.clear()
+    messagesState.activeByAnchorMessageId.clear()
+
+    const now = Date.now()
+    const missingOriginBlockIds: number[] = []
+    const orderedBlocks = Array.from(messagesState.blocksById.values()).sort(sortBlocksByCreation)
+
+    for (const block of orderedBlocks) {
+        const hasOriginMessage =
+            typeof block.compressMessageId === "string" &&
+            block.compressMessageId.length > 0 &&
+            messageIds.has(block.compressMessageId)
+
+        if (!hasOriginMessage) {
+            block.active = false
+            block.deactivatedAt = now
+            block.deactivatedByBlockId = undefined
+            missingOriginBlockIds.push(block.blockId)
+            continue
+        }
+
+        if (block.deactivatedByUser) {
+            block.active = false
+            if (block.deactivatedAt === undefined) {
+                block.deactivatedAt = now
+            }
+            block.deactivatedByBlockId = undefined
+            continue
+        }
+
+        for (const consumedBlockId of block.consumedBlockIds) {
+            if (!messagesState.activeBlockIds.has(consumedBlockId)) {
+                continue
+            }
+
+            const consumedBlock = messagesState.blocksById.get(consumedBlockId)
+            if (consumedBlock) {
+                consumedBlock.active = false
+                consumedBlock.deactivatedAt = now
+                consumedBlock.deactivatedByBlockId = block.blockId
+
+                const mappedBlockId = messagesState.activeByAnchorMessageId.get(
+                    consumedBlock.anchorMessageId,
+                )
+                if (mappedBlockId === consumedBlock.blockId) {
+                    messagesState.activeByAnchorMessageId.delete(consumedBlock.anchorMessageId)
+                }
+            }
+
+            messagesState.activeBlockIds.delete(consumedBlockId)
+        }
+
+        block.active = true
+        block.deactivatedAt = undefined
+        block.deactivatedByBlockId = undefined
+        messagesState.activeBlockIds.add(block.blockId)
+        if (messageIds.has(block.anchorMessageId)) {
+            messagesState.activeByAnchorMessageId.set(block.anchorMessageId, block.blockId)
+        }
+    }
+
+    for (const entry of messagesState.byMessageId.values()) {
+        const allBlockIds = Array.isArray(entry.allBlockIds)
+            ? [...new Set(entry.allBlockIds.filter((id) => Number.isInteger(id) && id > 0))]
+            : []
+
+        entry.allBlockIds = allBlockIds
+        entry.activeBlockIds = allBlockIds.filter((id) => messagesState.activeBlockIds.has(id))
+    }
+
+    const nextActiveBlockIds = messagesState.activeBlockIds
+    let deactivatedCount = 0
+    let reactivatedCount = 0
+
+    for (const blockId of previousActiveBlockIds) {
+        if (!nextActiveBlockIds.has(blockId)) {
+            deactivatedCount++
+        }
+    }
+    for (const blockId of nextActiveBlockIds) {
+        if (!previousActiveBlockIds.has(blockId)) {
+            reactivatedCount++
+        }
+    }
+
+    if (missingOriginBlockIds.length > 0 || deactivatedCount > 0 || reactivatedCount > 0) {
+        logger.info("Synced compress block state", {
+            missingOriginCount: missingOriginBlockIds.length,
+            deactivatedCount,
+            reactivatedCount,
+        })
+    }
+}