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

package/lib/compress/message-utils.ts

@@ -0,0 +1,250 @@
+import type { PluginConfig } from "../config"
+import type { SessionState } from "../state"
+import { parseBoundaryId } from "../message-ids"
+import { isIgnoredUserMessage, isProtectedUserMessage } from "../messages/query"
+import { resolveAnchorMessageId, resolveBoundaryIds, resolveSelection } from "./search"
+import { COMPRESSED_BLOCK_HEADER } from "./state"
+import type {
+    CompressMessageEntry,
+    CompressMessageToolArgs,
+    ResolvedMessageCompression,
+    ResolvedMessageCompressionsResult,
+    SearchContext,
+} from "./types"
+
+interface SkippedIssue {
+    kind: string
+    messageId: string
+}
+
+class SoftIssue extends Error {
+    constructor(
+        public readonly kind: string,
+        public readonly messageId: string,
+        message: string,
+    ) {
+        super(message)
+    }
+}
+
+export function validateArgs(args: CompressMessageToolArgs): void {
+    if (typeof args.topic !== "string" || args.topic.trim().length === 0) {
+        throw new Error("topic is required and must be a non-empty string")
+    }
+
+    if (!Array.isArray(args.content) || args.content.length === 0) {
+        throw new Error("content is required and must be a non-empty array")
+    }
+
+    for (let index = 0; index < args.content.length; index++) {
+        const entry = args.content[index]
+        const prefix = `content[${index}]`
+
+        if (typeof entry?.messageId !== "string" || entry.messageId.trim().length === 0) {
+            throw new Error(`${prefix}.messageId is required and must be a non-empty string`)
+        }
+
+        if (typeof entry?.topic !== "string" || entry.topic.trim().length === 0) {
+            throw new Error(`${prefix}.topic is required and must be a non-empty string`)
+        }
+
+        if (typeof entry?.summary !== "string" || entry.summary.trim().length === 0) {
+            throw new Error(`${prefix}.summary is required and must be a non-empty string`)
+        }
+    }
+}
+
+export function formatResult(
+    processedCount: number,
+    skippedIssues: string[],
+    skippedCount: number,
+): string {
+    const messageNoun = processedCount === 1 ? "message" : "messages"
+    const processedText =
+        processedCount > 0
+            ? `Compressed ${processedCount} ${messageNoun} into ${COMPRESSED_BLOCK_HEADER}.`
+            : "Compressed 0 messages."
+
+    if (skippedCount === 0) {
+        return processedText
+    }
+
+    const issueNoun = skippedCount === 1 ? "issue" : "issues"
+    const issueLines = skippedIssues.map((issue) => `- ${issue}`).join("\n")
+    return `${processedText}\nSkipped ${skippedCount} ${issueNoun}:\n${issueLines}`
+}
+
+export function formatIssues(skippedIssues: string[], skippedCount: number): string {
+    const issueNoun = skippedCount === 1 ? "issue" : "issues"
+    const issueLines = skippedIssues.map((issue) => `- ${issue}`).join("\n")
+    return `Unable to compress any messages. Found ${skippedCount} ${issueNoun}:\n${issueLines}`
+}
+
+const ISSUE_TEMPLATES: Record<string, [singular: string, plural: string]> = {
+    blocked: [
+        "refers to a protected message and cannot be compressed.",
+        "refer to protected messages and cannot be compressed.",
+    ],
+    "invalid-format": [
+        "is invalid. Use an injected raw message ID of the form mNNNN.",
+        "are invalid. Use injected raw message IDs of the form mNNNN.",
+    ],
+    "block-id": [
+        "is invalid here. Block IDs like bN are not allowed; use an mNNNN message ID instead.",
+        "are invalid here. Block IDs like bN are not allowed; use mNNNN message IDs instead.",
+    ],
+    "not-in-context": [
+        "is not available in the current conversation context. Choose an injected mNNNN ID visible in context.",
+        "are not available in the current conversation context. Choose injected mNNNN IDs visible in context.",
+    ],
+    protected: [
+        "refers to a protected message and cannot be compressed.",
+        "refer to protected messages and cannot be compressed.",
+    ],
+    "already-compressed": [
+        "is already part of an active compression.",
+        "are already part of active compressions.",
+    ],
+    duplicate: [
+        "was selected more than once in this batch.",
+        "were each selected more than once in this batch.",
+    ],
+}
+
+function formatSkippedGroup(kind: string, messageIds: string[]): string {
+    const templates = ISSUE_TEMPLATES[kind]
+    const ids = messageIds.join(", ")
+    const single = messageIds.length === 1
+    const prefix = single ? "messageId" : "messageIds"
+
+    if (!templates) {
+        return `${prefix} ${ids}: unknown issue.`
+    }
+
+    return `${prefix} ${ids} ${single ? templates[0] : templates[1]}`
+}
+
+function groupSkippedIssues(issues: SkippedIssue[]): string[] {
+    const groups = new Map<string, string[]>()
+    const order: string[] = []
+
+    for (const issue of issues) {
+        let ids = groups.get(issue.kind)
+        if (!ids) {
+            ids = []
+            groups.set(issue.kind, ids)
+            order.push(issue.kind)
+        }
+        ids.push(issue.messageId)
+    }
+
+    return order.map((kind) => {
+        const ids = groups.get(kind)!
+        return formatSkippedGroup(kind, ids)
+    })
+}
+
+export function resolveMessages(
+    args: CompressMessageToolArgs,
+    searchContext: SearchContext,
+    state: SessionState,
+    config: PluginConfig,
+): ResolvedMessageCompressionsResult {
+    const issues: SkippedIssue[] = []
+    const plans: ResolvedMessageCompression[] = []
+    const seenMessageIds = new Set<string>()
+
+    for (const entry of args.content) {
+        const normalizedMessageId = entry.messageId.trim()
+        if (seenMessageIds.has(normalizedMessageId)) {
+            issues.push({ kind: "duplicate", messageId: normalizedMessageId })
+            continue
+        }
+
+        try {
+            const plan = resolveMessage(
+                {
+                    ...entry,
+                    messageId: normalizedMessageId,
+                },
+                searchContext,
+                state,
+                config,
+            )
+            seenMessageIds.add(plan.entry.messageId)
+            plans.push(plan)
+        } catch (error: any) {
+            if (error instanceof SoftIssue) {
+                issues.push({ kind: error.kind, messageId: error.messageId })
+                continue
+            }
+
+            throw error
+        }
+    }
+
+    return {
+        plans,
+        skippedIssues: groupSkippedIssues(issues),
+        skippedCount: issues.length,
+    }
+}
+
+function resolveMessage(
+    entry: CompressMessageEntry,
+    searchContext: SearchContext,
+    state: SessionState,
+    config: PluginConfig,
+): ResolvedMessageCompression {
+    if (entry.messageId.toUpperCase() === "BLOCKED") {
+        throw new SoftIssue("blocked", "BLOCKED", "protected message")
+    }
+
+    const parsed = parseBoundaryId(entry.messageId)
+
+    if (!parsed) {
+        throw new SoftIssue("invalid-format", entry.messageId, "invalid format")
+    }
+
+    if (parsed.kind === "compressed-block") {
+        throw new SoftIssue("block-id", entry.messageId, "block ID used")
+    }
+
+    const messageId = state.messageIds.byRef.get(parsed.ref)
+    const rawMessage = messageId ? searchContext.rawMessagesById.get(messageId) : undefined
+    if (
+        !messageId ||
+        !rawMessage ||
+        !searchContext.rawIndexById.has(messageId) ||
+        isIgnoredUserMessage(rawMessage)
+    ) {
+        throw new SoftIssue("not-in-context", parsed.ref, "not in context")
+    }
+
+    const { startReference, endReference } = resolveBoundaryIds(
+        searchContext,
+        state,
+        parsed.ref,
+        parsed.ref,
+    )
+    const selection = resolveSelection(searchContext, startReference, endReference)
+
+    if (isProtectedUserMessage(config, rawMessage)) {
+        throw new SoftIssue("protected", parsed.ref, "protected message")
+    }
+
+    const pruneEntry = state.prune.messages.byMessageId.get(messageId)
+    if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
+        throw new SoftIssue("already-compressed", parsed.ref, "already compressed")
+    }
+
+    return {
+        entry: {
+            messageId: parsed.ref,
+            topic: entry.topic,
+            summary: entry.summary,
+        },
+        selection,
+        anchorMessageId: resolveAnchorMessageId(startReference),
+    }
+}

package/lib/compress/message.ts

@@ -0,0 +1,137 @@
+import { tool } from "@opencode-ai/plugin"
+import type { ToolContext } from "./types"
+import { countTokens } from "../token-utils"
+import { MESSAGE_FORMAT_EXTENSION } from "../prompts/extensions/tool"
+import { formatIssues, formatResult, resolveMessages, validateArgs } from "./message-utils"
+import { finalizeSession, prepareSession, type NotificationEntry } from "./pipeline"
+import { appendProtectedTools } from "./protected-content"
+import {
+    allocateBlockId,
+    allocateRunId,
+    applyCompressionState,
+    wrapCompressedSummary,
+} from "./state"
+import type { CompressMessageToolArgs } from "./types"
+
+function buildSchema() {
+    return {
+        topic: tool.schema
+            .string()
+            .describe(
+                "Short label (3-5 words) for the overall batch - e.g., 'Closed Research Notes'",
+            ),
+        content: tool.schema
+            .array(
+                tool.schema.object({
+                    messageId: tool.schema
+                        .string()
+                        .describe("Raw message ID to compress (e.g. m0001)"),
+                    topic: tool.schema
+                        .string()
+                        .describe("Short label (3-5 words) for this one message summary"),
+                    summary: tool.schema
+                        .string()
+                        .describe("Complete technical summary replacing that one message"),
+                }),
+            )
+            .describe("Batch of individual message summaries to create in one tool call"),
+    }
+}
+
+export function createCompressMessageTool(ctx: ToolContext): ReturnType<typeof tool> {
+    ctx.prompts.reload()
+    const runtimePrompts = ctx.prompts.getRuntimePrompts()
+
+    return tool({
+        description: runtimePrompts.compressMessage + MESSAGE_FORMAT_EXTENSION,
+        args: buildSchema(),
+        async execute(args, toolCtx) {
+            const input = args as CompressMessageToolArgs
+            validateArgs(input)
+            const callId =
+                typeof (toolCtx as unknown as { callID?: unknown }).callID === "string"
+                    ? (toolCtx as unknown as { callID: string }).callID
+                    : undefined
+
+            const { rawMessages, searchContext } = await prepareSession(
+                ctx,
+                toolCtx,
+                `Compress Message: ${input.topic}`,
+            )
+            const { plans, skippedIssues, skippedCount } = resolveMessages(
+                input,
+                searchContext,
+                ctx.state,
+                ctx.config,
+            )
+
+            if (plans.length === 0 && skippedCount > 0) {
+                throw new Error(formatIssues(skippedIssues, skippedCount))
+            }
+
+            const notifications: NotificationEntry[] = []
+
+            const preparedPlans: Array<{
+                plan: (typeof plans)[number]
+                summaryWithTools: string
+            }> = []
+
+            for (const plan of plans) {
+                const summaryWithTools = await appendProtectedTools(
+                    ctx.client,
+                    ctx.state,
+                    ctx.config.experimental.allowSubAgents,
+                    plan.entry.summary,
+                    plan.selection,
+                    searchContext,
+                    ctx.config.compress.protectedTools,
+                    ctx.config.protectedFilePatterns,
+                )
+
+                preparedPlans.push({
+                    plan,
+                    summaryWithTools,
+                })
+            }
+
+            const runId = allocateRunId(ctx.state)
+
+            for (const { plan, summaryWithTools } of preparedPlans) {
+                const blockId = allocateBlockId(ctx.state)
+                const storedSummary = wrapCompressedSummary(blockId, summaryWithTools)
+                const summaryTokens = countTokens(storedSummary)
+
+                applyCompressionState(
+                    ctx.state,
+                    {
+                        topic: plan.entry.topic,
+                        batchTopic: input.topic,
+                        startId: plan.entry.messageId,
+                        endId: plan.entry.messageId,
+                        mode: "message",
+                        runId,
+                        compressMessageId: toolCtx.messageID,
+                        compressCallId: callId,
+                        summaryTokens,
+                    },
+                    plan.selection,
+                    plan.anchorMessageId,
+                    blockId,
+                    storedSummary,
+                    [],
+                )
+
+                notifications.push({
+                    blockId,
+                    runId,
+                    summary: summaryWithTools,
+                    summaryTokens,
+                })
+            }
+
+            await finalizeSession(ctx, toolCtx, rawMessages, notifications, input.topic)
+
+            return formatResult(plans.length, skippedIssues, skippedCount)
+        },
+    })
+}

package/lib/compress/pipeline.ts

@@ -0,0 +1,106 @@
+import type { WithParts } from "../state"
+import { ensureSessionInitialized } from "../state"
+import { saveSessionState } from "../state/persistence"
+import { assignMessageRefs } from "../message-ids"
+import { isIgnoredUserMessage } from "../messages/query"
+import { deduplicate, purgeErrors } from "../strategies"
+import { getCurrentParams } from "../token-utils"
+import { sendCompressNotification } from "../ui/notification"
+import type { ToolContext } from "./types"
+import { buildSearchContext, fetchSessionMessages } from "./search"
+import type { SearchContext } from "./types"
+import { applyPendingCompressionDurations } from "./timing"
+
+interface RunContext {
+    ask(input: {
+        permission: string
+        patterns: string[]
+        always: string[]
+        metadata: Record<string, unknown>
+    }): Promise<void>
+    metadata(input: { title: string }): void
+    sessionID: string
+}
+
+export interface NotificationEntry {
+    blockId: number
+    runId: number
+    summary: string
+    summaryTokens: number
+}
+
+export interface PreparedSession {
+    rawMessages: WithParts[]
+    searchContext: SearchContext
+}
+
+export async function prepareSession(
+    ctx: ToolContext,
+    toolCtx: RunContext,
+    title: string,
+): Promise<PreparedSession> {
+    if (ctx.state.manualMode && ctx.state.manualMode !== "compress-pending") {
+        throw new Error(
+            "Manual mode: compress blocked. Do not retry until `<compress triggered manually>` appears in user context.",
+        )
+    }
+
+    await toolCtx.ask({
+        permission: "compress",
+        patterns: ["*"],
+        always: ["*"],
+        metadata: {},
+    })
+
+    toolCtx.metadata({ title })
+
+    const rawMessages = await fetchSessionMessages(ctx.client, toolCtx.sessionID)
+
+    await ensureSessionInitialized(
+        ctx.client,
+        ctx.state,
+        toolCtx.sessionID,
+        ctx.logger,
+        rawMessages,
+        ctx.config.manualMode.enabled,
+    )
+
+    assignMessageRefs(ctx.state, rawMessages)
+
+    deduplicate(ctx.state, ctx.logger, ctx.config, rawMessages)
+    purgeErrors(ctx.state, ctx.logger, ctx.config, rawMessages)
+
+    return {
+        rawMessages,
+        searchContext: buildSearchContext(ctx.state, rawMessages),
+    }
+}
+
+export async function finalizeSession(
+    ctx: ToolContext,
+    toolCtx: RunContext,
+    rawMessages: WithParts[],
+    entries: NotificationEntry[],
+    batchTopic: string | undefined,
+): Promise<void> {
+    ctx.state.manualMode = ctx.state.manualMode ? "active" : false
+    applyPendingCompressionDurations(ctx.state)
+    await saveSessionState(ctx.state, ctx.logger)
+
+    const params = getCurrentParams(ctx.state, rawMessages, ctx.logger)
+    const sessionMessageIds = rawMessages
+        .filter((msg) => !isIgnoredUserMessage(msg))
+        .map((msg) => msg.info.id)
+
+    await sendCompressNotification(
+        ctx.client,
+        ctx.logger,
+        ctx.config,
+        ctx.state,
+        toolCtx.sessionID,
+        entries,
+        batchTopic,
+        sessionMessageIds,
+        params,
+    )
+}

package/lib/compress/protected-content.ts

@@ -0,0 +1,154 @@
+import type { SessionState } from "../state"
+import { isIgnoredUserMessage } from "../messages/query"
+import {
+    getFilePathsFromParameters,
+    isFilePathProtected,
+    isToolNameProtected,
+} from "../protected-patterns"
+import {
+    buildSubagentResultText,
+    getSubAgentId,
+    mergeSubagentResult,
+} from "../subagents/subagent-results"
+import { fetchSessionMessages } from "./search"
+import type { SearchContext, SelectionResolution } from "./types"
+
+export function appendProtectedUserMessages(
+    summary: string,
+    selection: SelectionResolution,
+    searchContext: SearchContext,
+    state: SessionState,
+    enabled: boolean,
+): string {
+    if (!enabled) return summary
+
+    const userTexts: string[] = []
+
+    for (const messageId of selection.messageIds) {
+        const existingCompressionEntry = state.prune.messages.byMessageId.get(messageId)
+        if (existingCompressionEntry && existingCompressionEntry.activeBlockIds.length > 0) {
+            continue
+        }
+
+        const message = searchContext.rawMessagesById.get(messageId)
+        if (!message) continue
+        if (message.info.role !== "user") continue
+        if (isIgnoredUserMessage(message)) continue
+
+        const parts = Array.isArray(message.parts) ? message.parts : []
+        for (const part of parts) {
+            if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
+                userTexts.push(part.text)
+                break
+            }
+        }
+    }
+
+    if (userTexts.length === 0) {
+        return summary
+    }
+
+    const heading = "\n\nThe following user messages were sent in this conversation verbatim:"
+    const body = userTexts.map((text) => `\n${text}`).join("")
+    return summary + heading + body
+}
+
+export async function appendProtectedTools(
+    client: any,
+    state: SessionState,
+    allowSubAgents: boolean,
+    summary: string,
+    selection: SelectionResolution,
+    searchContext: SearchContext,
+    protectedTools: string[],
+    protectedFilePatterns: string[] = [],
+): Promise<string> {
+    const protectedOutputs: string[] = []
+
+    for (const messageId of selection.messageIds) {
+        const existingCompressionEntry = state.prune.messages.byMessageId.get(messageId)
+        if (existingCompressionEntry && existingCompressionEntry.activeBlockIds.length > 0) {
+            continue
+        }
+
+        const message = searchContext.rawMessagesById.get(messageId)
+        if (!message) continue
+
+        const parts = Array.isArray(message.parts) ? message.parts : []
+        for (const part of parts) {
+            if (part.type === "tool" && part.callID) {
+                let isToolProtected = isToolNameProtected(part.tool, protectedTools)
+
+                if (!isToolProtected && protectedFilePatterns.length > 0) {
+                    const filePaths = getFilePathsFromParameters(part.tool, part.state?.input)
+                    if (isFilePathProtected(filePaths, protectedFilePatterns)) {
+                        isToolProtected = true
+                    }
+                }
+
+                if (isToolProtected) {
+                    const title = `Tool: ${part.tool}`
+                    let output = ""
+
+                    if (part.state?.status === "completed" && part.state?.output) {
+                        output =
+                            typeof part.state.output === "string"
+                                ? part.state.output
+                                : JSON.stringify(part.state.output)
+                    }
+
+                    if (
+                        allowSubAgents &&
+                        part.tool === "task" &&
+                        part.state?.status === "completed" &&
+                        typeof part.state?.output === "string"
+                    ) {
+                        const cachedSubAgentResult = state.subAgentResultCache.get(part.callID)
+
+                        if (cachedSubAgentResult !== undefined) {
+                            if (cachedSubAgentResult) {
+                                output = mergeSubagentResult(
+                                    part.state.output,
+                                    cachedSubAgentResult,
+                                )
+                            }
+                        } else {
+                            const subAgentSessionId = getSubAgentId(part)
+                            if (subAgentSessionId) {
+                                let subAgentResultText = ""
+                                try {
+                                    const subAgentMessages = await fetchSessionMessages(
+                                        client,
+                                        subAgentSessionId,
+                                    )
+                                    subAgentResultText = buildSubagentResultText(subAgentMessages)
+                                } catch {
+                                    subAgentResultText = ""
+                                }
+
+                                if (subAgentResultText) {
+                                    state.subAgentResultCache.set(part.callID, subAgentResultText)
+                                    output = mergeSubagentResult(
+                                        part.state.output,
+                                        subAgentResultText,
+                                    )
+                                }
+                            }
+                        }
+                    }
+
+                    if (output) {
+                        protectedOutputs.push(`\n### ${title}\n${output}`)
+                    }
+                }
+            }
+        }
+    }
+
+    if (protectedOutputs.length === 0) {
+        return summary
+    }
+
+    const heading = "\n\nThe following protected tools were used in this conversation as well:"
+    return summary + heading + protectedOutputs.join("")
+}