@khalilgharbaoui/opencode-claude-code-plugin 0.25.0 → 0.26.1

package/README.md

@@ -80,6 +80,32 @@ 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

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 };