@khalilgharbaoui/opencode-claude-code-plugin 0.18.3 → 0.20.0

package/dist/index.d.ts

@@ -87,7 +87,7 @@ type OpenCodeConfig = {
  * Bus events surface to plugins. Shape mirrors what opencode core publishes
  * via `GlobalBus.emit("event", { directory, payload: { type, properties } })`
  * but kept loose since opencode adds events over time and this plugin only
- * reacts to a small subset (currently just `global.disposed`).
+ * reacts to a small subset (currently just `session.deleted`).
  */
 type OpenCodeEvent = {
     type?: string;
@@ -186,9 +186,9 @@ interface ClaudeCodeConfig {
     /**
      * 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.
+     * answer in prose. Off by default because it cannot currently fire: headless
+     * `--print` is not offered an `ExitPlanMode` tool at all, and this bridge
+     * keys on that tool call. See the plan-mode gotcha in AGENTS.md.
      */
     planModeQuestion?: boolean;
     webSearch?: WebSearchRouting;
@@ -202,6 +202,8 @@ interface ClaudeCodeConfig {
     idleProcessTimeoutMs?: number;
     /** Stage opencode skills as a `--plugin-dir` so Claude's Skill tool can run them. */
     bridgeOpencodeSkills?: boolean;
+    /** Append a one-line cost / duration / cache footer to each finished turn. */
+    turnStats?: boolean;
     logging?: LoggingConfig;
 }
 interface LoggingConfig {
@@ -336,13 +338,17 @@ interface ClaudeCodeProviderSettings {
      * receives a timeout error.
      *
      * Defaults (used when a tool is absent here): `bash`/`edit`/`write`/
-     * `webfetch` → 10 min (matches Claude CLI's Bash ceiling); `task` →
-     * 60 min (subagents routinely run 20–40 min); `question` → 30 min
-     * (operator AFK). Setting a key here replaces the default for that tool.
+     * `webfetch` → 10 min (matches Claude CLI's Bash ceiling); `task` and
+     * `task_batch` → no deadline (the call waits for the subagent; abandoned
+     * calls are released by aborts, the next user turn, and the process going
+     * away); `question` → 30 min (operator AFK). A positive value here replaces
+     * the default for that tool, `0` disables its deadline, and a negative or
+     * non-finite value is ignored.
      *
      * For `bash` specifically the call's own `input.timeout` is honoured on
      * top: the effective deadline is `max(resolved, input.timeout)`, so a
-     * long build the caller explicitly asked to run is never undercut.
+     * long build the caller explicitly asked to run is never undercut, and a
+     * positive `input.timeout` restores a deadline that `bash: 0` disabled.
      */
     proxyToolTimeoutMs?: Record<string, number>;
     /**
@@ -355,11 +361,15 @@ interface ClaudeCodeProviderSettings {
      * 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.
+     * Opt-in, and currently dormant. The delivery surface works: opencode's
+     * `question` form renders and round-trips (verified 2026-09-06, correcting
+     * an earlier claim here that it was broken upstream). What does not work is
+     * the trigger: headless `--print` does not offer the model an
+     * `ExitPlanMode` tool, measured on CLI 2.1.258, so the bridge has nothing
+     * to key on and the text path is what you get. Older opencode builds also
+     * have no `question` registry entry, in which case the plugin silently
+     * keeps the text path. Re-run the probes in AGENTS.md on a newer CLI before
+     * assuming the bridge is reachable.
      */
     planModeQuestion?: boolean;
     /**
@@ -375,21 +385,40 @@ interface ClaudeCodeProviderSettings {
     ignoreAnthropicApiKey?: boolean;
     /**
      * Kill a retained headless Claude worker after this many milliseconds of
-     * inactivity following a completed turn. Starting another turn cancels the
-     * timer, and the Claude session id is retained for a transparent resume.
-     * Omit or set to 0 to keep workers until LRU eviction. Interactive transport
-     * is excluded because it does not currently guarantee session-id resume.
+     * inactivity following a completed turn. Off unless set. The timer
+     * starts when a turn completes (not at spawn), starting another turn cancels
+     * it, a worker found mid-turn when it fires is left alone and re-timed, and
+     * the Claude session id is retained for a transparent resume. Omit or set 0
+     * to keep workers until LRU eviction (16 processes). Interactive transport is
+     * excluded because it does not currently guarantee session-id resume.
      */
     idleProcessTimeoutMs?: number;
     /**
      * Expose your opencode skills (`.opencode/skills`, `~/.config/opencode/skills`)
      * to Claude Code's native Skill tool by staging them as a session-scoped
-     * `--plugin-dir`. Off by default: every bridged skill is also listed in the
-     * system prompt opencode already forwards, so a large skill set is paid for
-     * twice per turn. Turn it on when the model tries `Skill("<name>")` and gets
-     * `Unknown skill`. No-op on CLIs without `--plugin-dir`.
+     * `--plugin-dir`, so a `Skill("<name>")` call for a skill opencode advertises
+     * does not fail with `Unknown skill`. Off by default: every bridged skill
+     * is also listed in the system prompt opencode forwards, so a large skill
+     * set costs prompt tokens twice per turn. When on it applies to the
+     * headless, interactive and direct `doGenerate` spawns alike; compaction
+     * never loads it, and the bundled configuration skill is staged either way.
+     * No-op on CLIs without `--plugin-dir`.
      */
     bridgeOpencodeSkills?: boolean;
+    /**
+     * Append one compact line to the end of every finished (non-compaction,
+     * non-error) turn with what that turn cost: dollars, wall duration, how many
+     * internal CLI turns it took, and input / output / cache-read / cache-write
+     * tokens. It is rendered as its own text part led by `▌ **stats:**` and is
+     * stripped again from any transcript rebuilt for the CLI, so the model never
+     * reads its own accounting.
+     *
+     * Off by default, because a cost line under every reply is a preference.
+     * The same numbers are logged at INFO regardless of this setting, and
+     * `total_cost_usd`, `duration_ms`, `usage`, `modelUsage` and
+     * `permission_denials` always reach `providerMetadata`.
+     */
+    turnStats?: boolean;
     /**
      * Routing for Claude's built-in `WebSearch` tool.
      *
@@ -510,8 +539,22 @@ interface ClaudeStreamMessage {
                 text?: string;
             }>;
             thinking?: string;
+            /** On a `tool_result` block: the CLI-executed tool failed. */
+            is_error?: boolean;
         }>;
     };
+    apiKeySource?: string;
+    permissionMode?: string;
+    model?: string;
+    claude_code_version?: string;
+    tools?: string[];
+    mcp_servers?: Array<{
+        name?: string;
+        status?: string;
+    }>;
+    compact_metadata?: Record<string, unknown>;
+    compactMetadata?: Record<string, unknown>;
+    rate_limit_info?: Record<string, unknown>;
     tool?: {
         name?: string;
         id?: string;
@@ -533,6 +576,24 @@ interface ClaudeStreamMessage {
     result?: string;
     is_error?: boolean;
     num_turns?: number;
+    stop_reason?: string | null;
+    /**
+     * Per-model totals on `result`, keyed by model id: `inputTokens`,
+     * `outputTokens`, `cacheReadInputTokens`, `cacheCreationInputTokens`,
+     * `webSearchRequests`, `costUSD`. All numeric, which is what makes it safe
+     * to forward whole into `providerMetadata`.
+     */
+    modelUsage?: Record<string, Record<string, number>>;
+    /**
+     * Tool calls the CLI's permission layer refused during the turn. Each entry
+     * also carries a `tool_input` on the wire; it is deliberately not declared
+     * here, because it can be a whole file's contents and must not be copied
+     * into provider metadata.
+     */
+    permission_denials?: Array<{
+        tool_name?: string;
+        tool_use_id?: string;
+    }>;
     usage?: {
         input_tokens?: number;
         output_tokens?: number;
@@ -768,6 +829,17 @@ declare const DEFAULT_PROXY_TOOL_NAMES: string[];
  * so a user-defined command keeps opencode's normal behaviour end to end.
  */
 declare function registerSideQuestionCommand(config: OpenCodeConfig): boolean;
+/**
+ * Registers `/claude-code-doctor` unless the user defined their own command of
+ * that name. Unlike `/btw` there is no hook to guard: the command is a plain
+ * template and the language model answers the message it produces, so leaving
+ * a user definition alone here is the whole guard.
+ *
+ * The name carries no slash. opencode invokes a command as `/<key>` and takes
+ * everything after the first space as `$ARGUMENTS`, so `claude-code doctor`
+ * would be the command `claude-code` with the argument `doctor`.
+ */
+declare function registerDoctorCommand(config: OpenCodeConfig): boolean;
 declare function _resetPlanModeWarningForTests(): void;
 declare function warnIfPlanModeCannotExit(permissionMode: string | undefined): void;
 declare function createClaudeCode(settings?: ClaudeCodeProviderSettings): ClaudeCodeProvider;
@@ -783,9 +855,15 @@ declare function configModelsForProvider(providerModels: OpenCodeProvider["model
  * diagnostics never report another provider's options.
  */
 declare function claudeCodeProviders(providers: Record<string, DiagnosticsProviderEntry> | undefined): Record<string, DiagnosticsProviderEntry>;
+/**
+ * The opencode session id a `session.deleted` bus event names, or undefined
+ * for any other event. opencode publishes `{ type, properties: { info } }`
+ * under `payload`, and the deleted session's own record is `properties.info`.
+ */
+declare function extractDeletedSessionId(event: OpenCodeEvent | undefined): string | undefined;
 declare const _default: {
     id: string;
     server: OpenCodePlugin;
 };
 
-export { type AgentRecord, type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, DEFAULT_PROXY_TOOL_NAMES, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, _resetPlanModeWarningForTests, bridgeOpencodeMcp, claudeCodeProviders, configModelsForProvider, createClaudeCode, _default as default, defaultModels, getAgentRegistry, getDefaultSubagentModel, registerSideQuestionCommand, resolveAgentModel, warnIfPlanModeCannotExit };
+export { type AgentRecord, type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, DEFAULT_PROXY_TOOL_NAMES, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, _resetPlanModeWarningForTests, bridgeOpencodeMcp, claudeCodeProviders, configModelsForProvider, createClaudeCode, _default as default, defaultModels, extractDeletedSessionId, getAgentRegistry, getDefaultSubagentModel, registerDoctorCommand, registerSideQuestionCommand, resolveAgentModel, warnIfPlanModeCannotExit };