@tarquinen/opencode-dcp 3.1.12 → 3.1.14

package/lib/message-ids.ts

@@ -0,0 +1,172 @@
+import type { SessionState, WithParts } from "./state"
+import { isIgnoredUserMessage } from "./messages/query"
+
+const MESSAGE_REF_REGEX = /^m(\d{4})$/
+const BLOCK_REF_REGEX = /^b([1-9]\d*)$/
+const MESSAGE_ID_TAG_NAME = "dcp-message-id"
+
+const MESSAGE_REF_WIDTH = 4
+const MESSAGE_REF_MIN_INDEX = 1
+export const MESSAGE_REF_MAX_INDEX = 9999
+
+export type ParsedBoundaryId =
+    | {
+          kind: "message"
+          ref: string
+          index: number
+      }
+    | {
+          kind: "compressed-block"
+          ref: string
+          blockId: number
+      }
+
+export function formatMessageRef(index: number): string {
+    if (
+        !Number.isInteger(index) ||
+        index < MESSAGE_REF_MIN_INDEX ||
+        index > MESSAGE_REF_MAX_INDEX
+    ) {
+        throw new Error(
+            `Message ID index out of bounds: ${index}. Supported range is 0-${MESSAGE_REF_MAX_INDEX}.`,
+        )
+    }
+    return `m${index.toString().padStart(MESSAGE_REF_WIDTH, "0")}`
+}
+
+export function formatBlockRef(blockId: number): string {
+    if (!Number.isInteger(blockId) || blockId < 1) {
+        throw new Error(`Invalid block ID: ${blockId}`)
+    }
+    return `b${blockId}`
+}
+
+export function parseMessageRef(ref: string): number | null {
+    const normalized = ref.trim().toLowerCase()
+    const match = normalized.match(MESSAGE_REF_REGEX)
+    if (!match) {
+        return null
+    }
+    const index = Number.parseInt(match[1], 10)
+    if (!Number.isInteger(index)) {
+        return null
+    }
+    if (index < MESSAGE_REF_MIN_INDEX || index > MESSAGE_REF_MAX_INDEX) {
+        return null
+    }
+    return index
+}
+
+export function parseBlockRef(ref: string): number | null {
+    const normalized = ref.trim().toLowerCase()
+    const match = normalized.match(BLOCK_REF_REGEX)
+    if (!match) {
+        return null
+    }
+    const id = Number.parseInt(match[1], 10)
+    return Number.isInteger(id) ? id : null
+}
+
+export function parseBoundaryId(id: string): ParsedBoundaryId | null {
+    const normalized = id.trim().toLowerCase()
+    const messageIndex = parseMessageRef(normalized)
+    if (messageIndex !== null) {
+        return {
+            kind: "message",
+            ref: formatMessageRef(messageIndex),
+            index: messageIndex,
+        }
+    }
+
+    const blockId = parseBlockRef(normalized)
+    if (blockId !== null) {
+        return {
+            kind: "compressed-block",
+            ref: formatBlockRef(blockId),
+            blockId,
+        }
+    }
+
+    return null
+}
+
+function escapeXmlAttribute(value: string): string {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/"/g, "&quot;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+}
+
+export function formatMessageIdTag(
+    ref: string,
+    attributes?: Record<string, string | undefined>,
+): string {
+    const serializedAttributes = Object.entries(attributes || {})
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, value]) => {
+            if (name.trim().length === 0 || typeof value !== "string" || value.length === 0) {
+                return ""
+            }
+
+            return ` ${name}="${escapeXmlAttribute(value)}"`
+        })
+        .join("")
+
+    return `\n<${MESSAGE_ID_TAG_NAME}${serializedAttributes}>${ref}</${MESSAGE_ID_TAG_NAME}>`
+}
+
+export function assignMessageRefs(state: SessionState, messages: WithParts[]): number {
+    let assigned = 0
+    let skippedSubAgentPrompt = false
+
+    for (const message of messages) {
+        if (isIgnoredUserMessage(message)) {
+            continue
+        }
+
+        if (state.isSubAgent && !skippedSubAgentPrompt && message.info.role === "user") {
+            skippedSubAgentPrompt = true
+            continue
+        }
+
+        const rawMessageId = message.info.id
+        if (typeof rawMessageId !== "string" || rawMessageId.length === 0) {
+            continue
+        }
+
+        const existingRef = state.messageIds.byRawId.get(rawMessageId)
+        if (existingRef) {
+            if (state.messageIds.byRef.get(existingRef) !== rawMessageId) {
+                state.messageIds.byRef.set(existingRef, rawMessageId)
+            }
+            continue
+        }
+
+        const ref = allocateNextMessageRef(state)
+        state.messageIds.byRawId.set(rawMessageId, ref)
+        state.messageIds.byRef.set(ref, rawMessageId)
+        assigned++
+    }
+
+    return assigned
+}
+
+function allocateNextMessageRef(state: SessionState): string {
+    let candidate = Number.isInteger(state.messageIds.nextRef)
+        ? Math.max(MESSAGE_REF_MIN_INDEX, state.messageIds.nextRef)
+        : MESSAGE_REF_MIN_INDEX
+
+    while (candidate <= MESSAGE_REF_MAX_INDEX) {
+        const ref = formatMessageRef(candidate)
+        if (!state.messageIds.byRef.has(ref)) {
+            state.messageIds.nextRef = candidate + 1
+            return ref
+        }
+        candidate++
+    }
+
+    throw new Error(
+        `Message ID alias capacity exceeded. Cannot allocate more than ${formatMessageRef(MESSAGE_REF_MAX_INDEX)} aliases in this session.`,
+    )
+}

package/lib/messages/index.ts

@@ -0,0 +1,8 @@
+export { prune } from "./prune"
+export { syncCompressionBlocks } from "./sync"
+export { injectCompressNudges } from "./inject/inject"
+export { injectMessageIds } from "./inject/inject"
+export { injectExtendedSubAgentResults } from "./inject/subagent-results"
+export { stripStaleMetadata } from "./reasoning-strip"
+export { buildPriorityMap } from "./priority"
+export { buildToolIdList, stripHallucinations, stripHallucinationsFromString } from "./utils"

package/lib/messages/inject/inject.ts

@@ -0,0 +1,215 @@
+import type { SessionState, WithParts } from "../../state"
+import type { Logger } from "../../logger"
+import type { PluginConfig } from "../../config"
+import type { RuntimePrompts } from "../../prompts/store"
+import { formatMessageIdTag } from "../../message-ids"
+import type { CompressionPriorityMap } from "../priority"
+import { compressPermission } from "../../compress-permission"
+import {
+    getLastUserMessage,
+    isIgnoredUserMessage,
+    isProtectedUserMessage,
+    messageHasCompress,
+} from "../query"
+import { saveSessionState } from "../../state/persistence"
+import {
+    appendToTextPart,
+    appendToLastTextPart,
+    appendToAllToolParts,
+    createSyntheticTextPart,
+    hasContent,
+} from "../utils"
+import {
+    addAnchor,
+    applyAnchoredNudges,
+    countMessagesAfterIndex,
+    findLastNonIgnoredMessage,
+    getIterationNudgeThreshold,
+    getNudgeFrequency,
+    getModelInfo,
+    isContextOverLimits,
+} from "./utils"
+
+export const injectCompressNudges = (
+    state: SessionState,
+    config: PluginConfig,
+    logger: Logger,
+    messages: WithParts[],
+    prompts: RuntimePrompts,
+    compressionPriorities?: CompressionPriorityMap,
+): void => {
+    if (compressPermission(state, config) === "deny") {
+        return
+    }
+
+    if (state.manualMode) {
+        return
+    }
+
+    const lastMessage = findLastNonIgnoredMessage(messages)
+    const lastAssistantMessage = messages.findLast((message) => message.info.role === "assistant")
+
+    if (lastAssistantMessage && messageHasCompress(lastAssistantMessage)) {
+        state.nudges.contextLimitAnchors.clear()
+        state.nudges.turnNudgeAnchors.clear()
+        state.nudges.iterationNudgeAnchors.clear()
+        void saveSessionState(state, logger)
+        return
+    }
+
+    const { providerId, modelId } = getModelInfo(messages)
+    let anchorsChanged = false
+
+    const { overMaxLimit, overMinLimit } = isContextOverLimits(
+        config,
+        state,
+        providerId,
+        modelId,
+        messages,
+    )
+
+    if (!overMinLimit) {
+        const hadTurnAnchors = state.nudges.turnNudgeAnchors.size > 0
+        const hadIterationAnchors = state.nudges.iterationNudgeAnchors.size > 0
+
+        if (hadTurnAnchors || hadIterationAnchors) {
+            state.nudges.turnNudgeAnchors.clear()
+            state.nudges.iterationNudgeAnchors.clear()
+            anchorsChanged = true
+        }
+    }
+
+    if (overMaxLimit) {
+        if (lastMessage) {
+            const interval = getNudgeFrequency(config)
+            const added = addAnchor(
+                state.nudges.contextLimitAnchors,
+                lastMessage.message.info.id,
+                lastMessage.index,
+                messages,
+                interval,
+            )
+            if (added) {
+                anchorsChanged = true
+            }
+        }
+    } else if (overMinLimit) {
+        const isLastMessageUser = lastMessage?.message.info.role === "user"
+
+        if (isLastMessageUser && lastAssistantMessage) {
+            const previousSize = state.nudges.turnNudgeAnchors.size
+            state.nudges.turnNudgeAnchors.add(lastMessage.message.info.id)
+            state.nudges.turnNudgeAnchors.add(lastAssistantMessage.info.id)
+            if (state.nudges.turnNudgeAnchors.size !== previousSize) {
+                anchorsChanged = true
+            }
+        }
+
+        const lastUserMessage = getLastUserMessage(messages)
+        if (lastUserMessage && lastMessage) {
+            const lastUserMessageIndex = messages.findIndex(
+                (message) => message.info.id === lastUserMessage.info.id,
+            )
+            if (lastUserMessageIndex >= 0) {
+                const messagesSinceUser = countMessagesAfterIndex(messages, lastUserMessageIndex)
+                const iterationThreshold = getIterationNudgeThreshold(config)
+
+                if (
+                    lastMessage.index > lastUserMessageIndex &&
+                    messagesSinceUser >= iterationThreshold
+                ) {
+                    const interval = getNudgeFrequency(config)
+                    const added = addAnchor(
+                        state.nudges.iterationNudgeAnchors,
+                        lastMessage.message.info.id,
+                        lastMessage.index,
+                        messages,
+                        interval,
+                    )
+
+                    if (added) {
+                        anchorsChanged = true
+                    }
+                }
+            }
+        }
+    }
+
+    applyAnchoredNudges(state, config, messages, prompts, compressionPriorities)
+
+    if (anchorsChanged) {
+        void saveSessionState(state, logger)
+    }
+}
+
+export const injectMessageIds = (
+    state: SessionState,
+    config: PluginConfig,
+    messages: WithParts[],
+    compressionPriorities?: CompressionPriorityMap,
+): void => {
+    if (compressPermission(state, config) === "deny") {
+        return
+    }
+
+    for (const message of messages) {
+        if (isIgnoredUserMessage(message)) {
+            continue
+        }
+
+        const messageRef = state.messageIds.byRawId.get(message.info.id)
+        if (!messageRef) {
+            continue
+        }
+
+        const isBlockedMessage = isProtectedUserMessage(config, message)
+        const priority =
+            config.compress.mode === "message" && !isBlockedMessage
+                ? compressionPriorities?.get(message.info.id)?.priority
+                : undefined
+        const tag = formatMessageIdTag(
+            isBlockedMessage ? "BLOCKED" : messageRef,
+            priority ? { priority } : undefined,
+        )
+
+        if (message.info.role === "user") {
+            let injected = false
+            for (const part of message.parts) {
+                if (part.type === "text") {
+                    injected = appendToTextPart(part, tag) || injected
+                }
+            }
+
+            if (injected) {
+                continue
+            }
+
+            message.parts.push(createSyntheticTextPart(message, tag))
+            continue
+        }
+
+        if (message.info.role !== "assistant") {
+            continue
+        }
+
+        if (!hasContent(message)) {
+            continue
+        }
+
+        if (appendToAllToolParts(message, tag)) {
+            continue
+        }
+
+        if (appendToLastTextPart(message, tag)) {
+            continue
+        }
+
+        const syntheticPart = createSyntheticTextPart(message, tag)
+        const firstToolIndex = message.parts.findIndex((p) => p.type === "tool")
+        if (firstToolIndex === -1) {
+            message.parts.push(syntheticPart)
+        } else {
+            message.parts.splice(firstToolIndex, 0, syntheticPart)
+        }
+    }
+}

package/lib/messages/inject/subagent-results.ts

@@ -0,0 +1,82 @@
+import type { Logger } from "../../logger"
+import type { SessionState, WithParts } from "../../state"
+import { filterMessages } from "../shape"
+import {
+    buildSubagentResultText,
+    getSubAgentId,
+    mergeSubagentResult,
+} from "../../subagents/subagent-results"
+import { stripHallucinationsFromString } from "../utils"
+
+async function fetchSubAgentMessages(client: any, sessionId: string): Promise<WithParts[]> {
+    const response = await client.session.messages({
+        path: { id: sessionId },
+    })
+
+    return filterMessages(response?.data || response)
+}
+
+export const injectExtendedSubAgentResults = async (
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    messages: WithParts[],
+    allowSubAgents: boolean,
+): Promise<void> => {
+    if (!allowSubAgents) {
+        return
+    }
+
+    for (const message of messages) {
+        const parts = Array.isArray(message.parts) ? message.parts : []
+
+        for (const part of parts) {
+            if (part.type !== "tool" || part.tool !== "task" || !part.callID) {
+                continue
+            }
+            if (state.prune.tools.has(part.callID)) {
+                continue
+            }
+            if (part.state?.status !== "completed" || typeof part.state.output !== "string") {
+                continue
+            }
+
+            const cachedResult = state.subAgentResultCache.get(part.callID)
+            if (cachedResult !== undefined) {
+                if (cachedResult) {
+                    part.state.output = stripHallucinationsFromString(
+                        mergeSubagentResult(part.state.output, cachedResult),
+                    )
+                }
+                continue
+            }
+
+            const subAgentSessionId = getSubAgentId(part)
+            if (!subAgentSessionId) {
+                continue
+            }
+
+            let subAgentMessages: WithParts[] = []
+            try {
+                subAgentMessages = await fetchSubAgentMessages(client, subAgentSessionId)
+            } catch (error) {
+                logger.warn("Failed to fetch subagent session for output expansion", {
+                    subAgentSessionId,
+                    callID: part.callID,
+                    error: error instanceof Error ? error.message : String(error),
+                })
+                continue
+            }
+
+            const subAgentResultText = buildSubagentResultText(subAgentMessages)
+            if (!subAgentResultText) {
+                continue
+            }
+
+            state.subAgentResultCache.set(part.callID, subAgentResultText)
+            part.state.output = stripHallucinationsFromString(
+                mergeSubagentResult(part.state.output, subAgentResultText),
+            )
+        }
+    }
+}