OpenCode

// internal/tui/tui.go

type startCompactSessionMsg struct{}

// ... 在 Update() 的 AgentEvent 分支中:

if payload.Done && payload.Type == agent.AgentEventTypeResponse &&
    a.selectedSession.ID != "" {

    model := a.app.CoderAgent.Model()
    contextWindow := model.ContextWindow
    tokens := a.selectedSession.CompletionTokens +
        a.selectedSession.PromptTokens
    if (tokens >= int64(float64(contextWindow)*0.95)) &&
        config.Get().AutoCompact {
        return a, util.CmdHandler(startCompactSessionMsg{})
    }
}

// internal/llm/agent/agent.go

func (a *agent) Summarize(ctx context.Context, sessionID string) error {
    summarizeCtx, cancel := context.WithCancel(ctx)
    a.activeRequests.Store(sessionID+"-summarize", cancel)

    go func() {
        defer cancel()
        msgs, err := a.messages.List(summarizeCtx, sessionID)
        if err != nil { return }

        summarizePrompt := "Provide a detailed but concise summary " +
            "of our conversation above. Focus on information " +
            "that would be helpful for continuing the conversation..."
        promptMsg := message.Message{
            Role:  message.User,
            Parts: []message.ContentPart{
                message.TextContent{Text: summarizePrompt},
            },
        }
        msgsWithPrompt := append(msgs, promptMsg)

        response, err := a.summarizeProvider.SendMessages(
            summarizeCtx, msgsWithPrompt, make([]tools.BaseTool, 0),
        )

        summary := strings.TrimSpace(response.Content)
        // 写回 session，设置截断点
        msg, _ := a.messages.Create(summarizeCtx, oldSession.ID,
            message.CreateMessageParams{
                Role:  message.Assistant,
                Parts: []message.ContentPart{
                    message.TextContent{Text: summary},
                },
            })
        oldSession.SummaryMessageID = msg.ID
    }()
    return nil
}

// dcp-src/index.ts

const server: Plugin = (async (ctx) => {
    const config = getConfig(ctx)
    if (!config.enabled) { return {} }

    const state = createSessionState()
    const logger = new Logger(config.debug)

    return {
        "experimental.chat.system.transform":
            createSystemPromptHandler(state, logger, config, prompts),
        "experimental.chat.messages.transform":
            createChatMessageTransformHandler(
                ctx.client, state, logger, config, prompts,
                hostPermissions,
            ) as any,
        "command.execute.before":
            createCommandExecuteHandler(
                ctx.client, state, logger, config,
                ctx.directory, hostPermissions,
            ),
        event: createEventHandler(state, logger),
        tool: {
            ...(config.compress.permission !== "deny" && {
                compress: config.compress.mode === "message"
                    ? createCompressMessageTool(compressToolContext)
                    : createCompressRangeTool(compressToolContext),
            }),
        },
    }
}) satisfies Plugin

// dcp-src/lib/strategies/deduplication.ts

export const deduplicate = (
    state: SessionState, logger: Logger,
    config: PluginConfig, messages: WithParts[],
): void => {
    const allToolIds = state.toolIdList
    const unprunedIds = allToolIds.filter(
        (id) => !state.prune.tools.has(id),
    )

    const signatureMap = new Map<string, string[]>()
    for (const id of unprunedIds) {
        const metadata = state.toolParameters.get(id)
        if (!metadata) continue
        if (isToolNameProtected(metadata.tool, protectedTools))
            continue
        const signature = createToolSignature(
            metadata.tool, metadata.parameters,
        )
        signatureMap.get(signature)?.push(id)
            ?? signatureMap.set(signature, [id])
    }

    const newPruneIds: string[] = []
    for (const [, ids] of signatureMap.entries()) {
        if (ids.length > 1) {
            const idsToRemove = ids.slice(0, -1)
            newPruneIds.push(...idsToRemove)
        }
    }

    for (const id of newPruneIds) {
        const entry = state.toolParameters.get(id)
        state.prune.tools.set(id, entry?.tokenCount ?? 0)
    }
}

function createToolSignature(tool: string, params?: any): string {
    if (!params) return tool
    const normalized = normalizeParameters(params)
    const sorted = sortObjectKeys(normalized)
    return `${tool}::${JSON.stringify(sorted)}`
}

// dcp-src/lib/messages/prune.ts

const PRUNED_TOOL_OUTPUT_REPLACEMENT =
    "[Output removed to save context - " +
    "information superseded or no longer needed]"

export const prune = (
    state: SessionState, logger: Logger,
    config: PluginConfig, messages: WithParts[],
): void => {
    filterCompressedRanges(state, logger, config, messages)
    pruneToolOutputs(state, logger, messages)
    pruneToolInputs(state, logger, messages)
    pruneToolErrors(state, logger, messages)
}

const pruneToolOutputs = (
    state: SessionState, logger: Logger,
    messages: WithParts[],
): void => {
    for (const msg of messages) {
        const parts = Array.isArray(msg.parts) ? msg.parts : []
        for (const part of parts) {
            if (part.type !== "tool") continue
            if (!state.prune.tools.has(part.callID)) continue
            if (part.state.status !== "completed") continue

            part.state.output = PRUNED_TOOL_OUTPUT_REPLACEMENT
        }
    }
}