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

package/lib/analysis/tokens.ts

@@ -1,225 +0,0 @@
-/**
- * Shared Token Analysis
- * Computes a breakdown of token usage across categories for a session.
- *
- * TOKEN CALCULATION STRATEGY
- * ==========================
- * We minimize tokenizer estimation by leveraging API-reported values wherever possible.
- *
- * WHAT WE GET FROM THE API (exact):
- *   - tokens.input    : Input tokens for each assistant response
- *   - tokens.output   : Output tokens generated (includes text + tool calls)
- *   - tokens.reasoning: Reasoning tokens used
- *   - tokens.cache    : Cache read/write tokens
- *
- * HOW WE CALCULATE EACH CATEGORY:
- *
- *   SYSTEM = firstAssistant.input + cache.read + cache.write - tokenizer(firstUserMessage)
- *            The first response's total input (input + cache.read + cache.write)
- *            contains system + first user message. On the first request of a
- *            session, the system prompt appears in cache.write (cache creation),
- *            not cache.read.
- *
- *   TOOLS  = tokenizer(toolInputs + toolOutputs) - prunedTokens
- *            We must tokenize tools anyway for pruning decisions.
- *
- *   USER   = tokenizer(all user messages)
- *            User messages are typically small, so estimation is acceptable.
- *
- *   ASSISTANT = total - system - user - tools
- *               Calculated as residual. This absorbs:
- *               - Assistant text output tokens
- *               - Reasoning tokens (if persisted by the model)
- *               - Any estimation errors
- *
- *   TOTAL  = input + output + reasoning + cache.read + cache.write
- *            Matches opencode's UI display.
- *
- * WHY ASSISTANT IS THE RESIDUAL:
- *   If reasoning tokens persist in context (model-dependent), they semantically
- *   belong with "Assistant" since reasoning IS assistant-generated content.
- */
-
-import type { AssistantMessage, TextPart, ToolPart } from "@opencode-ai/sdk/v2"
-import type { SessionState, WithParts } from "../state"
-import { isIgnoredUserMessage } from "../messages/query"
-import { isMessageCompacted } from "../state/utils"
-import { countTokens, extractCompletedToolOutput } from "../token-utils"
-
-export type MessageStatus = "active" | "pruned"
-
-export interface TokenBreakdown {
-    system: number
-    user: number
-    assistant: number
-    tools: number
-    toolCount: number
-    toolsInContextCount: number
-    prunedTokens: number
-    prunedToolCount: number
-    prunedMessageCount: number
-    total: number
-    messageCount: number
-}
-
-export interface TokenAnalysis {
-    breakdown: TokenBreakdown
-    messageStatuses: MessageStatus[]
-}
-
-export function emptyBreakdown(): TokenBreakdown {
-    return {
-        system: 0,
-        user: 0,
-        assistant: 0,
-        tools: 0,
-        toolCount: 0,
-        toolsInContextCount: 0,
-        prunedTokens: 0,
-        prunedToolCount: 0,
-        prunedMessageCount: 0,
-        total: 0,
-        messageCount: 0,
-    }
-}
-
-export function analyzeTokens(state: SessionState, messages: WithParts[]): TokenAnalysis {
-    const breakdown = emptyBreakdown()
-    const messageStatuses: MessageStatus[] = []
-    breakdown.prunedTokens = state.stats.totalPruneTokens
-
-    let firstAssistant: AssistantMessage | undefined
-    for (const msg of messages) {
-        if (msg.info.role !== "assistant") continue
-        const assistantInfo = msg.info as AssistantMessage
-        if (
-            assistantInfo.tokens?.input > 0 ||
-            assistantInfo.tokens?.cache?.read > 0 ||
-            assistantInfo.tokens?.cache?.write > 0
-        ) {
-            firstAssistant = assistantInfo
-            break
-        }
-    }
-
-    let lastAssistant: AssistantMessage | undefined
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i]
-        if (msg.info.role !== "assistant") continue
-        const assistantInfo = msg.info as AssistantMessage
-        if (assistantInfo.tokens?.output > 0) {
-            lastAssistant = assistantInfo
-            break
-        }
-    }
-
-    const apiInput = lastAssistant?.tokens?.input || 0
-    const apiOutput = lastAssistant?.tokens?.output || 0
-    const apiReasoning = lastAssistant?.tokens?.reasoning || 0
-    const apiCacheRead = lastAssistant?.tokens?.cache?.read || 0
-    const apiCacheWrite = lastAssistant?.tokens?.cache?.write || 0
-    breakdown.total = apiInput + apiOutput + apiReasoning + apiCacheRead + apiCacheWrite
-
-    const userTextParts: string[] = []
-    const toolInputParts: string[] = []
-    const toolOutputParts: string[] = []
-    const allToolIds = new Set<string>()
-    const activeToolIds = new Set<string>()
-    const prunedByMessageToolIds = new Set<string>()
-    const allMessageIds = new Set<string>()
-
-    let firstUserText = ""
-    let foundFirstUser = false
-
-    for (const msg of messages) {
-        const ignoredUser = msg.info.role === "user" && isIgnoredUserMessage(msg)
-        if (ignoredUser) continue
-
-        allMessageIds.add(msg.info.id)
-        const parts = Array.isArray(msg.parts) ? msg.parts : []
-        const compacted = isMessageCompacted(state, msg)
-        const pruneEntry = state.prune.messages.byMessageId.get(msg.info.id)
-        const messagePruned = !!pruneEntry && pruneEntry.activeBlockIds.length > 0
-        const messageActive = !compacted && !messagePruned
-
-        breakdown.messageCount += 1
-        messageStatuses.push(messageActive ? "active" : "pruned")
-
-        for (const part of parts) {
-            if (part.type === "tool") {
-                const toolPart = part as ToolPart
-                if (toolPart.callID) {
-                    allToolIds.add(toolPart.callID)
-                    if (!compacted) activeToolIds.add(toolPart.callID)
-                    if (messagePruned) prunedByMessageToolIds.add(toolPart.callID)
-                }
-
-                const toolPruned = toolPart.callID && state.prune.tools.has(toolPart.callID)
-                if (!compacted && !toolPruned) {
-                    if (toolPart.state?.input) {
-                        const inputText =
-                            typeof toolPart.state.input === "string"
-                                ? toolPart.state.input
-                                : JSON.stringify(toolPart.state.input)
-                        toolInputParts.push(inputText)
-                    }
-                    const outputText = extractCompletedToolOutput(toolPart)
-                    if (outputText !== undefined) {
-                        toolOutputParts.push(outputText)
-                    }
-                }
-                continue
-            }
-
-            if (part.type === "text" && msg.info.role === "user" && !compacted) {
-                const textPart = part as TextPart
-                const text = textPart.text || ""
-                userTextParts.push(text)
-                if (!foundFirstUser) firstUserText += text
-            }
-        }
-
-        if (msg.info.role === "user" && !foundFirstUser) {
-            foundFirstUser = true
-        }
-    }
-
-    const prunedByToolIds = new Set<string>()
-    for (const toolID of allToolIds) {
-        if (state.prune.tools.has(toolID)) prunedByToolIds.add(toolID)
-    }
-
-    const prunedToolIds = new Set<string>([...prunedByToolIds, ...prunedByMessageToolIds])
-    breakdown.toolCount = allToolIds.size
-    breakdown.toolsInContextCount = [...activeToolIds].filter(
-        (id) => !prunedByToolIds.has(id),
-    ).length
-    breakdown.prunedToolCount = prunedToolIds.size
-
-    for (const [messageID, entry] of state.prune.messages.byMessageId) {
-        if (allMessageIds.has(messageID) && entry.activeBlockIds.length > 0) {
-            breakdown.prunedMessageCount += 1
-        }
-    }
-
-    const firstUserTokens = countTokens(firstUserText)
-    breakdown.user = countTokens(userTextParts.join("\n"))
-    const toolInputTokens = countTokens(toolInputParts.join("\n"))
-    const toolOutputTokens = countTokens(toolOutputParts.join("\n"))
-
-    if (firstAssistant) {
-        const firstInput =
-            (firstAssistant.tokens?.input || 0) +
-            (firstAssistant.tokens?.cache?.read || 0) +
-            (firstAssistant.tokens?.cache?.write || 0)
-        breakdown.system = Math.max(0, firstInput - firstUserTokens)
-    }
-
-    breakdown.tools = toolInputTokens + toolOutputTokens
-    breakdown.assistant = Math.max(
-        0,
-        breakdown.total - breakdown.system - breakdown.user - breakdown.tools,
-    )
-
-    return { breakdown, messageStatuses }
-}

package/lib/compress/index.ts

@@ -1,3 +0,0 @@
-export { ToolContext } from "./types"
-export { createCompressMessageTool } from "./message"
-export { createCompressRangeTool } from "./range"

package/lib/compress/message-utils.ts

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

@@ -1,137 +0,0 @@
-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)
-        },
-    })
-}