@khalilgharbaoui/opencode-claude-code-plugin 0.24.0 → 0.26.0

package/README.md

@@ -80,11 +80,37 @@ In your `opencode.json`, point at the local build with a `file://` URL:
 
 CI installs and builds on **Node 24** (`.github/workflows/publish.yml`), which is the only version this package is built against. `package.json` declares no `engines` range, so older Node versions are untested rather than deliberately unsupported. opencode itself may run under Bun; the [interactive transport](#interactive-transport-experimental) requires that.
 
+### opencode 2
+
+The same package runs on opencode 1.x and 2.x, and nothing changes for 1.x. The same config works too: opencode 2's native key is `plugins`, but it still reads the 1.x `plugin` key shown above, so an existing install needs no edit. A config used only by opencode 2 can spell it natively:
+
+```json
+{
+  "plugins": ["@khalilgharbaoui/opencode-claude-code-plugin"]
+}
+```
+
+Your existing `provider.claude-code.options` block keeps working, because opencode 2 still reads 1.x config files. Its native spelling is `provider.claude-code.settings`, and plugin-level settings such as `accounts` may also go in the plugin entry itself: `{"package": "@khalilgharbaoui/opencode-claude-code-plugin", "options": {"accounts": ["work"]}}`.
+
+For a local checkout, point opencode 2 at the **`dist` directory**, not the repository root. It loads `<dir>/server` or `<dir>/index` from a directory and never reads `package.json#main`:
+
+```json
+{
+  "plugins": ["/absolute/path/to/opencode-claude-code-plugin/dist"]
+}
+```
+
+Verified live on opencode **2.0.11** with Claude Code 2.1.280: chat turns, proxied tools running through opencode 2's own `shell`, `edit`, `write`, `webfetch` and `subagent` tools and their permission rules, Claude's own tools rendered in the transcript, subagent dispatch with the agent list, reasoning variants, compaction, account providers, `/claude-code-doctor`, `/btw`, and the bundled configuration skill. Differences from 1.x:
+
+- **`/btw` is answered after the running turn**, not inside it. opencode 2's plugin API has no session-status route, which is what 1.x uses to write the answer into a turn that is still running. The aside is queued, so it can never swallow the turn's own continuation.
+- **No todo panel.** opencode 2 has no `todowrite` tool, so Claude's task list is not mirrored into one.
+- **Account failover and the plan-mode form** use opencode 2's `question` tool, which takes the same input as 1.x. Both are covered by offline tests only on 2.x, since neither can be triggered on demand.
+
 ---
 
 ## Models
 
-The plugin auto-registers the following, and they appear in the model picker with no extra config: Haiku 4.5, Sonnet 4.5/4.6/5, Opus 4.5/4.6/4.7/4.8/5 (plus two fast-mode Opus entries), Fable 5/5.1 and Mythos 5/5.1, each except Haiku carrying `low` / `medium` / `high` / `xhigh` / `max` reasoning variants.
+The plugin auto-registers the following, and they appear in the model picker with no extra config: Haiku 4.5, Sonnet 4.5/4.6/5, Opus 4.5/4.6/4.7/4.8/5/5.5 (plus three fast-mode Opus entries), Fable 5/5.1 and Mythos 5/5.1, each except Haiku carrying `low` / `medium` / `high` / `xhigh` / `max` reasoning variants.
 
 | ID | Display name | Context | Output | Reasoning variants | Price × |
 |---|---|---|---|---|---|
@@ -99,6 +125,8 @@ The plugin auto-registers the following, and they appear in the model picker wit
 | `claude-opus-4-8-fast` | Claude Opus 4.8 Fast | 1M | 128,000 | low/medium/high/xhigh/max | 10× |
 | `claude-opus-5` | Claude Opus 5 | 1M | 128,000 | low/medium/high/xhigh/max | 5× |
 | `claude-opus-5-fast` | Claude Opus 5 Fast | 1M | 128,000 | low/medium/high/xhigh/max | 10× |
+| `claude-opus-5-5` | Claude Opus 5.5 | 1M | 128,000 | low/medium/high/xhigh/max | 4× |
+| `claude-opus-5-5-fast` | Claude Opus 5.5 Fast | 1M | 128,000 | low/medium/high/xhigh/max | 8× |
 | `claude-fable-5` | Claude Fable 5 | 1M | 128,000 | low/medium/high/xhigh/max | 10× |
 | `claude-fable-5-1` | Claude Fable 5.1 | 1M | 128,000 | low/medium/high/xhigh/max | 10× |
 | `claude-mythos-5` | Claude Mythos 5 | 1M | 128,000 | low/medium/high/xhigh/max | 10× |
@@ -108,15 +136,17 @@ The plugin auto-registers the following, and they appear in the model picker wit
 
 Capabilities for every model: text + image input, text output, tool use, attachments. No temperature control, no PDF/audio/video, no interleaved streaming.
 
-**Price ×** is each model's per-token list price relative to Haiku, the cheapest model. It's derived exactly from Anthropic's published pricing (input and output ratios both come out the same: Haiku $1/$5 = 1×, Sonnet $3/$15 = 3×, Opus $5/$25 = 5×, Fable/Mythos 5 and 5.1 / Opus fast mode $10/$50 = 10×). So **Fable/Mythos 5 and 5.1, and fast-mode Opus, all cost 2× standard Opus 5**. The same multiplier is shown as a `(N×)` suffix on the display name in opencode's model picker, since opencode has no dedicated multiplier field. On a flat Max/Pro subscription it doubles as a rough guide to how fast each model drains your usage limit.
+**Price ×** is each model's per-token list price relative to Haiku, the cheapest model. It's derived exactly from Anthropic's published pricing (input and output ratios both come out the same: Haiku $1/$5 = 1×, Sonnet $3/$15 = 3×, Opus 5.5 $4/$20 = 4×, Opus $5/$25 = 5×, Opus 5.5 fast mode $8/$40 = 8×, Fable/Mythos 5 and 5.1 / Opus 5 and 4.8 fast mode $10/$50 = 10×). So **Fable/Mythos 5 and 5.1, and fast-mode Opus 5 and 4.8, all cost 2× standard Opus 5**, and fast mode is 2× the standard price on every Opus that offers it. The same multiplier is shown as a `(N×)` suffix on the display name in opencode's model picker, since opencode has no dedicated multiplier field. On a flat Max/Pro subscription it doubles as a rough guide to how fast each model drains your usage limit.
 
 Fable 5.1 and Mythos 5.1 keep the same $10/M input and $50/M output rates as 5.0, but cache reads cost $0.25/M instead of $1/M. Their cache-write rate remains $12.50/M.
 
-The model ID is passed straight through to `claude --model`, so anything Claude Code accepts works. The two `-fast` IDs are the one exception, described below.
+Opus 5.5 is priced below the Opus line at $4/M input and $20/M output, with cache writes at $5/M and cache reads at $0.20/M (0.05× input rather than the usual 0.1×). It needs **Claude Code 2.1.280 or newer**: the API rejects it from an older CLI with a 400 naming that floor, which shows up as a failed turn.
+
+The model ID is passed straight through to `claude --model`, so anything Claude Code accepts works. The three `-fast` IDs are the one exception, described below.
 
 ### Fast mode
 
-`claude-opus-5-fast` and `claude-opus-4-8-fast` run the same models at up to 2.5× the output tokens per second, at 2× the price ($10/M input, $50/M output, the 10× column). Pick them in the model selector like any other model.
+`claude-opus-5-5-fast`, `claude-opus-5-fast` and `claude-opus-4-8-fast` run the same models at up to 2.5× the output tokens per second, at 2× the price ($8/M input, $40/M output for Opus 5.5, the 8× column; $10/M input, $50/M output for Opus 5 and 4.8, the 10× column). Pick them in the model selector like any other model.
 
 The `-fast` suffix is this plugin's own marker, not a model name Anthropic serves. The plugin strips it and spawns `claude --model claude-opus-5 --settings '{"fastMode":true}'`, because that settings layer is the only way to opt a headless (`--print`) session into fast mode: there is no `--fast` flag, and the old `claude-opus-4-6-fast` style model names are retired. Requires Claude Code 2.1.220+; below that the plugin skips the opt-in and you get standard speed.
 
@@ -1214,7 +1244,7 @@ This plugin absorbs work from its forks directly, cherry-picked with the origina
 | [@galvani](https://github.com/galvani) (Jan Kozak) | Per-session working directory for `opencode serve`, so one server spawns each project's `claude` in the right place. Also found the stale `toolCallMap` re-emission three months before it was fixed here. | `9e02ce4`, `2238ed0` |
 | [@HeikoAtGitHub](https://github.com/HeikoAtGitHub) | Stopped sending `AGENTS.md` to the model twice (opencode already forwards it). Independently diagnosed the 5-minute proxy wall. | `25260a4`, `42f426d` |
 | [@bernardofortes](https://github.com/bernardofortes) (Bernardo Fortes) | `idleProcessTimeoutMs`, idle eviction of retained `claude` workers. | `a5f723a` |
-| [@broskees](https://github.com/broskees) (Joseph Roberts) | Task proxy default-on (PR #18), the abort `interrupt` so Esc really stops the CLI, the skill bridge, `task_batch` for concurrent subagents (and the measurement that the CLI serialises MCP calls), the undici 300 s diagnosis of the proxy wall, and the lifecycle release of proxied calls that made the `task` deadline unnecessary (PR #36). | PR #18, `68ed142`, PR #36 |
+| [@broskees](https://github.com/broskees) (Joseph Roberts) | Task proxy default-on (PR #18), the abort `interrupt` so Esc really stops the CLI, the skill bridge, `task_batch` for concurrent subagents (and the measurement that the CLI serialises MCP calls), the undici 300 s diagnosis of the proxy wall, the lifecycle release of proxied calls that made the `task` deadline unnecessary (PR #36), and Claude Opus 5.5 with its fast-mode entry (PR #43). | PR #18, `68ed142`, PR #36, PR #43 |
 | [@jknlsn](https://github.com/jknlsn) (Jake Nelson) | Per-tool proxy timeouts, subagent dispatch steering, the question proxy, the start watchdog respawn. | `84f3db9`, `94980a6`, `47501d0`, `ffefc24` |
 | [@CollieIsCute](https://github.com/CollieIsCute) (Collie Tsai) | The plan-mode approval bridge. | `8c5b583` |
 | [@flupkede](https://github.com/flupkede) | The compress proxy tool design and the AI-SDK v4 image-part fix. | `4ac319f`, `60a6e9a` |

package/dist/index.d.ts

@@ -1,5 +1,188 @@
 import { LanguageModelV3, LanguageModelV3CallOptions } from '@ai-sdk/provider';
 
+/**
+ * Hand-written structural mirror of the slice of opencode 2.x's plugin API
+ * this package touches. Same approach as `opencode-types.ts` for V1: no
+ * runtime or type dependency on `@opencode/plugin`, whose promise API pulls in
+ * an Effect release candidate we have no other use for.
+ *
+ * Read off the shipped `.d.ts` of `@opencode/plugin@2.0.11`, `@opencode/schema`
+ * and `@opencode/client` at the same version, not off the website, whose
+ * provider docs describe a metadata-only surface and omit the `aisdk` domain
+ * entirely. Every field here is one we read or write; everything else is left
+ * out on purpose so drift in an unused corner cannot break the build.
+ */
+
+interface V2Registration {
+    readonly dispose: () => Promise<void>;
+}
+/** `@opencode/schema/provider` `Provider.Info`, the fields we set. */
+interface V2ProviderInfo {
+    id: string;
+    name: string;
+    activation: "auto" | "enabled" | "disabled";
+    package: string;
+    settings?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+interface V2ModelVariant {
+    id: string;
+    settings?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+interface V2ModelCost {
+    input: number;
+    output: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+/** `@opencode/schema/model` `Model.Info`, every required field plus the optional ones we fill. */
+interface V2ModelInfo {
+    id: string;
+    modelID: string;
+    providerID: string;
+    name: string;
+    family?: string;
+    capabilities: {
+        tools: boolean;
+        input: string[];
+        output: string[];
+    };
+    variants: V2ModelVariant[];
+    time: {
+        released: number;
+    };
+    cost: V2ModelCost[];
+    status: "alpha" | "beta" | "deprecated" | "active";
+    enabled: boolean;
+    limit: {
+        context: number;
+        input?: number;
+        output: number;
+    };
+    settings?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    package?: string;
+}
+interface V2ProviderRecord {
+    readonly provider: V2ProviderInfo;
+    readonly models: ReadonlyMap<string, V2ModelInfo>;
+}
+interface V2ProviderEditor {
+    list(): readonly V2ProviderRecord[];
+    get(providerID: string): V2ProviderRecord | undefined;
+    add(input: {
+        info: V2ProviderInfo;
+        models: readonly V2ModelInfo[];
+    }): void;
+    update(providerID: string, update: (provider: V2ProviderInfo) => void): void;
+    remove(providerID: string): void;
+    readonly models: {
+        set(providerID: string, models: readonly V2ModelInfo[]): void;
+    };
+}
+interface V2AISDKSdkEvent {
+    readonly model: V2ModelInfo;
+    readonly package: string;
+    readonly options: Record<string, unknown>;
+    sdk?: unknown;
+}
+interface V2AISDKLanguageEvent {
+    readonly model: V2ModelInfo;
+    readonly sdk: unknown;
+    readonly options: Record<string, unknown>;
+    language?: LanguageModelV3;
+}
+type V2RequestKind = "primary" | "compaction" | "title" | "generate";
+interface V2ModelRequestEvent {
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly model: {
+        id: string;
+        providerID: string;
+        variant?: string;
+    };
+    readonly kind: V2RequestKind;
+    baseURL?: string;
+    headers: Record<string, string>;
+}
+interface V2ModelHookOptions {
+    readonly providerID?: string;
+}
+/** `@opencode/schema/prompt-input` `Prompt`: we only rewrite `text`. */
+type V2Prompt = {
+    text?: string;
+} & Record<string, unknown>;
+type V2Delivery = "steer" | "queue";
+interface V2CommandInvocation {
+    readonly sessionID: string;
+    readonly prompt: V2Prompt;
+    readonly delivery: V2Delivery;
+}
+interface V2CommandDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly execute: (input: V2CommandInvocation) => Promise<void>;
+}
+/** `session.deleted` is the one event this plugin acts on. */
+interface V2Event {
+    readonly type?: string;
+    readonly data?: {
+        readonly sessionID?: string;
+    } & Record<string, unknown>;
+}
+interface V2Context {
+    readonly app: {
+        readonly version: string;
+    };
+    readonly location: {
+        readonly directory: string;
+    };
+    readonly options: Record<string, unknown>;
+    readonly provider: {
+        transform(callback: (editor: V2ProviderEditor) => void): Promise<V2Registration>;
+    };
+    readonly aisdk: {
+        hook(name: "sdk", callback: (event: V2AISDKSdkEvent) => Promise<void> | void, options?: V2ModelHookOptions): Promise<V2Registration>;
+        hook(name: "language", callback: (event: V2AISDKLanguageEvent) => Promise<void> | void, options?: V2ModelHookOptions): Promise<V2Registration>;
+    };
+    readonly session: {
+        hook(name: "model.request", callback: (event: V2ModelRequestEvent) => Promise<void> | void, options?: V2ModelHookOptions): Promise<V2Registration>;
+        prompt?(input: V2Prompt & {
+            sessionID: string;
+            delivery?: V2Delivery;
+        }): Promise<unknown>;
+    };
+    readonly command?: {
+        transform(callback: (editor: {
+            add(definition: V2CommandDefinition): void;
+        }) => void): Promise<V2Registration>;
+    };
+    readonly event?: {
+        subscribe(options?: {
+            signal?: AbortSignal;
+        }): AsyncIterable<V2Event>;
+    };
+    readonly skill?: {
+        transform(callback: (editor: {
+            get(id: string): unknown;
+            add(skill: {
+                id: string;
+                name: string;
+                description?: string;
+                path: string;
+                content: string;
+            }): void;
+        }) => void): Promise<V2Registration>;
+    };
+}
+/** What `setup` may return: a cleanup run when opencode unloads the plugin. */
+type V2Cleanup = () => void | Promise<void>;
+
 type ModelID = string;
 type ProviderID = string;
 type OpenCodeModel = {
@@ -158,6 +341,14 @@ type LogMode = "silent" | "debug";
 interface ClaudeCodeConfig {
     provider: string;
     cliPath: string;
+    /**
+     * Which opencode major this model was created by, which decides the tool
+     * vocabulary its stream uses (src/host-tools.ts). Set only by the V2
+     * entrypoint's `sdk` hook; absent means opencode 1.x. Per model rather than
+     * per process on purpose: opencode 1.18 also calls a dual export's `setup`,
+     * so nothing process-wide may decide it.
+     */
+    hostApi?: "v1" | "v2";
     /** Drive interactive claude (subscription) instead of headless --print. */
     interactive?: boolean;
     /** Deprecated/no-op with interactive: Claude Code's TUI requires manual confirmation for bypassPermissions. */
@@ -258,6 +449,8 @@ type WebSearchRouting = "claude" | "disabled" | (string & {});
 type AccountFailoverMode = "ask" | "off";
 interface ClaudeCodeProviderSettings {
     cliPath?: string;
+    /** Internal: set by the opencode 2 entrypoint. See `ClaudeCodeConfig.hostApi`. */
+    hostApi?: "v1" | "v2";
     /** Drive interactive claude (subscription) instead of headless --print. */
     interactive?: boolean;
     /** Deprecated/no-op with interactive: Claude Code's TUI requires manual confirmation for bypassPermissions. */
@@ -724,6 +917,16 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
     get provider(): string;
     private toUsage;
     private toFinishReason;
+    /**
+     * Whether this call only names the session, which gets the synthetic stub
+     * rather than a `claude` spawn. opencode 1.x sends a title request with no
+     * tools, and that is the whole test there. opencode 2 sends its tool set
+     * along with it (measured on 2.0.11: `scope: "tools"`, agent `title`), so
+     * every new V2 session paid for a second `claude` process just to title
+     * itself; for a V2 model the request kind, carried as the `title` agent,
+     * decides instead.
+     */
+    private isTitleRequest;
     private requestScope;
     /**
      * Build the combined `--mcp-config` list and return both the list and the
@@ -842,7 +1045,14 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
     private synthesizeTitle;
     private doGenerateViaStream;
     doGenerate(options: LanguageModelV3CallOptions): Promise<Awaited<ReturnType<LanguageModelV3["doGenerate"]>>>;
+    private doGenerateForHost;
+    /**
+     * Tool parts leave in opencode 1.x's vocabulary; on opencode 2.x they are
+     * renamed at this one edge (src/host-tools.ts). On V1 the stream is
+     * returned untouched.
+     */
     doStream(options: LanguageModelV3CallOptions): Promise<Awaited<ReturnType<LanguageModelV3["doStream"]>>>;
+    private doStreamForHost;
 }
 
 interface BridgedMcp {
@@ -959,6 +1169,20 @@ declare function configModelsForProvider(providerModels: OpenCodeProvider["model
  * diagnostics never report another provider's options.
  */
 declare function claudeCodeProviders(providers: Record<string, DiagnosticsProviderEntry> | undefined): Record<string, DiagnosticsProviderEntry>;
+/**
+ * Record what every known agent asked for, so `resolveAgentModel` and
+ * `resolveAgentEffort` can answer at spawn time without the language model
+ * needing to see opencode's config.
+ *
+ * Runs BEFORE `expandAccountProviders`, which deletes the seed provider entry
+ * once it has expanded it: `defaultSubagentModel` has to be read while it is
+ * still there.
+ *
+ * Purely observational. It defines no agents and changes no agent's config;
+ * an agent this plugin never heard of is simply absent from the registry,
+ * which is what keeps opencode's built-ins out of the override path.
+ */
+declare function buildAgentRegistry(config: OpenCodeConfig): Promise<void>;
 /**
  * The opencode session id a `session.deleted` bus event names, or undefined
  * for any other event. opencode publishes `{ type, properties: { info } }`
@@ -968,6 +1192,7 @@ declare function extractDeletedSessionId(event: OpenCodeEvent | undefined): stri
 declare const _default: {
     id: string;
     server: OpenCodePlugin;
+    setup: (ctx: V2Context) => Promise<V2Cleanup>;
 };
 
-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 };
+export { type AgentRecord, type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, DEFAULT_PROXY_TOOL_NAMES, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, _resetPlanModeWarningForTests, bridgeOpencodeMcp, buildAgentRegistry, claudeCodeProviders, configModelsForProvider, createClaudeCode, _default as default, defaultModels, extractDeletedSessionId, getAgentRegistry, getDefaultSubagentModel, registerDoctorCommand, registerSideQuestionCommand, resolveAgentModel, warnIfPlanModeCannotExit };