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

package/lib/strategies/deduplication.ts

@@ -0,0 +1,127 @@
+import { PluginConfig } from "../config"
+import { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import {
+    getFilePathsFromParameters,
+    isFilePathProtected,
+    isToolNameProtected,
+} 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
+        }
+
+        // Skip protected tools
+        if (isToolNameProtected(metadata.tool, protectedTools)) {
+            continue
+        }
+
+        const filePaths = getFilePathsFromParameters(metadata.tool, metadata.parameters)
+        if (isFilePathProtected(filePaths, config.protectedFilePatterns)) {
+            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,88 @@
+import { PluginConfig } from "../config"
+import { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import {
+    getFilePathsFromParameters,
+    isFilePathProtected,
+    isToolNameProtected,
+} 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
+        }
+
+        // Skip protected tools
+        if (isToolNameProtected(metadata.tool, protectedTools)) {
+            continue
+        }
+
+        const filePaths = getFilePathsFromParameters(metadata.tool, metadata.parameters)
+        if (isFilePathProtected(filePaths, config.protectedFilePatterns)) {
+            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)`,
+        )
+    }
+}

package/lib/subagents/subagent-results.ts

@@ -0,0 +1,74 @@
+import type { WithParts } from "../state"
+
+const SUB_AGENT_RESULT_BLOCK_REGEX = /(<task_result>\s*)([\s\S]*?)(\s*<\/task_result>)/i
+
+export function getSubAgentId(part: any): string | null {
+    const sessionId = part?.state?.metadata?.sessionId
+    if (typeof sessionId !== "string") {
+        return null
+    }
+
+    const value = sessionId.trim()
+    return value.length > 0 ? value : null
+}
+
+export function buildSubagentResultText(messages: WithParts[]): string {
+    const assistantMessages = messages.filter((message) => message.info.role === "assistant")
+    if (assistantMessages.length === 0) {
+        return ""
+    }
+
+    const lastAssistant = assistantMessages[assistantMessages.length - 1]
+    const lastText = getLastTextPart(lastAssistant)
+
+    if (assistantMessages.length < 2) {
+        return lastText
+    }
+
+    const secondToLastAssistant = assistantMessages[assistantMessages.length - 2]
+    if (!assistantMessageHasCompressTool(secondToLastAssistant)) {
+        return lastText
+    }
+
+    const secondToLastText = getLastTextPart(secondToLastAssistant)
+    return [secondToLastText, lastText].filter((text) => text.length > 0).join("\n\n")
+}
+
+export function mergeSubagentResult(output: string, subAgentResultText: string): string {
+    if (!subAgentResultText || typeof output !== "string") {
+        return output
+    }
+
+    return output.replace(
+        SUB_AGENT_RESULT_BLOCK_REGEX,
+        (_match, openTag: string, _body: string, closeTag: string) =>
+            `${openTag}${subAgentResultText}${closeTag}`,
+    )
+}
+
+function getLastTextPart(message: WithParts): string {
+    const parts = Array.isArray(message.parts) ? message.parts : []
+    for (let index = parts.length - 1; index >= 0; index--) {
+        const part = parts[index]
+        if (part.type !== "text" || typeof part.text !== "string") {
+            continue
+        }
+
+        const text = part.text.trim()
+        if (!text) {
+            continue
+        }
+
+        return text
+    }
+
+    return ""
+}
+
+function assistantMessageHasCompressTool(message: WithParts): boolean {
+    const parts = Array.isArray(message.parts) ? message.parts : []
+    return parts.some(
+        (part) =>
+            part.type === "tool" && part.tool === "compress" && part.state?.status === "completed",
+    )
+}

package/lib/ui/notification.ts

@@ -0,0 +1,346 @@
+import type { Logger } from "../logger"
+import type { SessionState } from "../state"
+import {
+    formatPrunedItemsList,
+    formatProgressBar,
+    formatStatsHeader,
+    formatTokenCount,
+} from "./utils"
+import { ToolParameterEntry } from "../state"
+import { PluginConfig } from "../config"
+import { getActiveSummaryTokenUsage } from "../state/utils"
+
+export type PruneReason = "completion" | "noise" | "extraction"
+export const PRUNE_REASON_LABELS: Record<PruneReason, string> = {
+    completion: "Task Complete",
+    noise: "Noise Removal",
+    extraction: "Extraction",
+}
+
+interface CompressionNotificationEntry {
+    blockId: number
+    runId: number
+    summary: string
+    summaryTokens: number
+}
+
+function buildMinimalMessage(state: SessionState, reason: PruneReason | undefined): string {
+    const reasonSuffix = reason ? ` — ${PRUNE_REASON_LABELS[reason]}` : ""
+    return (
+        formatStatsHeader(state.stats.totalPruneTokens, state.stats.pruneTokenCounter) +
+        reasonSuffix
+    )
+}
+
+function buildDetailedMessage(
+    state: SessionState,
+    reason: PruneReason | undefined,
+    pruneToolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory: string,
+): string {
+    let message = formatStatsHeader(state.stats.totalPruneTokens, state.stats.pruneTokenCounter)
+
+    if (pruneToolIds.length > 0) {
+        const pruneTokenCounterStr = `~${formatTokenCount(state.stats.pruneTokenCounter)}`
+        const reasonLabel = reason ? ` — ${PRUNE_REASON_LABELS[reason]}` : ""
+        message += `\n\n▣ Pruning (${pruneTokenCounterStr})${reasonLabel}`
+
+        const itemLines = formatPrunedItemsList(pruneToolIds, toolMetadata, workingDirectory)
+        message += "\n" + itemLines.join("\n")
+    }
+
+    return message.trim()
+}
+
+const TOAST_BODY_MAX_LINES = 12
+const TOAST_SUMMARY_MAX_CHARS = 600
+
+function truncateToastBody(body: string, maxLines: number = TOAST_BODY_MAX_LINES): string {
+    const lines = body.split("\n")
+    if (lines.length <= maxLines) {
+        return body
+    }
+    const kept = lines.slice(0, maxLines - 1)
+    const remaining = lines.length - maxLines + 1
+    return kept.join("\n") + `\n... and ${remaining} more`
+}
+
+function truncateToastSummary(summary: string, maxChars: number = TOAST_SUMMARY_MAX_CHARS): string {
+    if (summary.length <= maxChars) {
+        return summary
+    }
+    return summary.slice(0, maxChars - 3) + "..."
+}
+
+function truncateExtractedSection(
+    message: string,
+    maxChars: number = TOAST_SUMMARY_MAX_CHARS,
+): string {
+    const marker = "\n\n▣ Extracted"
+    const index = message.indexOf(marker)
+    if (index === -1) {
+        return message
+    }
+    const extracted = message.slice(index)
+    if (extracted.length <= maxChars) {
+        return message
+    }
+    return message.slice(0, index) + truncateToastSummary(extracted, maxChars)
+}
+
+export async function sendUnifiedNotification(
+    client: any,
+    logger: Logger,
+    config: PluginConfig,
+    state: SessionState,
+    sessionId: string,
+    pruneToolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    reason: PruneReason | undefined,
+    params: any,
+    workingDirectory: string,
+): Promise<boolean> {
+    const hasPruned = pruneToolIds.length > 0
+    if (!hasPruned) {
+        return false
+    }
+
+    if (config.pruneNotification === "off") {
+        return false
+    }
+
+    const message =
+        config.pruneNotification === "minimal"
+            ? buildMinimalMessage(state, reason)
+            : buildDetailedMessage(state, reason, pruneToolIds, toolMetadata, workingDirectory)
+
+    if (config.pruneNotificationType === "toast") {
+        let toastMessage = truncateExtractedSection(message)
+        toastMessage =
+            config.pruneNotification === "minimal" ? toastMessage : truncateToastBody(toastMessage)
+
+        await client.tui.showToast({
+            body: {
+                title: "DCP: Compress Notification",
+                message: toastMessage,
+                variant: "info",
+                duration: 5000,
+            },
+        })
+        return true
+    }
+
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+    return true
+}
+
+function buildCompressionSummary(
+    entries: CompressionNotificationEntry[],
+    state: SessionState,
+): string {
+    if (entries.length === 1) {
+        return entries[0]?.summary ?? ""
+    }
+
+    return entries
+        .map((entry) => {
+            const topic =
+                state.prune.messages.blocksById.get(entry.blockId)?.topic ?? "(unknown topic)"
+            return `### ${topic}\n${entry.summary}`
+        })
+        .join("\n\n")
+}
+
+function getCompressionLabel(entries: CompressionNotificationEntry[]): string {
+    const runId = entries[0]?.runId
+    if (runId === undefined) {
+        return "Compression"
+    }
+
+    return `Compression #${runId}`
+}
+
+function formatCompressionMetrics(removedTokens: number, summaryTokens: number): string {
+    const metrics = [`-${formatTokenCount(removedTokens, true)} removed`]
+    if (summaryTokens > 0) {
+        metrics.push(`+${formatTokenCount(summaryTokens, true)} summary`)
+    }
+    return metrics.join(", ")
+}
+
+export async function sendCompressNotification(
+    client: any,
+    logger: Logger,
+    config: PluginConfig,
+    state: SessionState,
+    sessionId: string,
+    entries: CompressionNotificationEntry[],
+    batchTopic: string | undefined,
+    sessionMessageIds: string[],
+    params: any,
+): Promise<boolean> {
+    if (config.pruneNotification === "off") {
+        return false
+    }
+
+    if (entries.length === 0) {
+        return false
+    }
+
+    let message: string
+    const compressionLabel = getCompressionLabel(entries)
+    const summary = buildCompressionSummary(entries, state)
+    const summaryTokens = entries.reduce((total, entry) => total + entry.summaryTokens, 0)
+    const summaryTokensStr = formatTokenCount(summaryTokens)
+    const compressedTokens = entries.reduce((total, entry) => {
+        const compressionBlock = state.prune.messages.blocksById.get(entry.blockId)
+        if (!compressionBlock) {
+            logger.error("Compression block missing for notification", {
+                compressionId: entry.blockId,
+                sessionId,
+            })
+            return total
+        }
+
+        return total + compressionBlock.compressedTokens
+    }, 0)
+
+    const newlyCompressedMessageIds: string[] = []
+    const newlyCompressedToolIds: string[] = []
+    const seenMessageIds = new Set<string>()
+    const seenToolIds = new Set<string>()
+
+    for (const entry of entries) {
+        const compressionBlock = state.prune.messages.blocksById.get(entry.blockId)
+        if (!compressionBlock) {
+            continue
+        }
+
+        for (const messageId of compressionBlock.directMessageIds) {
+            if (seenMessageIds.has(messageId)) {
+                continue
+            }
+            seenMessageIds.add(messageId)
+            newlyCompressedMessageIds.push(messageId)
+        }
+
+        for (const toolId of compressionBlock.directToolIds) {
+            if (seenToolIds.has(toolId)) {
+                continue
+            }
+            seenToolIds.add(toolId)
+            newlyCompressedToolIds.push(toolId)
+        }
+    }
+
+    const topic =
+        batchTopic ??
+        (entries.length === 1
+            ? (state.prune.messages.blocksById.get(entries[0]?.blockId ?? -1)?.topic ??
+              "(unknown topic)")
+            : "(unknown topic)")
+
+    const totalActiveSummaryTkns = getActiveSummaryTokenUsage(state)
+    const totalGross = state.stats.totalPruneTokens + state.stats.pruneTokenCounter
+    const notificationHeader = `▣ DCP | ${formatCompressionMetrics(totalGross, totalActiveSummaryTkns)}`
+
+    if (config.pruneNotification === "minimal") {
+        message = `${notificationHeader} — ${compressionLabel}`
+    } else {
+        message = notificationHeader
+        const activePrunedMessages = new Map<string, number>()
+        for (const [messageId, entry] of state.prune.messages.byMessageId) {
+            if (entry.activeBlockIds.length > 0) {
+                activePrunedMessages.set(messageId, entry.tokenCount)
+            }
+        }
+        const progressBar = formatProgressBar(
+            sessionMessageIds,
+            activePrunedMessages,
+            newlyCompressedMessageIds,
+            50,
+        )
+        message += `\n\n${progressBar}`
+        message += `\n▣ ${compressionLabel} ${formatCompressionMetrics(compressedTokens, summaryTokens)}`
+        message += `\n→ Topic: ${topic}`
+        message += `\n→ Items: ${newlyCompressedMessageIds.length} messages`
+        if (newlyCompressedToolIds.length > 0) {
+            message += ` and ${newlyCompressedToolIds.length} tools compressed`
+        } else {
+            message += ` compressed`
+        }
+        if (config.compress.showCompression) {
+            message += `\n→ Compression (~${summaryTokensStr}): ${summary}`
+        }
+    }
+
+    if (config.pruneNotificationType === "toast") {
+        let toastMessage = message
+        if (config.compress.showCompression) {
+            const truncatedSummary = truncateToastSummary(summary)
+            if (truncatedSummary !== summary) {
+                toastMessage = toastMessage.replace(
+                    `\n→ Compression (~${summaryTokensStr}): ${summary}`,
+                    `\n→ Compression (~${summaryTokensStr}): ${truncatedSummary}`,
+                )
+            }
+        }
+        toastMessage =
+            config.pruneNotification === "minimal" ? toastMessage : truncateToastBody(toastMessage)
+
+        await client.tui.showToast({
+            body: {
+                title: "DCP: Compress Notification",
+                message: toastMessage,
+                variant: "info",
+                duration: 5000,
+            },
+        })
+        return true
+    }
+
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+    return true
+}
+
+export async function sendIgnoredMessage(
+    client: any,
+    sessionID: string,
+    text: string,
+    params: any,
+    logger: Logger,
+): Promise<void> {
+    const agent = params.agent || undefined
+    const variant = params.variant || undefined
+    const model =
+        params.providerId && params.modelId
+            ? {
+                  providerID: params.providerId,
+                  modelID: params.modelId,
+              }
+            : undefined
+
+    try {
+        await client.session.prompt({
+            path: {
+                id: sessionID,
+            },
+            body: {
+                noReply: true,
+                agent: agent,
+                model: model,
+                variant: variant,
+                parts: [
+                    {
+                        type: "text",
+                        text: text,
+                        ignored: true,
+                    },
+                ],
+            },
+        })
+    } catch (error: any) {
+        logger.error("Failed to send notification", { error: error.message })
+    }
+}