diff --git a/index.ts b/index.ts index 1046a76..691f5c3 100644 --- a/index.ts +++ b/index.ts @@ -50,13 +50,17 @@ const plugin: Plugin = (async (ctx) => { const discardEnabled = config.tools.discard.enabled const extractEnabled = config.tools.extract.enabled + // Use user-role prompts for reasoning models (second person), + // assistant-role prompts for non-reasoning models (first person) + const roleDir = state.isReasoningModel ? "user" : "assistant" + let promptName: string if (discardEnabled && extractEnabled) { - promptName = "system/system-prompt-both" + promptName = `${roleDir}/system/system-prompt-both` } else if (discardEnabled) { - promptName = "system/system-prompt-discard" + promptName = `${roleDir}/system/system-prompt-discard` } else if (extractEnabled) { - promptName = "system/system-prompt-extract" + promptName = `${roleDir}/system/system-prompt-extract` } else { return } diff --git a/lib/messages/prune.ts b/lib/messages/prune.ts index bdca0c1..8baefed 100644 --- a/lib/messages/prune.ts +++ b/lib/messages/prune.ts @@ -2,34 +2,45 @@ import type { SessionState, WithParts } from "../state" import type { Logger } from "../logger" import type { PluginConfig } from "../config" import { loadPrompt } from "../prompt" -import { extractParameterKey, buildToolIdList } from "./utils" +import { + extractParameterKey, + buildToolIdList, + createSyntheticUserMessage, + createSyntheticAssistantMessage, +} from "./utils" import { getLastAssistantMessage, getLastUserMessage, isMessageCompacted } from "../shared-utils" -import { AssistantMessage, UserMessage } from "@opencode-ai/sdk" const PRUNED_TOOL_INPUT_REPLACEMENT = "[content removed to save context, this is not what was written to the file, but a placeholder]" const PRUNED_TOOL_OUTPUT_REPLACEMENT = "[Output removed to save context - information superseded or no longer needed]" -const getNudgeString = (config: PluginConfig): string => { + +const getNudgeString = (config: PluginConfig, isReasoningModel: boolean): string => { const discardEnabled = config.tools.discard.enabled const extractEnabled = config.tools.extract.enabled + const roleDir = isReasoningModel ? "user" : "assistant" if (discardEnabled && extractEnabled) { - return loadPrompt("nudge/nudge-both") + return loadPrompt(`${roleDir}/nudge/nudge-both`) } else if (discardEnabled) { - return loadPrompt("nudge/nudge-discard") + return loadPrompt(`${roleDir}/nudge/nudge-discard`) } else if (extractEnabled) { - return loadPrompt("nudge/nudge-extract") + return loadPrompt(`${roleDir}/nudge/nudge-extract`) } return "" } -const wrapPrunableTools = (content: string): string => ` +const wrapPrunableToolsUser = (content: string): string => ` +The following tools have been invoked and are available for pruning. This list does not mandate immediate action. Consider your current goals and the resources you need before discarding valuable tool inputs or outputs. Consolidate your prunes for efficiency; it is rarely worth pruning a single tiny tool output. Keep the context free of noise. +${content} +` + +const wrapPrunableToolsAssistant = (content: string): string => ` I have the following tool outputs available for pruning. I should consider my current goals and the resources I need before discarding valuable inputs or outputs. I should consolidate prunes for efficiency; it is rarely worth pruning a single tiny tool output. ${content} ` -const getCooldownMessage = (config: PluginConfig): string => { +const getCooldownMessage = (config: PluginConfig, isReasoningModel: boolean): string => { const discardEnabled = config.tools.discard.enabled const extractEnabled = config.tools.extract.enabled @@ -42,16 +53,12 @@ const getCooldownMessage = (config: PluginConfig): string => { toolName = "extract tool" } - return ` -I just performed context management. I will not use the ${toolName} again until after my next tool use, when a fresh list will be available. -` -} + const message = isReasoningModel + ? `Context management was just performed. Do not use the ${toolName} again. A fresh list will be available after your next tool use.` + : `I just performed context management. I will not use the ${toolName} again until after my next tool use, when a fresh list will be available.` -const SYNTHETIC_MESSAGE_ID = "msg_01234567890123456789012345" -const SYNTHETIC_PART_ID = "prt_01234567890123456789012345" -const SYNTHETIC_USER_MESSAGE_ID = "msg_01234567890123456789012346" -const SYNTHETIC_USER_PART_ID = "prt_01234567890123456789012346" -const REASONING_MODEL_USER_MESSAGE_CONTENT = "[internal: context sync - no response needed]" + return `\n${message}\n` +} const buildPrunableToolsList = ( state: SessionState, @@ -92,7 +99,8 @@ const buildPrunableToolsList = ( return "" } - return wrapPrunableTools(lines.join("\n")) + const wrapFn = state.isReasoningModel ? wrapPrunableToolsUser : wrapPrunableToolsAssistant + return wrapFn(lines.join("\n")) } export const insertPruneToolContext = ( @@ -105,16 +113,14 @@ export const insertPruneToolContext = ( return } - const lastAssistantMessage = getLastAssistantMessage(messages) - if (!lastAssistantMessage) { - return - } + // For reasoning models, inject into user role; for non-reasoning, inject into assistant role + const isReasoningModel = state.isReasoningModel let prunableToolsContent: string if (state.lastToolPrune) { logger.debug("Last tool was prune - injecting cooldown message") - prunableToolsContent = getCooldownMessage(config) + prunableToolsContent = getCooldownMessage(config, isReasoningModel) } else { const prunableToolsList = buildPrunableToolsList(state, config, logger, messages) if (!prunableToolsList) { @@ -129,69 +135,24 @@ export const insertPruneToolContext = ( state.nudgeCounter >= config.tools.settings.nudgeFrequency ) { logger.info("Inserting prune nudge message") - nudgeString = "\n" + getNudgeString(config) + nudgeString = "\n" + getNudgeString(config, isReasoningModel) } prunableToolsContent = prunableToolsList + nudgeString } - const assistantInfo = lastAssistantMessage.info as AssistantMessage - const assistantMessage: WithParts = { - info: { - id: SYNTHETIC_MESSAGE_ID, - sessionID: assistantInfo.sessionID, - role: "assistant", - parentID: assistantInfo.parentID, - modelID: assistantInfo.modelID, - providerID: assistantInfo.providerID, - time: { created: Date.now() }, - tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, - cost: 0, - path: assistantInfo.path, - mode: assistantInfo.mode, - }, - parts: [ - { - id: SYNTHETIC_PART_ID, - sessionID: assistantInfo.sessionID, - messageID: SYNTHETIC_MESSAGE_ID, - type: "text", - text: prunableToolsContent, - }, - ], - } - - messages.push(assistantMessage) - - // For reasoning models, append a synthetic user message to close the assistant turn. - if (state.isReasoningModel) { - const lastRealUserMessage = getLastUserMessage(messages) - const userMessageInfo = lastRealUserMessage?.info as UserMessage | undefined - - const userMessage: WithParts = { - info: { - id: SYNTHETIC_USER_MESSAGE_ID, - sessionID: assistantInfo.sessionID, - role: "user", - time: { created: Date.now() + 1 }, - agent: userMessageInfo?.agent ?? "code", - model: userMessageInfo?.model ?? { - providerID: assistantInfo.providerID, - modelID: assistantInfo.modelID, - }, - } as UserMessage, - parts: [ - { - id: SYNTHETIC_USER_PART_ID, - sessionID: assistantInfo.sessionID, - messageID: SYNTHETIC_USER_MESSAGE_ID, - type: "text", - text: REASONING_MODEL_USER_MESSAGE_CONTENT, - }, - ], + if (isReasoningModel) { + const lastUserMessage = getLastUserMessage(messages) + if (!lastUserMessage) { + return + } + messages.push(createSyntheticUserMessage(lastUserMessage, prunableToolsContent)) + } else { + const lastAssistantMessage = getLastAssistantMessage(messages) + if (!lastAssistantMessage) { + return } - messages.push(userMessage) - logger.debug("Appended synthetic user message for reasoning model") + messages.push(createSyntheticAssistantMessage(lastAssistantMessage, prunableToolsContent)) } } @@ -218,7 +179,6 @@ const pruneToolOutputs = (state: SessionState, logger: Logger, messages: WithPar if (!state.prune.toolIds.includes(part.callID)) { continue } - // Skip write and edit tools - their inputs are pruned instead if (part.tool === "write" || part.tool === "edit") { continue } @@ -238,16 +198,13 @@ const pruneToolInputs = (state: SessionState, logger: Logger, messages: WithPart if (!state.prune.toolIds.includes(part.callID)) { continue } - // Only prune inputs for write and edit tools if (part.tool !== "write" && part.tool !== "edit") { continue } - // Don't prune yet if tool is still pending or running if (part.state.status === "pending" || part.state.status === "running") { continue } - // Write tool has content field, edit tool has oldString/newString fields if (part.tool === "write" && part.state.input?.content !== undefined) { part.state.input.content = PRUNED_TOOL_INPUT_REPLACEMENT } diff --git a/lib/messages/utils.ts b/lib/messages/utils.ts index cbf497d..ca01bc7 100644 --- a/lib/messages/utils.ts +++ b/lib/messages/utils.ts @@ -1,6 +1,67 @@ import { Logger } from "../logger" import { isMessageCompacted } from "../shared-utils" import type { SessionState, WithParts } from "../state" +import type { AssistantMessage, UserMessage } from "@opencode-ai/sdk" + +const SYNTHETIC_MESSAGE_ID = "msg_01234567890123456789012345" +const SYNTHETIC_PART_ID = "prt_01234567890123456789012345" + +export const createSyntheticUserMessage = (baseMessage: WithParts, content: string): WithParts => { + const userInfo = baseMessage.info as UserMessage + return { + info: { + id: SYNTHETIC_MESSAGE_ID, + sessionID: userInfo.sessionID, + role: "user", + time: { created: Date.now() }, + agent: userInfo.agent || "code", + model: { + providerID: userInfo.model.providerID, + modelID: userInfo.model.modelID, + }, + }, + parts: [ + { + id: SYNTHETIC_PART_ID, + sessionID: userInfo.sessionID, + messageID: SYNTHETIC_MESSAGE_ID, + type: "text", + text: content, + }, + ], + } +} + +export const createSyntheticAssistantMessage = ( + baseMessage: WithParts, + content: string, +): WithParts => { + const assistantInfo = baseMessage.info as AssistantMessage + return { + info: { + id: SYNTHETIC_MESSAGE_ID, + sessionID: assistantInfo.sessionID, + role: "assistant", + parentID: assistantInfo.parentID, + modelID: assistantInfo.modelID, + providerID: assistantInfo.providerID, + time: { created: Date.now() }, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + cost: 0, + path: assistantInfo.path, + mode: assistantInfo.mode, + }, + parts: [ + { + id: SYNTHETIC_PART_ID, + sessionID: assistantInfo.sessionID, + messageID: SYNTHETIC_MESSAGE_ID, + type: "text", + text: content, + }, + ], + } +} /** * Extracts a human-readable key from tool metadata for display purposes. @@ -9,6 +70,17 @@ export const extractParameterKey = (tool: string, parameters: any): string => { if (!parameters) return "" if (tool === "read" && parameters.filePath) { + const offset = parameters.offset + const limit = parameters.limit + if (offset !== undefined && limit !== undefined) { + return `${parameters.filePath} (lines ${offset}-${offset + limit})` + } + if (offset !== undefined) { + return `${parameters.filePath} (lines ${offset}+)` + } + if (limit !== undefined) { + return `${parameters.filePath} (lines 0-${limit})` + } return parameters.filePath } if (tool === "write" && parameters.filePath) { diff --git a/lib/prompts/nudge/nudge-both.txt b/lib/prompts/assistant/nudge/nudge-both.txt similarity index 100% rename from lib/prompts/nudge/nudge-both.txt rename to lib/prompts/assistant/nudge/nudge-both.txt diff --git a/lib/prompts/nudge/nudge-discard.txt b/lib/prompts/assistant/nudge/nudge-discard.txt similarity index 100% rename from lib/prompts/nudge/nudge-discard.txt rename to lib/prompts/assistant/nudge/nudge-discard.txt diff --git a/lib/prompts/nudge/nudge-extract.txt b/lib/prompts/assistant/nudge/nudge-extract.txt similarity index 100% rename from lib/prompts/nudge/nudge-extract.txt rename to lib/prompts/assistant/nudge/nudge-extract.txt diff --git a/lib/prompts/system/system-prompt-both.txt b/lib/prompts/assistant/system/system-prompt-both.txt similarity index 100% rename from lib/prompts/system/system-prompt-both.txt rename to lib/prompts/assistant/system/system-prompt-both.txt diff --git a/lib/prompts/system/system-prompt-discard.txt b/lib/prompts/assistant/system/system-prompt-discard.txt similarity index 100% rename from lib/prompts/system/system-prompt-discard.txt rename to lib/prompts/assistant/system/system-prompt-discard.txt diff --git a/lib/prompts/system/system-prompt-extract.txt b/lib/prompts/assistant/system/system-prompt-extract.txt similarity index 100% rename from lib/prompts/system/system-prompt-extract.txt rename to lib/prompts/assistant/system/system-prompt-extract.txt diff --git a/lib/prompts/user/nudge/nudge-both.txt b/lib/prompts/user/nudge/nudge-both.txt new file mode 100644 index 0000000..f9fa492 --- /dev/null +++ b/lib/prompts/user/nudge/nudge-both.txt @@ -0,0 +1,10 @@ + +**CRITICAL CONTEXT WARNING:** Your context window is filling with tool outputs. Strict adherence to context hygiene is required. + +**Immediate Actions Required:** +1. **Task Completion:** If a sub-task is complete, decide: use `discard` if no valuable context to preserve (default), or use `extract` if insights are worth keeping. +2. **Noise Removal:** If you read files or ran commands that yielded no value, use `discard` to remove them. +3. **Knowledge Preservation:** If you are holding valuable raw data you'll need to reference later, use `extract` to distill the insights and remove the raw entry. + +**Protocol:** You should prioritize this cleanup, but do not interrupt a critical atomic operation if one is in progress. Once the immediate step is done, you must perform context management. + diff --git a/lib/prompts/user/nudge/nudge-discard.txt b/lib/prompts/user/nudge/nudge-discard.txt new file mode 100644 index 0000000..1ccecf9 --- /dev/null +++ b/lib/prompts/user/nudge/nudge-discard.txt @@ -0,0 +1,9 @@ + +**CRITICAL CONTEXT WARNING:** Your context window is filling with tool outputs. Strict adherence to context hygiene is required. + +**Immediate Actions Required:** +1. **Task Completion:** If a sub-task is complete, use the `discard` tool to remove the tools used. +2. **Noise Removal:** If you read files or ran commands that yielded no value, use the `discard` tool to remove them. + +**Protocol:** You should prioritize this cleanup, but do not interrupt a critical atomic operation if one is in progress. Once the immediate step is done, you must discard unneeded tool outputs. + diff --git a/lib/prompts/user/nudge/nudge-extract.txt b/lib/prompts/user/nudge/nudge-extract.txt new file mode 100644 index 0000000..5bdb370 --- /dev/null +++ b/lib/prompts/user/nudge/nudge-extract.txt @@ -0,0 +1,9 @@ + +**CRITICAL CONTEXT WARNING:** Your context window is filling with tool outputs. Strict adherence to context hygiene is required. + +**Immediate Actions Required:** +1. **Task Completion:** If you have completed work, extract key findings from the tools used. Scale distillation depth to the value of the content. +2. **Knowledge Preservation:** If you are holding valuable raw data you'll need to reference later, use the `extract` tool with high-fidelity distillation to preserve the insights and remove the raw entry. + +**Protocol:** You should prioritize this cleanup, but do not interrupt a critical atomic operation if one is in progress. Once the immediate step is done, you must extract valuable findings from tool outputs. + diff --git a/lib/prompts/user/system/system-prompt-both.txt b/lib/prompts/user/system/system-prompt-both.txt new file mode 100644 index 0000000..f1e88aa --- /dev/null +++ b/lib/prompts/user/system/system-prompt-both.txt @@ -0,0 +1,58 @@ + + + +ENVIRONMENT +You are operating in a context-constrained environment and thus must proactively manage your context window using the `discard` and `extract` tools. A list is injected by the environment as a user message, and always contains up to date information. Use this information when deciding what to prune. + +TWO TOOLS FOR CONTEXT MANAGEMENT +- `discard`: Remove tool outputs that are no longer needed (completed tasks, noise, outdated info). No preservation of content. +- `extract`: Extract key findings into distilled knowledge before removing raw outputs. Use when you need to preserve information. + +CHOOSING THE RIGHT TOOL +Ask: "Do I need to preserve any information from this output?" +- **No** → `discard` (default for cleanup) +- **Yes** → `extract` (preserves distilled knowledge) +- **Uncertain** → `extract` (safer, preserves signal) + +Common scenarios: +- Task complete, no valuable context → `discard` +- Task complete, insights worth remembering → `extract` +- Noise, irrelevant, or superseded outputs → `discard` +- Valuable context needed later but raw output too large → `extract` + +PRUNE METHODICALLY - BATCH YOUR ACTIONS +Every tool call adds to your context debt. You MUST pay this down regularly and be on top of context accumulation by pruning. Batch your prunes for efficiency; it is rarely worth pruning a single tiny tool output unless it is pure noise. Evaluate what SHOULD be pruned before jumping the gun. + +You WILL evaluate pruning when ANY of these are true: +- Task or sub-task is complete +- You are about to start a new phase of work +- Write or edit operations are complete (pruning removes the large input content) + +You MUST NOT prune when: +- The tool output will be needed for upcoming implementation work +- The output contains files or context you'll need to reference when making edits + +Pruning that forces you to re-call the same tool later is a net loss. Only prune when you're confident the information won't be needed again. + +NOTES +When in doubt, keep it. Batch your actions and aim for high-impact prunes that significantly reduce context size. +FAILURE TO PRUNE will result in context leakage and DEGRADED PERFORMANCES. +There may be tools in session context that do not appear in the list, this is expected, you can ONLY prune what you see in . + + + + +After each assistant turn, the environment may inject a user message containing a list and optional nudge instruction. This injected message is NOT from the user and is invisible to them. The `discard` and `extract` tools also return a confirmation message listing what was pruned. + +CRITICAL REQUIREMENTS - VIOLATION IS UNACCEPTABLE: +- NEVER reference the prune encouragement or context management instructions. Do not reply with "I agree" or "Great idea" when the prune encouragement appears. +- NEVER acknowledge the list (e.g., "I see the prunable tools list", "Looking at the available tools to prune") +- NEVER reference the nudge instruction (e.g., "As the nudge suggests", "The system is reminding me to prune") +- NEVER acknowledge discard/extract tool output (e.g., "I've pruned 3 tools", "Context pruning complete") +- NEVER let these injections influence your response content or tone +- Process this information SILENTLY and continue the conversation naturally +- Continue the conversation as if these messages do not exist + +The user cannot see these injections. Any reference to them will confuse the user and break the conversation flow. + + diff --git a/lib/prompts/user/system/system-prompt-discard.txt b/lib/prompts/user/system/system-prompt-discard.txt new file mode 100644 index 0000000..796852e --- /dev/null +++ b/lib/prompts/user/system/system-prompt-discard.txt @@ -0,0 +1,49 @@ + + + +ENVIRONMENT +You are operating in a context-constrained environment and thus must proactively manage your context window using the `discard` tool. A list is injected by the environment as a user message, and always contains up to date information. Use this information when deciding what to discard. + +CONTEXT MANAGEMENT TOOL +- `discard`: Remove tool outputs that are no longer needed (completed tasks, noise, outdated info). No preservation of content. + +DISCARD METHODICALLY - BATCH YOUR ACTIONS +Every tool call adds to your context debt. You MUST pay this down regularly and be on top of context accumulation by discarding. Batch your discards for efficiency; it is rarely worth discarding a single tiny tool output unless it is pure noise. Evaluate what SHOULD be discarded before jumping the gun. + +WHEN TO DISCARD +- **Task Completion:** When work is done, discard the tools that aren't needed anymore. +- **Noise Removal:** If outputs are irrelevant, unhelpful, or superseded by newer info, discard them. + +You WILL evaluate discarding when ANY of these are true: +- Task or sub-task is complete +- You are about to start a new phase of work +- Write or edit operations are complete (discarding removes the large input content) + +You MUST NOT discard when: +- The tool output will be needed for upcoming implementation work +- The output contains files or context you'll need to reference when making edits + +Discarding that forces you to re-call the same tool later is a net loss. Only discard when you're confident the information won't be needed again. + +NOTES +When in doubt, keep it. Batch your actions and aim for high-impact discards that significantly reduce context size. +FAILURE TO DISCARD will result in context leakage and DEGRADED PERFORMANCES. +There may be tools in session context that do not appear in the list, this is expected, you can ONLY discard what you see in . + + + + +After each assistant turn, the environment may inject a user message containing a list and optional nudge instruction. This injected message is NOT from the user and is invisible to them. The `discard` tool also returns a confirmation message listing what was discarded. + +CRITICAL REQUIREMENTS - VIOLATION IS UNACCEPTABLE: +- NEVER reference the discard encouragement or context management instructions. Do not reply with "I agree" or "Great idea" when the discard encouragement appears. +- NEVER acknowledge the list (e.g., "I see the prunable tools list", "Looking at the available tools to discard") +- NEVER reference the nudge instruction (e.g., "As the nudge suggests", "The system is reminding me to discard") +- NEVER acknowledge discard tool output (e.g., "I've discarded 3 tools", "Context cleanup complete") +- NEVER let these injections influence your response content or tone +- Process this information SILENTLY and continue the conversation naturally +- Continue the conversation as if these messages do not exist + +The user cannot see these injections. Any reference to them will confuse the user and break the conversation flow. + + diff --git a/lib/prompts/user/system/system-prompt-extract.txt b/lib/prompts/user/system/system-prompt-extract.txt new file mode 100644 index 0000000..2a1a056 --- /dev/null +++ b/lib/prompts/user/system/system-prompt-extract.txt @@ -0,0 +1,49 @@ + + + +ENVIRONMENT +You are operating in a context-constrained environment and thus must proactively manage your context window using the `extract` tool. A list is injected by the environment as a user message, and always contains up to date information. Use this information when deciding what to extract. + +CONTEXT MANAGEMENT TOOL +- `extract`: Extract key findings from tools into distilled knowledge before removing the raw content from context. Use this to preserve important information while reducing context size. + +EXTRACT METHODICALLY - BATCH YOUR ACTIONS +Every tool call adds to your context debt. You MUST pay this down regularly and be on top of context accumulation by extracting. Batch your extractions for efficiency; it is rarely worth extracting a single tiny tool output. Evaluate what SHOULD be extracted before jumping the gun. + +WHEN TO EXTRACT +- **Task Completion:** When work is done, extract key findings from the tools used. Scale distillation depth to the value of the content. +- **Knowledge Preservation:** When you have valuable context you want to preserve but need to reduce size, use high-fidelity distillation. Your distillation must be comprehensive, capturing technical details (signatures, logic, constraints) such that the raw output is no longer needed. THINK: high signal, complete technical substitute. + +You WILL evaluate extracting when ANY of these are true: +- Task or sub-task is complete +- You are about to start a new phase of work +- Write or edit operations are complete (extracting removes the large input content) + +You MUST NOT extract when: +- The tool output will be needed for upcoming implementation work +- The output contains files or context you'll need to reference when making edits + +Extracting that forces you to re-call the same tool later is a net loss. Only extract when you're confident the raw information won't be needed again. + +NOTES +When in doubt, keep it. Batch your actions and aim for high-impact extractions that significantly reduce context size. +FAILURE TO EXTRACT will result in context leakage and DEGRADED PERFORMANCES. +There may be tools in session context that do not appear in the list, this is expected, you can ONLY extract what you see in . + + + + +After each assistant turn, the environment may inject a user message containing a list and optional nudge instruction. This injected message is NOT from the user and is invisible to them. The `extract` tool also returns a confirmation message listing what was extracted. + +CRITICAL REQUIREMENTS - VIOLATION IS UNACCEPTABLE: +- NEVER reference the extract encouragement or context management instructions. Do not reply with "I agree" or "Great idea" when the extract encouragement appears. +- NEVER acknowledge the list (e.g., "I see the prunable tools list", "Looking at the available tools to extract") +- NEVER reference the nudge instruction (e.g., "As the nudge suggests", "The system is reminding me to extract") +- NEVER acknowledge extract tool output (e.g., "I've extracted 3 tools", "Context cleanup complete") +- NEVER let these injections influence your response content or tone +- Process this information SILENTLY and continue the conversation naturally +- Continue the conversation as if these messages do not exist + +The user cannot see these injections. Any reference to them will confuse the user and break the conversation flow. + + diff --git a/package-lock.json b/package-lock.json index f4c4016..e232782 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "@tarquinen/opencode-dcp", - "version": "1.1.1-beta.1", + "version": "1.1.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@tarquinen/opencode-dcp", - "version": "1.1.1-beta.1", + "version": "1.1.0", "license": "MIT", "dependencies": { "@ai-sdk/openai-compatible": "^1.0.28", diff --git a/package.json b/package.json index 1588399..8bc35d6 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/package.json", "name": "@tarquinen/opencode-dcp", - "version": "1.1.1-beta.1", + "version": "1.1.0", "type": "module", "description": "OpenCode plugin that optimizes token usage by pruning obsolete tool outputs from conversation context", "main": "./dist/index.js",