@tarquinen/opencode-dcp 3.2.4-beta0 → 3.2.6-beta0

package/lib/messages/inject/utils.ts

@@ -0,0 +1,374 @@
+import type { SessionState, WithParts } from "../../state"
+import type { PluginConfig } from "../../config"
+import {
+    appendGuidanceToDcpTag,
+    buildCompressedBlockGuidance,
+    renderMessagePriorityGuidance,
+} from "../../prompts/extensions/nudge"
+import type { RuntimePrompts } from "../../prompts/store"
+import type { UserMessage } from "@opencode-ai/sdk/v2"
+import {
+    type CompressionPriorityMap,
+    type MessagePriority,
+    listPriorityRefsBeforeIndex,
+} from "../priority"
+import {
+    appendToTextPart,
+    appendToLastTextPart,
+    createSyntheticTextPart,
+    hasContent,
+} from "../utils"
+import { getLastUserMessage, isIgnoredUserMessage } from "../query"
+import { getCurrentTokenUsage } from "../../token-utils"
+import { getActiveSummaryTokenUsage } from "../../state/utils"
+
+const MESSAGE_MODE_NUDGE_PRIORITY: MessagePriority = "high"
+
+export interface LastUserModelContext {
+    providerId: string | undefined
+    modelId: string | undefined
+}
+
+export interface LastNonIgnoredMessage {
+    message: WithParts
+    index: number
+}
+
+export function getNudgeFrequency(config: PluginConfig): number {
+    return Math.max(1, Math.floor(config.compress.nudgeFrequency || 1))
+}
+
+export function getIterationNudgeThreshold(config: PluginConfig): number {
+    return Math.max(1, Math.floor(config.compress.iterationNudgeThreshold || 1))
+}
+
+export function findLastNonIgnoredMessage(messages: WithParts[]): LastNonIgnoredMessage | null {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i]
+        if (isIgnoredUserMessage(message)) {
+            continue
+        }
+        return { message, index: i }
+    }
+
+    return null
+}
+
+export function countMessagesAfterIndex(messages: WithParts[], index: number): number {
+    let count = 0
+
+    for (let i = index + 1; i < messages.length; i++) {
+        const message = messages[i]
+        if (isIgnoredUserMessage(message)) {
+            continue
+        }
+        count++
+    }
+
+    return count
+}
+
+export function getModelInfo(messages: WithParts[]): LastUserModelContext {
+    const lastUserMessage = getLastUserMessage(messages)
+    if (!lastUserMessage) {
+        return {
+            providerId: undefined,
+            modelId: undefined,
+        }
+    }
+
+    const userInfo = lastUserMessage.info as UserMessage
+    return {
+        providerId: userInfo.model.providerID,
+        modelId: userInfo.model.modelID,
+    }
+}
+
+function resolveContextTokenLimit(
+    config: PluginConfig,
+    state: SessionState,
+    providerId: string | undefined,
+    modelId: string | undefined,
+    threshold: "max" | "min",
+): number | undefined {
+    const parseLimitValue = (limit: number | `${number}%` | undefined): number | undefined => {
+        if (limit === undefined) {
+            return undefined
+        }
+
+        if (typeof limit === "number") {
+            return limit
+        }
+
+        if (!limit.endsWith("%") || state.modelContextLimit === undefined) {
+            return undefined
+        }
+
+        const parsedPercent = parseFloat(limit.slice(0, -1))
+        if (isNaN(parsedPercent)) {
+            return undefined
+        }
+
+        const roundedPercent = Math.round(parsedPercent)
+        const clampedPercent = Math.max(0, Math.min(100, roundedPercent))
+        return Math.round((clampedPercent / 100) * state.modelContextLimit)
+    }
+
+    const modelLimits =
+        threshold === "max" ? config.compress.modelMaxLimits : config.compress.modelMinLimits
+    if (modelLimits && providerId !== undefined && modelId !== undefined) {
+        const providerModelId = `${providerId}/${modelId}`
+        const modelLimit = modelLimits[providerModelId]
+        if (modelLimit !== undefined) {
+            return parseLimitValue(modelLimit)
+        }
+    }
+
+    const globalLimit =
+        threshold === "max" ? config.compress.maxContextLimit : config.compress.minContextLimit
+    return parseLimitValue(globalLimit)
+}
+
+export function isContextOverLimits(
+    config: PluginConfig,
+    state: SessionState,
+    providerId: string | undefined,
+    modelId: string | undefined,
+    messages: WithParts[],
+) {
+    const summaryTokenExtension = config.compress.summaryBuffer
+        ? getActiveSummaryTokenUsage(state)
+        : 0
+    const resolvedMaxContextLimit = resolveContextTokenLimit(
+        config,
+        state,
+        providerId,
+        modelId,
+        "max",
+    )
+    const maxContextLimit =
+        resolvedMaxContextLimit === undefined
+            ? undefined
+            : resolvedMaxContextLimit + summaryTokenExtension
+    const minContextLimit = resolveContextTokenLimit(config, state, providerId, modelId, "min")
+    const currentTokens = getCurrentTokenUsage(state, messages)
+
+    const overMaxLimit = maxContextLimit === undefined ? false : currentTokens > maxContextLimit
+    const overMinLimit = minContextLimit === undefined ? true : currentTokens >= minContextLimit
+
+    return {
+        overMaxLimit,
+        overMinLimit,
+    }
+}
+
+export function addAnchor(
+    anchorMessageIds: Set<string>,
+    anchorMessageId: string,
+    anchorMessageIndex: number,
+    messages: WithParts[],
+    interval: number,
+): boolean {
+    if (anchorMessageIndex < 0) {
+        return false
+    }
+
+    let latestAnchorMessageIndex = -1
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (anchorMessageIds.has(messages[i].info.id)) {
+            latestAnchorMessageIndex = i
+            break
+        }
+    }
+
+    const shouldAdd =
+        latestAnchorMessageIndex < 0 || anchorMessageIndex - latestAnchorMessageIndex >= interval
+    if (!shouldAdd) {
+        return false
+    }
+
+    const previousSize = anchorMessageIds.size
+    anchorMessageIds.add(anchorMessageId)
+    return anchorMessageIds.size !== previousSize
+}
+
+function buildMessagePriorityGuidance(
+    messages: WithParts[],
+    compressionPriorities: CompressionPriorityMap | undefined,
+    anchorIndex: number,
+    priority: MessagePriority,
+): string {
+    if (!compressionPriorities || compressionPriorities.size === 0) {
+        return ""
+    }
+
+    const refs = listPriorityRefsBeforeIndex(messages, compressionPriorities, anchorIndex, priority)
+    const priorityLabel = `${priority[0].toUpperCase()}${priority.slice(1)}`
+
+    return renderMessagePriorityGuidance(priorityLabel, refs)
+}
+
+function injectAnchoredNudge(message: WithParts, nudgeText: string): void {
+    if (!nudgeText.trim()) {
+        return
+    }
+
+    if (message.info.role === "user") {
+        if (appendToLastTextPart(message, nudgeText)) {
+            return
+        }
+
+        message.parts.push(createSyntheticTextPart(message, nudgeText))
+        return
+    }
+
+    if (message.info.role !== "assistant") {
+        return
+    }
+
+    if (!hasContent(message)) {
+        return
+    }
+
+    for (const part of message.parts) {
+        if (part.type === "text") {
+            if (appendToTextPart(part, nudgeText)) {
+                return
+            }
+        }
+    }
+
+    const syntheticPart = createSyntheticTextPart(message, nudgeText)
+    const firstToolIndex = message.parts.findIndex((p) => p.type === "tool")
+    if (firstToolIndex === -1) {
+        message.parts.push(syntheticPart)
+    } else {
+        message.parts.splice(firstToolIndex, 0, syntheticPart)
+    }
+}
+
+function collectAnchoredMessages(
+    anchorMessageIds: Set<string>,
+    messages: WithParts[],
+): Array<{ message: WithParts; index: number }> {
+    const anchoredMessages: Array<{ message: WithParts; index: number }> = []
+
+    for (const anchorMessageId of anchorMessageIds) {
+        const index = messages.findIndex((message) => message.info.id === anchorMessageId)
+        if (index === -1) {
+            continue
+        }
+
+        anchoredMessages.push({
+            message: messages[index],
+            index,
+        })
+    }
+
+    return anchoredMessages
+}
+
+function collectTurnNudgeAnchors(
+    state: SessionState,
+    config: PluginConfig,
+    messages: WithParts[],
+): Set<string> {
+    const turnNudgeAnchors = new Set<string>()
+    const targetRole = config.compress.nudgeForce === "strong" ? "user" : "assistant"
+
+    for (const message of messages) {
+        if (!state.nudges.turnNudgeAnchors.has(message.info.id)) continue
+
+        if (message.info.role === targetRole) {
+            turnNudgeAnchors.add(message.info.id)
+        }
+    }
+
+    return turnNudgeAnchors
+}
+
+function applyRangeModeAnchoredNudge(
+    anchorMessageIds: Set<string>,
+    messages: WithParts[],
+    baseNudgeText: string,
+    compressedBlockGuidance: string,
+): void {
+    const nudgeText = appendGuidanceToDcpTag(baseNudgeText, compressedBlockGuidance)
+    if (!nudgeText.trim()) {
+        return
+    }
+
+    for (const { message } of collectAnchoredMessages(anchorMessageIds, messages)) {
+        injectAnchoredNudge(message, nudgeText)
+    }
+}
+
+function applyMessageModeAnchoredNudge(
+    anchorMessageIds: Set<string>,
+    messages: WithParts[],
+    baseNudgeText: string,
+    compressionPriorities?: CompressionPriorityMap,
+): void {
+    for (const { message, index } of collectAnchoredMessages(anchorMessageIds, messages)) {
+        const priorityGuidance = buildMessagePriorityGuidance(
+            messages,
+            compressionPriorities,
+            index,
+            MESSAGE_MODE_NUDGE_PRIORITY,
+        )
+        const nudgeText = appendGuidanceToDcpTag(baseNudgeText, priorityGuidance)
+        injectAnchoredNudge(message, nudgeText)
+    }
+}
+
+export function applyAnchoredNudges(
+    state: SessionState,
+    config: PluginConfig,
+    messages: WithParts[],
+    prompts: RuntimePrompts,
+    compressionPriorities?: CompressionPriorityMap,
+): void {
+    const turnNudgeAnchors = collectTurnNudgeAnchors(state, config, messages)
+
+    if (config.compress.mode === "message") {
+        applyMessageModeAnchoredNudge(
+            state.nudges.contextLimitAnchors,
+            messages,
+            prompts.contextLimitNudge,
+            compressionPriorities,
+        )
+        applyMessageModeAnchoredNudge(
+            turnNudgeAnchors,
+            messages,
+            prompts.turnNudge,
+            compressionPriorities,
+        )
+        applyMessageModeAnchoredNudge(
+            state.nudges.iterationNudgeAnchors,
+            messages,
+            prompts.iterationNudge,
+            compressionPriorities,
+        )
+        return
+    }
+
+    const compressedBlockGuidance = buildCompressedBlockGuidance(state)
+    applyRangeModeAnchoredNudge(
+        state.nudges.contextLimitAnchors,
+        messages,
+        prompts.contextLimitNudge,
+        compressedBlockGuidance,
+    )
+    applyRangeModeAnchoredNudge(
+        turnNudgeAnchors,
+        messages,
+        prompts.turnNudge,
+        compressedBlockGuidance,
+    )
+    applyRangeModeAnchoredNudge(
+        state.nudges.iterationNudgeAnchors,
+        messages,
+        prompts.iterationNudge,
+        compressedBlockGuidance,
+    )
+}

package/lib/messages/priority.ts

@@ -0,0 +1,102 @@
+import type { PluginConfig } from "../config"
+import { countAllMessageTokens } from "../token-utils"
+import { isMessageCompacted } from "../state/utils"
+import type { SessionState, WithParts } from "../state"
+import { isIgnoredUserMessage, isProtectedUserMessage, messageHasCompress } from "./query"
+
+const MEDIUM_PRIORITY_MIN_TOKENS = 500
+const HIGH_PRIORITY_MIN_TOKENS = 5000
+
+export type MessagePriority = "low" | "medium" | "high"
+
+export interface CompressionPriorityEntry {
+    ref: string
+    tokenCount: number
+    priority: MessagePriority
+}
+
+export type CompressionPriorityMap = Map<string, CompressionPriorityEntry>
+
+export function buildPriorityMap(
+    config: PluginConfig,
+    state: SessionState,
+    messages: WithParts[],
+): CompressionPriorityMap {
+    if (config.compress.mode !== "message") {
+        return new Map()
+    }
+    const priorities: CompressionPriorityMap = new Map()
+
+    for (const message of messages) {
+        if (isIgnoredUserMessage(message)) {
+            continue
+        }
+
+        if (isProtectedUserMessage(config, message)) {
+            continue
+        }
+
+        if (isMessageCompacted(state, message)) {
+            continue
+        }
+
+        const rawMessageId = message.info.id
+        if (typeof rawMessageId !== "string" || rawMessageId.length === 0) {
+            continue
+        }
+
+        const ref = state.messageIds.byRawId.get(rawMessageId)
+        if (!ref) {
+            continue
+        }
+
+        const tokenCount = countAllMessageTokens(message)
+        priorities.set(rawMessageId, {
+            ref,
+            tokenCount,
+            priority: messageHasCompress(message) ? "high" : classifyMessagePriority(tokenCount),
+        })
+    }
+
+    return priorities
+}
+
+export function classifyMessagePriority(tokenCount: number): MessagePriority {
+    if (tokenCount >= HIGH_PRIORITY_MIN_TOKENS) {
+        return "high"
+    }
+
+    if (tokenCount >= MEDIUM_PRIORITY_MIN_TOKENS) {
+        return "medium"
+    }
+
+    return "low"
+}
+
+export function listPriorityRefsBeforeIndex(
+    messages: WithParts[],
+    priorities: CompressionPriorityMap,
+    anchorIndex: number,
+    priority: MessagePriority,
+): string[] {
+    const refs: string[] = []
+    const seen = new Set<string>()
+    const upperBound = Math.max(0, Math.min(anchorIndex, messages.length))
+
+    for (let index = 0; index < upperBound; index++) {
+        const rawMessageId = messages[index]?.info.id
+        if (typeof rawMessageId !== "string") {
+            continue
+        }
+
+        const entry = priorities.get(rawMessageId)
+        if (!entry || entry.priority !== priority || seen.has(entry.ref)) {
+            continue
+        }
+
+        seen.add(entry.ref)
+        refs.push(entry.ref)
+    }
+
+    return refs
+}

package/lib/messages/prune.ts

@@ -0,0 +1,238 @@
+import type { SessionState, WithParts } from "../state"
+import type { Logger } from "../logger"
+import type { PluginConfig } from "../config"
+import { isMessageCompacted } from "../state/utils"
+import { createSyntheticUserMessage, replaceBlockIdsWithBlocked } from "./utils"
+import { getLastUserMessage } from "./query"
+import type { UserMessage } from "@opencode-ai/sdk/v2"
+
+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,
+    config: PluginConfig,
+    messages: WithParts[],
+): void => {
+    filterCompressedRanges(state, logger, config, messages)
+    // 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,
+    config: PluginConfig,
+    messages: 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)
+
+                if (userMessage) {
+                    const userInfo = userMessage.info as UserMessage
+                    const summaryContent =
+                        config.compress.mode === "message"
+                            ? replaceBlockIdsWithBlocked(rawSummaryContent)
+                            : rawSummaryContent
+                    const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`
+                    result.push(
+                        createSyntheticUserMessage(
+                            userMessage,
+                            summaryContent,
+                            userInfo.variant,
+                            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)
+}