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

package/README.md

@@ -181,8 +181,9 @@ 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. |
 | `controlRequestToolBehaviors` | `Record<string, "allow" \| "deny">` | – | Per-tool override for `can_use_tool`. Example: `{ "Bash": "deny", "Read": "allow" }`. |
 | `controlRequestDenyMessage` | string | built-in message | Message returned to Claude on a deny. |
@@ -272,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
 
@@ -296,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:
 
@@ -450,6 +466,25 @@ Each chat keeps a long-lived `claude` subprocess so the model retains its native
 
 Set `permissionMode: "plan"` to forward `--permission-mode plan` to Claude. The plugin handles `ExitPlanMode` specially — instead of forwarding it as a tool call, it converts it to a confirmation prompt that flows through opencode normally.
 
+By default that prompt is text: the plan is rendered as markdown, followed by `**Do you want to proceed with this plan?** (yes/no)`, and you answer in your next message.
+
+### Approval as a real form (`planModeQuestion`, opt-in)
+
+Set `planModeQuestion: true` to route the approval through opencode's native `question` tool instead:
+
+```json
+"options": {
+  "permissionMode": "plan",
+  "planModeQuestion": true
+}
+```
+
+The plan is still rendered, but the turn then ends on `tool-calls` and opencode runs its own `question` tool, so approval is a form rather than prose. Your answer is fed back to the CLI as the `tool_result` for the original `ExitPlanMode` call, which is what actually unlocks plan mode on the Claude side. A "yes" typed as ordinary text never does that. Anything other than picking `yes` (including custom text) comes back as rejection feedback the model is told to act on.
+
+> **Leave this off for now.** It depends on the same opencode `question` form that is [broken upstream](#with-question-in-proxytools-currently-blocked-upstream--leave-it-off): with it on, a plan approval hangs until you interrupt the turn. On opencode builds with no `question` registry entry at all the plugin silently keeps the text path (look for `plan-mode question gate` in the log). Re-test when [anomalyco/opencode#36603](https://github.com/anomalyco/opencode/pull/36603) merges.
+
+Approval bridge contributed by [@CollieIsCute](https://github.com/CollieIsCute).
+
 ---
 
 ## AskUserQuestion

package/dist/index.d.ts

@@ -162,6 +162,14 @@ interface ClaudeCodeConfig {
     controlRequestDenyMessage?: string;
     proxyTools?: string[];
     proxyToolTimeoutMs?: Record<string, number>;
+    /**
+     * Route `ExitPlanMode` through opencode's native `question` tool so plan
+     * approval is a real form instead of a "(yes/no)" line the operator has to
+     * answer in prose. Off by default: opencode's question form is currently
+     * broken upstream, so enabling this trades a working text prompt for a
+     * silent hang. See the plan-mode gotcha in AGENTS.md.
+     */
+    planModeQuestion?: boolean;
     webSearch?: WebSearchRouting;
     hotReloadMcp?: boolean;
     proxyOpencodeMcpTools?: boolean;
@@ -292,6 +300,23 @@ interface ClaudeCodeProviderSettings {
      * long build the caller explicitly asked to run is never undercut.
      */
     proxyToolTimeoutMs?: Record<string, number>;
+    /**
+     * Route Claude's `ExitPlanMode` through opencode's native `question` tool.
+     *
+     * Off (default): the plan is rendered as markdown followed by
+     * `**Do you want to proceed with this plan?** (yes/no)` and the operator
+     * answers in prose. On: the plan is rendered, the turn ends on
+     * `tool-calls`, and opencode runs its own `question` tool so approval is a
+     * real form; the answer is fed back to the CLI as the `tool_result` for
+     * the original `ExitPlanMode` call, which is what unlocks plan mode.
+     *
+     * Two reasons it is opt-in. opencode's `question` form does not currently
+     * render (upstream anomalyco/opencode#36604), so an enabled bridge hangs
+     * the turn until the operator interrupts; and older opencode builds have
+     * no `question` registry entry at all, in which case the plugin silently
+     * keeps the text path. See the plan-mode gotcha in AGENTS.md.
+     */
+    planModeQuestion?: boolean;
     /**
      * Strip `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` from the environment of
      * every spawned `claude` process. When an API key is present, Claude Code
@@ -525,9 +550,20 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      *   call resolves to `⚙ invalid`; the version gate drops the def.
      *
      * Returns undefined/false when the SDK client is unavailable (direct
-     * AI-SDK use, tests) so the static defs stand.
+     * AI-SDK use, tests) so the static defs stand. `resolved` distinguishes
+     * "the registry answered and has no `question` entry" from "nobody
+     * answered": only the former is a real version-gate signal.
      */
     private fetchLiveToolInfo;
+    /** Share one lazy registry request within a turn without making it stale. */
+    private createLiveToolInfoLoader;
+    /**
+     * Whether the ExitPlanMode approval bridge is live for this turn: the
+     * operator opted in AND opencode's registry actually has the `question`
+     * tool. Without the registry entry the emitted tool-call would render as
+     * `⚙ invalid` and wedge the turn, so the plugin keeps the text path.
+     */
+    private resolvePlanModeQuestion;
     /**
      * Create a proxy MCP server for a single active Claude process/session.
      * The process lifecycle owns the server lifecycle via session-manager.
@@ -619,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
@@ -637,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 };