@khalilgharbaoui/opencode-claude-code-plugin 0.64.1 → 0.65.0

package/dist/index.d.ts

@@ -113,6 +113,81 @@ interface V2ModelRequestEvent {
 interface V2ModelHookOptions {
     readonly providerID?: string;
 }
+/**
+ * `@opencode/plugin` 2.2.2 `SessionRetry`, the `session.hook("retry")` event:
+ * opencode asks before it runs a failed turn again (h #g277).
+ */
+interface V2SessionRetryEvent {
+    readonly sessionID: string;
+    readonly model: {
+        readonly id: string;
+        readonly providerID: string;
+    };
+    readonly error: {
+        readonly type?: string;
+        readonly message?: string;
+    };
+    readonly attempt: number;
+    decision: {
+        retry: false;
+    } | {
+        retry: true;
+        delay: number;
+    };
+}
+/** One way to connect an integration (`IntegrationMethod`); only `type` is always there. */
+interface V2IntegrationMethod {
+    readonly type: string;
+    readonly id?: string;
+    readonly label?: string;
+}
+/** `@opencode/plugin` 2.2.2 `IntegrationEditor`, the calls we make. */
+interface V2IntegrationEditor {
+    get(id: string): {
+        id: string;
+        name: string;
+    } | undefined;
+    update(id: string, update: (integration: {
+        id: string;
+        name: string;
+    }) => void): void;
+    readonly method: {
+        list(integrationID: string): readonly V2IntegrationMethod[];
+        update(input: {
+            integrationID: string;
+            method: {
+                id: string;
+                type: "external";
+                label: string;
+            };
+        }): void;
+        remove(integrationID: string, method: V2IntegrationMethod): void;
+    };
+}
+/** `@opencode/client` `ConnectionInfo`, passed back to opencode untouched. */
+interface V2ConnectionInfo {
+    readonly type: string;
+    readonly id?: string;
+    readonly label?: string;
+}
+/** `@opencode/schema/connection` `Connection.Status`. */
+interface V2ConnectionStatus {
+    status: "needs_auth";
+    message: string;
+    url?: string;
+}
+/** `@opencode/plugin` 2.2.2 `IntegrationDomain`, the slice `/connect` needs. */
+interface V2IntegrationDomain {
+    transform(callback: (editor: V2IntegrationEditor) => void): Promise<V2Registration>;
+    readonly connection: {
+        active(integrationID: string): Promise<V2ConnectionInfo | undefined>;
+        status(input: {
+            integrationID: string;
+            connection: V2ConnectionInfo;
+            status: V2ConnectionStatus | undefined;
+        }): Promise<void>;
+    };
+}
 /** `@opencode/schema/prompt-input` `Prompt`: we only rewrite `text`. */
 type V2Prompt = {
     text?: string;
@@ -158,6 +233,8 @@ interface V2Context {
     readonly options: Record<string, unknown>;
     readonly provider: {
         transform(callback: (editor: V2ProviderEditor) => void): Promise<V2Registration>;
+        /** Re-runs the transforms. In `@opencode/plugin` 2.2.5; optional because older hosts may lack it. */
+        reload?(): Promise<void>;
     };
     readonly aisdk: {
         hook(name: "sdk", callback: (event: V2AISDKSdkEvent) => Promise<void> | void, options?: V2ModelHookOptions): Promise<V2Registration>;
@@ -165,6 +242,7 @@ interface V2Context {
     };
     readonly session: {
         hook(name: "model.request", callback: (event: V2ModelRequestEvent) => Promise<void> | void, options?: V2ModelHookOptions): Promise<V2Registration>;
+        hook(name: "retry", callback: (event: V2SessionRetryEvent) => Promise<void> | void, options?: V2ModelHookOptions): Promise<V2Registration>;
         prompt?(input: V2Prompt & {
             sessionID: string;
             delivery?: V2Delivery;
@@ -180,6 +258,8 @@ interface V2Context {
             signal?: AbortSignal;
         }): AsyncIterable<V2Event>;
     };
+    /** `/connect`'s entry for each provider (h #g277). Optional: early 2.0 releases lack parts of it. */
+    readonly integration?: V2IntegrationDomain;
     /**
      * Absent before 2.0.31's measured shape: the definition is plain JSON
      * Schema, which `Rpc.PortableDefinition` accepts, and the handlers object is
@@ -444,7 +524,11 @@ interface ClaudeCodeConfig {
     controlRequestDenyMessage?: string;
     proxyTools?: string[];
     proxyOpencodeTools?: string[];
+    /** See `ClaudeCodeProviderSettings.alwaysLoadProxyTools`. Default bash, edit, write. */
+    alwaysLoadProxyTools?: boolean | string[];
     stripContextReminders?: boolean;
+    /** See `ClaudeCodeProviderSettings.verbatimPrompts`. Default true. */
+    verbatimPrompts?: boolean;
     extraDisallowedTools?: string[];
     /** See `ClaudeCodeProviderSettings.mapReadRules`. Default true. */
     mapReadRules?: boolean;
@@ -481,6 +565,8 @@ interface ClaudeCodeConfig {
     resumeAfterRestart?: boolean;
     /** Carry a conversation's Claude session over when its model or effort changes. Default true. */
     resumeAcrossModelChanges?: boolean;
+    /** Apply a model or effort change to the live `claude` process. Default true. */
+    liveModelSwitch?: boolean;
     /** Carry a conversation's Claude transcript over on an account switch. Default true. */
     crossAccountResume?: boolean;
     /** See `ClaudeCodeProviderSettings.maxBudgetUsd`. Resolved; unset is off. */
@@ -536,6 +622,26 @@ type AccountFailoverMode = "ask" | "off" | "auto";
 type SubagentDispatchMode = "ask" | "off";
 interface ClaudeCodeProviderSettings {
     cliPath?: string;
+    /**
+     * Register the model catalog as the installed Claude Code describes it.
+     * Default `true`.
+     *
+     * A background probe asks the CLI, once per CLI version, which models it
+     * knows, the context window it runs each in and the effort levels it
+     * accepts, and keeps the answer in `cli-models.json` under
+     * `$XDG_STATE_HOME`. Providers are registered from that file: windows and
+     * effort variants follow the CLI, and a model the CLI's own picker offers
+     * that the catalog lacks is added at an unknown (zero) price. Costs and the
+     * `(N×)` labels stay the catalog's, because the CLI carries no prices.
+     *
+     * Free: each probe is a `--bare` process with no credential, sent
+     * `initialize` and `get_context_usage` and never a message (measured: no
+     * API request, h #g279). Registration never waits for it, so a fresh answer
+     * applies at once on opencode 2 (a provider reload) and from the next
+     * start on opencode 1. `false` registers the built-in catalog as it ships
+     * and runs no probe.
+     */
+    cliModelCatalog?: boolean;
     /** Internal: set by the opencode 2 entrypoint. See `ClaudeCodeConfig.hostApi`. */
     hostApi?: "v1" | "v2";
     /** Wins over the legacy interactive option and its environment fallback. */
@@ -839,6 +945,39 @@ interface ClaudeCodeProviderSettings {
      * reminder is then something the model can actually act on.
      */
     stripContextReminders?: boolean;
+    /**
+     * Which proxy tools Claude Code loads into every request instead of
+     * deferring them behind its `ToolSearch` tool. Default `["bash", "edit",
+     * "write"]`.
+     *
+     * Claude Code defers every MCP tool, the proxy's included, so the first
+     * proxied call in a `claude` process costs one extra API request to find
+     * the tool. A listed tool is served with `_meta["anthropic/alwaysLoad"]`,
+     * which skips that request: measured on Claude Code 2.1.314, a turn that
+     * ran a proxied `bash` took 2 API calls instead of 3, with 32% fewer prompt
+     * tokens and 41% lower cost, while a turn that called no tool carried 531
+     * more prompt tokens. `true` loads every tool the proxy serves (the MCP
+     * tools `proxyOpencodeMcpTools` adds included), `false` defers them all as
+     * before. Names are the proxy's lowercase tool names. An older Claude Code
+     * ignores the field.
+     */
+    alwaysLoadProxyTools?: boolean | string[];
+    /**
+     * Deliver the text of every message as written. Default true.
+     *
+     * Claude Code reads the last text block of a headless user message the way
+     * it reads typing: a leading `/` runs one of its commands and an `@path`
+     * attaches that file. Measured on Claude Code 2.1.314, a message `/model
+     * claude-sonnet-5-5` switched the running process to Sonnet without a
+     * model call, and a message starting with a path such as `/etc/hosts` lost
+     * the environment, deferred-tool, agent and skill context of its turn. On,
+     * each envelope carries `client_composed: true`, the field the Agent SDK's
+     * `verbatimPrompts` sets, and the text reaches Claude unchanged; hooks,
+     * CLAUDE.md and the skill listing still arrive. The one thing lost is the
+     * `ultrathink` keyword's reminder: use an effort variant instead. Headless
+     * transport only; an older Claude Code ignores the field.
+     */
+    verbatimPrompts?: boolean;
     /**
      * Extra Claude Code built-ins to switch off with `--disallowedTools`,
      * on top of the ones implied by `proxyTools`.
@@ -1079,6 +1218,29 @@ interface ClaudeCodeProviderSettings {
      * false` turns this off too.
      */
     resumeAcrossModelChanges?: boolean;
+    /**
+     * Apply a model or reasoning effort change to the conversation's running
+     * `claude` process, with the CLI's own `set_model` and `apply_flag_settings`
+     * control requests, instead of stopping it and starting another with
+     * `--resume`. Default `true`.
+     *
+     * Measured on Claude Code 2.1.288 and 2.1.314 (h #g278): the conversation is
+     * kept, the next request goes out under the new model or effort, and the
+     * prompt cache reads and writes are the same as the respawn's. What it saves
+     * is the respawn itself, 4.6 to 6.6 seconds to `system`/`init` per change on
+     * a real install, against about 25 ms for an effort change and 0.5 to 0.7 s
+     * for a model change. To make an effort change possible, a headless spawn
+     * carries its effort as `--effort` and drops CLAUDE_CODE_EFFORT_LEVEL: the
+     * variable beats a live change silently.
+     *
+     * Only between two models on the same account and in the same fast mode,
+     * between two explicit efforts, on an idle child (a change that lands
+     * mid-turn still finishes that turn on the old settings, h #g271), and on
+     * the headless transport: the interactive one has no control channel and
+     * keeps respawning. Any refusal or timeout falls back to the respawn. Needs
+     * `resumeAcrossModelChanges`; `false` here restores the respawn exactly.
+     */
+    liveModelSwitch?: boolean;
     /**
      * Continue the same Claude conversation when it moves to another account,
      * instead of replaying the whole thread as text into a fresh session there.