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

package/lib/host-permissions.ts

@@ -0,0 +1,101 @@
+export type PermissionAction = "ask" | "allow" | "deny"
+
+export type PermissionValue = PermissionAction | Record<string, PermissionAction>
+
+export type PermissionConfig = Record<string, PermissionValue> | undefined
+
+export interface HostPermissionSnapshot {
+    global: PermissionConfig
+    agents: Record<string, PermissionConfig>
+}
+
+type PermissionRule = {
+    permission: string
+    pattern: string
+    action: PermissionAction
+}
+
+const findLastMatchingRule = (
+    rules: PermissionRule[],
+    predicate: (rule: PermissionRule) => boolean,
+): PermissionRule | undefined => {
+    for (let index = rules.length - 1; index >= 0; index -= 1) {
+        const rule = rules[index]
+        if (rule && predicate(rule)) {
+            return rule
+        }
+    }
+
+    return undefined
+}
+
+const wildcardMatch = (value: string, pattern: string): boolean => {
+    const normalizedValue = value.replaceAll("\\", "/")
+    let escaped = pattern
+        .replaceAll("\\", "/")
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".")
+
+    if (escaped.endsWith(" .*")) {
+        escaped = escaped.slice(0, -3) + "( .*)?"
+    }
+
+    const flags = process.platform === "win32" ? "si" : "s"
+    return new RegExp(`^${escaped}$`, flags).test(normalizedValue)
+}
+
+const getPermissionRules = (permissionConfigs: PermissionConfig[]): PermissionRule[] => {
+    const rules: PermissionRule[] = []
+    for (const permissionConfig of permissionConfigs) {
+        if (!permissionConfig) {
+            continue
+        }
+
+        for (const [permission, value] of Object.entries(permissionConfig)) {
+            if (value === "ask" || value === "allow" || value === "deny") {
+                rules.push({ permission, pattern: "*", action: value })
+                continue
+            }
+
+            for (const [pattern, action] of Object.entries(value)) {
+                if (action === "ask" || action === "allow" || action === "deny") {
+                    rules.push({ permission, pattern, action })
+                }
+            }
+        }
+    }
+    return rules
+}
+
+export const compressDisabledByOpencode = (...permissionConfigs: PermissionConfig[]): boolean => {
+    const match = findLastMatchingRule(getPermissionRules(permissionConfigs), (rule) =>
+        wildcardMatch("compress", rule.permission),
+    )
+
+    return match?.pattern === "*" && match.action === "deny"
+}
+
+export const resolveEffectiveCompressPermission = (
+    basePermission: PermissionAction,
+    hostPermissions: HostPermissionSnapshot,
+    agentName?: string,
+): PermissionAction => {
+    if (basePermission === "deny") {
+        return "deny"
+    }
+
+    return compressDisabledByOpencode(
+        hostPermissions.global,
+        agentName ? hostPermissions.agents[agentName] : undefined,
+    )
+        ? "deny"
+        : basePermission
+}
+
+export const hasExplicitToolPermission = (
+    permissionConfig: PermissionConfig,
+    tool: string,
+): boolean => {
+    return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool) : false
+}

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 {
+    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 },
+    })
+
+    const payload = (response?.data || response) as WithParts[]
+    return Array.isArray(payload) ? payload : []
+}
+
+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),
+            )
+        }
+    }
+}