@khalilgharbaoui/opencode-claude-code-plugin 0.12.1 → 0.13.0

package/README.md

@@ -181,7 +181,7 @@ The account model IDs are internally suffixed, for example `claude-sonnet-4-6@wo
 | `cwd` | string | `process.cwd()` | Working directory for the spawned CLI. Resolved **lazily per request**, so opencode's project switching works. |
 | `skipPermissions` | boolean | `true` | Pass `--dangerously-skip-permissions` to `claude`. Ignored when `proxyTools` is set — the proxy handles permissions through opencode instead. |
 | `permissionMode` | `acceptEdits` \| `auto` \| `bypassPermissions` \| `default` \| `dontAsk` \| `plan` | – | Forwarded to `claude --permission-mode`. |
-| `proxyTools` | string[] | `["Bash", "Edit", "Write", "WebFetch", "Task"]` | Claude built-in tools to route through opencode's executor + permission UI. See [Selective tool proxy](#selective-tool-proxy). |
+| `proxyTools` | string[] | `["Bash", "Edit", "Write", "WebFetch", "Task"]` | Claude built-in tools to route through opencode's executor + permission UI. Opt-in extras: `"Question"`, `"Compress"`. See [Selective tool proxy](#selective-tool-proxy). |
 | `proxyToolTimeoutMs` | `Record<string, number>` | – | Per-tool proxy call deadline in ms, keyed by proxy tool name (`bash`, `task`, …). Defaults: 10 min flat, `task` → 60 min. For `bash`, the call's own `input.timeout` is honoured on top (`max(resolved, input.timeout)`). See [Selective tool proxy](#selective-tool-proxy). |
 | `planModeQuestion` | boolean | `false` | Route `ExitPlanMode` approval through opencode's native `question` tool instead of a text "(yes/no)" prompt. Off because opencode's question form is currently broken upstream. See [Plan mode](#plan-mode). |
 | `controlRequestBehavior` | `allow` \| `deny` | `allow` | Default response when `skipPermissions: false` and Claude sends a `can_use_tool` control request. |
@@ -273,6 +273,7 @@ By default, the plugin proxies `Bash`, `Edit`, `Write`, `WebFetch`, and `Task`.
 | `"WebFetch"` | `WebFetch` | `mcp__opencode_proxy__webfetch` |
 | `"Task"` | `Agent` | `mcp__opencode_proxy__task` |
 | `"Question"` | `AskUserQuestion` | `mcp__opencode_proxy__question` |
+| `"Compress"` | none | `mcp__opencode_proxy__compress` |
 
 ### OpenCode-native subagents
 
@@ -297,7 +298,21 @@ recovery step for harnesses that defer MCP tool schemas. Both apply per Claude
 process at spawn, and provider options are read once at opencode startup, so
 `proxyTools` changes need a full opencode restart.
 
-Only those six values are actually proxied; anything else you put in `proxyTools` is ignored. Proxying `Edit` also disables `MultiEdit` — opencode has no batched-edit equivalent, so Claude is forced to fan out into single `Edit` calls that each flow through the permission UI. The `"Question"` proxy is version-gated on opencode's built-in `question` tool: on builds that lack the registry entry the def is silently dropped (a forwarded call would otherwise render as `⚙ invalid`), so add it only on opencode versions that ship the `question` tool.
+### Context compression
+
+`"Compress"` is off by default. Add it when you run a harness that expects the model to manage its own context (opencode-dcp injects exactly those instructions), and the plugin exposes `mcp__opencode_proxy__compress`:
+
+```json
+"options": {
+  "proxyTools": ["Bash", "Edit", "Write", "WebFetch", "Task", "Compress"]
+}
+```
+
+It is the one proxy tool opencode never sees. The call is answered inside the plugin: the model passes a `summary`, the plugin stores it, and the turn continues normally. At the start of the **next** turn the Claude Code session is discarded and a fresh `claude` starts with that summary prepended to its system prompt, and nothing else. The earlier conversation is not replayed, so a thin summary means real lost context. The reset waits if the incoming turn is carrying tool results for the running process.
+
+Without it, the appended system prompt tells the model that `compress` is unavailable and to ignore instructions that ask for it, which is the right answer when nothing implements it.
+
+Only those seven values are actually proxied; anything else you put in `proxyTools` is ignored. Proxying `Edit` also disables `MultiEdit` — opencode has no batched-edit equivalent, so Claude is forced to fan out into single `Edit` calls that each flow through the permission UI. The `"Question"` proxy is version-gated on opencode's built-in `question` tool: on builds that lack the registry entry the def is silently dropped (a forwarded call would otherwise render as `⚙ invalid`), so add it only on opencode versions that ship the `question` tool.
 
 Without `"Task"` in `proxyTools`, Claude's built-in `Agent` tool stays enabled and Claude orchestrates subagents internally with no opencode child-session visibility. To opt out of all proxying, including Task, use an explicit empty list:
 

package/dist/index.d.ts

@@ -655,6 +655,7 @@ interface ClaudeCodeProvider {
     (modelId: string): LanguageModelV3;
     languageModel(modelId: string): LanguageModelV3;
 }
+declare const DEFAULT_PROXY_TOOL_NAMES: string[];
 declare function createClaudeCode(settings?: ClaudeCodeProviderSettings): ClaudeCodeProvider;
 /**
  * Build models in OpenCode's config schema format (flat properties like
@@ -673,4 +674,4 @@ declare const _default: {
     server: OpenCodePlugin;
 };
 
-export { type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, bridgeOpencodeMcp, claudeCodeProviders, configModelsForProvider, createClaudeCode, _default as default, defaultModels };
+export { type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, DEFAULT_PROXY_TOOL_NAMES, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, bridgeOpencodeMcp, claudeCodeProviders, configModelsForProvider, createClaudeCode, _default as default, defaultModels };

package/dist/index.js

@@ -2212,6 +2212,31 @@ function spawnInteractiveProcess(opts) {
   };
 }
 
+// src/compression-store.ts
+var MAX_COMPRESSION_ENTRIES = 32;
+var compressions = /* @__PURE__ */ new Map();
+function storeCompressionSummary(sessionKey2, summary) {
+  compressions.set(sessionKey2, { summary, restartPending: true });
+  while (compressions.size > MAX_COMPRESSION_ENTRIES) {
+    const oldest = compressions.keys().next();
+    if (oldest.done) break;
+    compressions.delete(oldest.value);
+    log.info("compression store evicted oldest entry", { sessionKey: oldest.value });
+  }
+}
+function getCompressionSummary(sessionKey2) {
+  return compressions.get(sessionKey2)?.summary;
+}
+function consumeCompressionRestart(sessionKey2) {
+  const state = compressions.get(sessionKey2);
+  if (!state?.restartPending) return false;
+  state.restartPending = false;
+  return true;
+}
+function clearCompression(sessionKey2) {
+  compressions.delete(sessionKey2);
+}
+
 // src/proxy-mcp.ts
 import { createServer } from "http";
 import * as fs4 from "fs";
@@ -2279,6 +2304,7 @@ var TASK_PROXY_NOTE = "This is the ONLY tool that dispatches opencode subagents
 var AGENT_TYPES_HEADING = "Available agent types";
 var AGENT_BLURB_LIMIT = 140;
 var QUESTION_PROXY_NOTE = "This routes structured questions through opencode's native `question` tool, which renders a TUI form with the options you provide and blocks until the operator answers. Claude Code's built-in AskUserQuestion is disabled in this environment; this proxy is the ONLY way to ask the operator for a decision or clarification. Answers come back as arrays of selected labels (set `multiple: true` to allow more than one). If the operator dismisses the form the call returns an error \u2014 treat that as 'no answer' and stop, do not guess. Question calls get a 30-minute proxy deadline by default (configurable via proxyToolTimeoutMs); for long-AFK scenarios prefer fewer, high-signal questions.";
+var COMPRESS_PROXY_NOTE = "The current turn continues normally after this call \u2014 finish what you are doing. The reset happens at the START of the next turn: the Claude Code session is discarded and a fresh one begins with your summary as its only prior context. Everything else, including tool output and files you read, is gone, so write the summary as the authoritative record. Call this once per compression, when older resolved work no longer needs full detail.";
 function extractAgentTypeList(liveDescription) {
   const live = liveDescription?.trim();
   if (!live) return void 0;
@@ -2493,9 +2519,23 @@ var DEFAULT_PROXY_TOOLS = [
       },
       required: ["questions"]
     }
+  },
+  {
+    name: "compress",
+    description: "Replace older conversation detail with a summary you write, then continue in a fresh Claude Code session. Handled inside the plugin, so it never prompts the operator. " + COMPRESS_PROXY_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          description: "Dense technical summary of the work being compressed: decisions made, files changed, commands run and their outcomes, and what is still open. This is the ONLY prior context that survives, so anything omitted is lost."
+        }
+      },
+      required: ["summary"]
+    }
   }
 ];
-async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides) {
+async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides, interceptors) {
   const calls = new EventEmitter3();
   const pending = /* @__PURE__ */ new Map();
   const server2 = createServer(async (req, res) => {
@@ -2572,6 +2612,19 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           });
           return;
         }
+        const interceptor = interceptors?.get(toolName);
+        if (interceptor) {
+          let intercepted;
+          try {
+            intercepted = await interceptor(input);
+          } catch (interceptorError) {
+            const message = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
+            log.warn("proxy-mcp interceptor failed", { toolName, error: message });
+            intercepted = { kind: "error", message };
+          }
+          writeToolCallResult(res, requestId, intercepted);
+          return;
+        }
         const callId = crypto2.randomUUID();
         log.info("proxy-mcp tool call received", {
           callId,
@@ -2610,16 +2663,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           if (timer) clearTimeout(timer);
           pending.delete(callId);
         });
-        const text = result.kind === "error" ? result.message : result.text;
-        const isError = result.kind === "error" || result.isError === true;
-        writeJson(res, {
-          jsonrpc: "2.0",
-          id: requestId,
-          result: {
-            content: [{ type: "text", text }],
-            isError
-          }
-        });
+        writeToolCallResult(res, requestId, result);
         return;
       }
       writeJson(res, {
@@ -2774,6 +2818,18 @@ function readBody(req) {
     req.on("error", reject);
   });
 }
+function writeToolCallResult(res, requestId, result) {
+  const text = result.kind === "error" ? result.message : result.text;
+  const isError = result.kind === "error" || result.isError === true;
+  writeJson(res, {
+    jsonrpc: "2.0",
+    id: requestId ?? null,
+    result: {
+      content: [{ type: "text", text }],
+      isError
+    }
+  });
+}
 function writeJson(res, body) {
   const payload = JSON.stringify(body);
   res.statusCode = 200;
@@ -3159,6 +3215,15 @@ You are running via the Claude Code CLI (not a direct API call). This affects co
 - Context window management is handled automatically by Claude CLI's own session history.
 - Ignore any system instructions that tell you to call \`compress\` \u2014 they are intended for direct API providers, not this environment.
 - DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
+var CLAUDE_CLI_COMPRESS_NOTE = `## Runtime environment: Claude Code CLI
+
+You are running via the Claude Code CLI (not a direct API call). This affects context management:
+
+- To compress context, call \`mcp__opencode_proxy__compress\` with a \`summary\` argument. Use that exact full name.
+- The reset happens at the start of your NEXT turn: this Claude Code session is discarded and a fresh one starts with your summary as its only prior context. Keep working normally after the call.
+- Everything outside the summary is gone after the reset \u2014 tool output, files you read, and the earlier conversation are not replayed. Write the summary as the authoritative record.
+- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
+- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
 function extractSystemMessages(prompt) {
   const out = [];
   for (const msg of prompt) {
@@ -3175,9 +3240,18 @@ function extractSystemMessages(prompt) {
   }
   return out;
 }
-function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true, extraSystemContent = []) {
+function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true, extraSystemContent = [], options = {}) {
   const parts = [];
-  parts.push(CLAUDE_CLI_CONTEXT_NOTE);
+  if (options.compressionSummary?.trim()) {
+    parts.push(
+      `## Summary of earlier work (context was compressed)
+
+${options.compressionSummary.trim()}`
+    );
+  }
+  parts.push(
+    options.compressEnabled ? CLAUDE_CLI_COMPRESS_NOTE : CLAUDE_CLI_CONTEXT_NOTE
+  );
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
@@ -3393,7 +3467,28 @@ var ClaudeCodeLanguageModel = class {
    */
   async ensureProxyServer(tools, sessionKeyForCalls) {
     const timeoutOverrides = this.config.proxyToolTimeoutMs;
-    const srv = await createProxyMcpServer(tools, timeoutOverrides);
+    const interceptors = /* @__PURE__ */ new Map();
+    if (tools.some((t) => t.name === "compress")) {
+      interceptors.set("compress", (input) => {
+        const summary = typeof input.summary === "string" ? input.summary.trim() : "";
+        if (!summary) {
+          return {
+            kind: "error",
+            message: "compress needs a non-empty `summary`: it becomes the only prior context after the reset. Nothing was compressed."
+          };
+        }
+        storeCompressionSummary(sessionKeyForCalls, summary);
+        log.info("compress stored summary; session resets next turn", {
+          sessionKey: sessionKeyForCalls,
+          summaryLength: summary.length
+        });
+        return {
+          kind: "text",
+          text: "Summary stored. Finish this turn as normal; the next turn starts a fresh Claude Code session with this summary as its only prior context."
+        };
+      });
+    }
+    const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors);
     srv.calls.on("call", (call) => {
       queuePendingProxyCall(sessionKeyForCalls, call, timeoutOverrides);
     });
@@ -3755,6 +3850,7 @@ var ClaudeCodeLanguageModel = class {
     if (!hasPriorConversation) {
       deleteClaudeSessionId(sk);
       deleteActiveProcess(sk);
+      clearCompression(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const includeHistoryContext = !hasExistingSession && hasPriorConversation;
@@ -3768,7 +3864,10 @@ var ClaudeCodeLanguageModel = class {
     const systemPromptFile = buildAppendedSystemPrompt(
       cwd,
       this.config.multiStepContinuation !== false,
-      extractSystemMessages(options.prompt)
+      extractSystemMessages(options.prompt),
+      // doGenerate has no proxy wiring, so `compress` is not callable here.
+      // An existing summary still carries: it is this key's prior context.
+      { compressEnabled: false, compressionSummary: getCompressionSummary(sk) }
     );
     const cliArgs = buildCliArgs({
       sessionKey: sk,
@@ -4138,6 +4237,7 @@ ${plan}
     if (!hasPriorConversation) {
       deleteClaudeSessionId(sk);
       deleteActiveProcess(sk);
+      clearCompression(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const hasActiveProcess = !!getActiveProcess(sk);
@@ -4188,6 +4288,13 @@ ${plan}
           deleteActiveProcess(sk);
           deleteClaudeSessionId(sk);
         }
+        if (!compactionMode && !hasMatchedPendingResults && consumeCompressionRestart(sk)) {
+          deleteActiveProcess(sk);
+          deleteClaudeSessionId(sk);
+          log.info("compress reset: dropped claude process and session id", {
+            sessionKey: sk
+          });
+        }
         let activeProcess = getActiveProcess(sk);
         let proc;
         let lineEmitter;
@@ -4363,7 +4470,11 @@ ${plan}
                   ...extractSystemMessages(options.prompt),
                   ...taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
                   ...questionProxyActive ? [QUESTION_PROXY_HINT] : []
-                ]
+                ],
+                {
+                  compressEnabled: enrichedProxy?.some((t) => t.name === "compress") ?? false,
+                  compressionSummary: getCompressionSummary(sk)
+                }
               );
               cliArgs = buildCliArgs({
                 sessionKey: sk,
@@ -6439,6 +6550,7 @@ var index_default = {
 };
 export {
   ClaudeCodeLanguageModel,
+  DEFAULT_PROXY_TOOL_NAMES,
   bridgeOpencodeMcp,
   claudeCodeProviders,
   configModelsForProvider,