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

package/README.md

@@ -181,7 +181,8 @@ 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). |
+| `extraDisallowedTools` | string[] | – | Extra Claude built-ins to switch off with `--disallowedTools`, on top of what `proxyTools` implies. Claude's names, e.g. `["NotebookEdit"]`. See [Closing a tool with no proxy](#closing-a-tool-with-no-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 +274,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 +299,35 @@ 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.
+### Closing a tool with no proxy
+
+`proxyTools` only reaches built-ins the plugin can replace. A built-in with no opencode equivalent, `NotebookEdit` today and whatever Claude Code ships next, stays enabled and unmediated no matter what you put in that list. `extraDisallowedTools` names them directly:
+
+```json
+"options": {
+  "extraDisallowedTools": ["NotebookEdit"]
+}
+```
+
+These go straight to `claude --disallowedTools`, so use Claude's tool names rather than opencode's. There is no replacement: the capability goes away rather than being routed through opencode, which is the point, but the model then has to work without it.
+
+Unknown entries in `proxyTools` are logged as a warning at spawn rather than passing silently, so a typo shows up as "ignoring unknown proxyTools entries" in the plugin log instead of quietly leaving the matching built-in unmediated.
+
+### 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

@@ -161,6 +161,7 @@ interface ClaudeCodeConfig {
     controlRequestToolBehaviors?: Record<string, ControlRequestBehavior>;
     controlRequestDenyMessage?: string;
     proxyTools?: string[];
+    extraDisallowedTools?: string[];
     proxyToolTimeoutMs?: Record<string, number>;
     /**
      * Route `ExitPlanMode` through opencode's native `question` tool so plan
@@ -283,6 +284,20 @@ interface ClaudeCodeProviderSettings {
       * entry, in which case the deny/markdown fallback applies.
       */
     proxyTools?: string[];
+    /**
+     * Extra Claude Code built-ins to switch off with `--disallowedTools`,
+     * on top of the ones implied by `proxyTools`.
+     *
+     * `proxyTools` can only disable built-ins the plugin knows how to
+     * replace, so a built-in with no proxy equivalent (`NotebookEdit`, and
+     * anything Claude Code adds after this release) has no off switch
+     * otherwise. Names are Claude's, not opencode's: `["NotebookEdit"]`.
+     *
+     * Disabling a tool with no replacement removes the capability rather
+     * than routing it through opencode — that is the point, but it does mean
+     * the model has to work without it.
+     */
+    extraDisallowedTools?: string[];
     /**
      * Per-tool proxy call timeouts in milliseconds, keyed by the proxy tool
      * name (`bash`, `edit`, `write`, `webfetch`, `task`, `question` —
@@ -655,6 +670,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 +689,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

@@ -294,6 +294,9 @@ var CLAUDE_INTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "TaskGet",
   "TaskStop"
 ]);
+function singleQuoteForShell(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 function emitTodoWrite(todos) {
   return {
     name: "todowrite",
@@ -348,7 +351,7 @@ function mapTool(name, input, opts) {
     return {
       name: "bash",
       input: {
-        command: `echo "TASK OUTPUT: ${String(output).replace(/"/g, '\\"')}"`,
+        command: `printf '%s\\n' ${singleQuoteForShell(`TASK OUTPUT: ${String(output)}`)}`,
         description: "Displaying task output"
       },
       executed: false
@@ -2212,6 +2215,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 +2307,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 +2522,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 +2615,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 +2666,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, {
@@ -2766,6 +2813,20 @@ function disallowedToolFlags(tools) {
   }
   return out;
 }
+function resolveDisallowedTools(options) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (name) => {
+    const trimmed = name.trim();
+    if (!trimmed || seen.has(trimmed)) return;
+    seen.add(trimmed);
+    out.push(trimmed);
+  };
+  for (const name of disallowedToolFlags(options.proxyTools ?? [])) push(name);
+  for (const name of options.extraDisallowedTools ?? []) push(String(name));
+  if (options.disableWebSearch) push("WebSearch");
+  return out;
+}
 function readBody(req) {
   return new Promise((resolve4, reject) => {
     const chunks = [];
@@ -2774,6 +2835,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 +3232,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 +3257,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());
   }
@@ -3279,9 +3370,22 @@ var ClaudeCodeLanguageModel = class {
       DEFAULT_PROXY_TOOLS.map((t) => [t.name.toLowerCase(), t])
     );
     const picked = [];
+    const unknown = [];
     for (const n of names) {
       const def = defsByName.get(String(n).toLowerCase());
       if (def) picked.push(def);
+      else unknown.push(String(n));
+    }
+    if (unknown.length > 0) {
+      const known = [...defsByName.keys()].join(", ");
+      if (picked.length === 0) {
+        log.warn(
+          "no proxyTools entry was recognised; nothing will be proxied this turn",
+          { unknown, known }
+        );
+      } else {
+        log.warn("ignoring unknown proxyTools entries", { unknown, known });
+      }
     }
     return picked.length > 0 ? picked : null;
   }
@@ -3393,7 +3497,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 +3880,7 @@ var ClaudeCodeLanguageModel = class {
     if (!hasPriorConversation) {
       deleteClaudeSessionId(sk);
       deleteActiveProcess(sk);
+      clearCompression(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const includeHistoryContext = !hasExistingSession && hasPriorConversation;
@@ -3768,7 +3894,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 +4267,7 @@ ${plan}
     if (!hasPriorConversation) {
       deleteClaudeSessionId(sk);
       deleteActiveProcess(sk);
+      clearCompression(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const hasActiveProcess = !!getActiveProcess(sk);
@@ -4188,6 +4318,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;
@@ -4346,10 +4483,11 @@ ${plan}
                 proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
               }
               const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
-              const proxyDisallowed = enrichedProxy ? disallowedToolFlags(enrichedProxy) : [];
-              const extraDisallowed = [];
-              if (self.config.webSearch === "disabled") extraDisallowed.push("WebSearch");
-              const allDisallowed = [...proxyDisallowed, ...extraDisallowed];
+              const allDisallowed = resolveDisallowedTools({
+                proxyTools: enrichedProxy,
+                extraDisallowedTools: self.config.extraDisallowedTools,
+                disableWebSearch: self.config.webSearch === "disabled"
+              });
               const mcp = self.effectiveMcpConfig(
                 cwd,
                 proxyServer?.configPath(),
@@ -4363,7 +4501,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,
@@ -5596,11 +5738,11 @@ function defineModel(opts) {
     variants: opts.reasoning ? reasoningVariants : void 0
   };
 }
-var haikuCost = { input: 1e-6, output: 5e-6, cacheRead: 1e-7, cacheWrite: 125e-8 };
-var sonnetCost = { input: 3e-6, output: 15e-6, cacheRead: 3e-7, cacheWrite: 375e-8 };
-var sonnet5Cost = { input: 2e-6, output: 1e-5, cacheRead: 2e-7, cacheWrite: 25e-7 };
-var opusCost = { input: 5e-6, output: 25e-6, cacheRead: 5e-7, cacheWrite: 625e-8 };
-var fableCost = { input: 1e-5, output: 5e-5, cacheRead: 1e-6, cacheWrite: 125e-7 };
+var haikuCost = { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 };
+var sonnetCost = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
+var sonnet5Cost = { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 };
+var opusCost = { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 };
+var fableCost = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
 function toConfigModel(model) {
   const inputMods = [];
   const outputMods = [];
@@ -6199,6 +6341,7 @@ function createClaudeCode(settings = {}) {
       controlRequestToolBehaviors: settings.controlRequestToolBehaviors,
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
+      extraDisallowedTools: settings.extraDisallowedTools,
       proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
       planModeQuestion: settings.planModeQuestion ?? false,
       webSearch: settings.webSearch,
@@ -6439,6 +6582,7 @@ var index_default = {
 };
 export {
   ClaudeCodeLanguageModel,
+  DEFAULT_PROXY_TOOL_NAMES,
   bridgeOpencodeMcp,
   claudeCodeProviders,
   configModelsForProvider,