opencode-kiro 0.5.0-beta.2 → 0.5.0-beta.4

package/README.md

@@ -1,12 +1,11 @@
 # opencode-kiro
 
-> ⚠️ **Experimental prerelease** — `0.5.0-beta.2` targets the **unreleased OpenCode v2**
+> ⚠️ **Experimental prerelease** — `0.5.0-beta.4` targets the **unreleased OpenCode v2**
 > plugin contract at a pinned snapshot. It does **not** work with OpenCode v1.
 > v1 users: stay on **`opencode-kiro@0.4.0`** (the `main` branch / npm `latest` line,
-> which remains the supported stable release). See
-> [RELEASE_NOTES_0.5.0-beta.2.md](./RELEASE_NOTES_0.5.0-beta.2.md) and
-> [PINNED_VERSIONS.md](./PINNED_VERSIONS.md) for exact pins and the tested OpenCode SHA.
-> No OpenCode v2 release date is known or claimed here.
+> which remains the supported stable release). See [CHANGELOG.md](./CHANGELOG.md) and
+> [docs/COMPATIBILITY.md](./docs/COMPATIBILITY.md) for exact pins and the tested
+> OpenCode SHA. No OpenCode v2 release date is known or claimed here.
 
 The ACP-compliant [Kiro](https://kiro.dev) plugin for [opencode](https://opencode.ai).
 
@@ -36,11 +35,11 @@ This prerelease is built and tested against **one pinned OpenCode v2 snapshot**:
 
 | Item | Value |
 |---|---|
-| Tested OpenCode commit (`upstream/v2`) | `1cf61593b5ec204619b3f679fe418fec10ca5934` |
-| `@opencode-ai/plugin` | `0.0.0-dev-17968` (exact) |
-| Package version | `0.5.0-beta.2` |
+| Tested OpenCode commit (`upstream/v2` head, 2026-08-29) | `8ba434b5973856b2f32b8cd3543e154b25c413e6` |
+| `@opencode-ai/plugin` | `0.0.0-dev-18686` (exact) |
+| Package version | `0.5.0-beta.4` |
 
-Full pin table and verification evidence: [PINNED_VERSIONS.md](./PINNED_VERSIONS.md).
+Full pin table and verification steps: [docs/COMPATIBILITY.md](./docs/COMPATIBILITY.md).
 There is no `engines.opencode` constraint — the v2 host has no stable semver yet; the
 tested SHA above is the compatibility target. Other v2 snapshots may or may not work.
 
@@ -55,21 +54,29 @@ tested SHA above is the compatibility target. Other v2 snapshots may or may not
 ## Install and configure
 
 **One config entry — that's the whole setup.** Add the package to the **`plugins`**
-array (plural) of your OpenCode config (`opencode.json`, project or global):
+array (plural) of your OpenCode config. That is any `opencode.json` or `opencode.jsonc`
+(or `.opencode/opencode.json`) found walking up from the project directory, or the
+global `~/.config/opencode/opencode.json`:
 
 ```json
 {
-  "plugins": ["opencode-kiro@0.5.0-beta.2"]
+  "plugins": ["opencode-kiro@0.5.0-beta.4"]
 }
 ```
 
-The object form pins the same version and leaves room for future options:
+> ⚠️ **Always pin the exact version, as above.** The host background-auto-refreshes
+> unpinned npm plugin packages to whatever the registry serves, so a bare `"opencode-kiro"`
+> spec can silently move you off the tested build. Use the exact
+> `opencode-kiro@0.5.0-beta.4` spec.
+
+The object form pins the same version and takes the plugin options described in
+[Plugin options](#plugin-options):
 
 ```json
 {
   "plugins": [
     {
-      "package": "opencode-kiro@0.5.0-beta.2",
+      "package": "opencode-kiro@0.5.0-beta.4",
       "options": {}
     }
   ]
@@ -78,10 +85,49 @@ The object form pins the same version and leaves room for future options:
 
 This loads the server entry (`./server` export): auth, model discovery, and provider
 ownership. The server plugin declares **`tui: true`**, so the host TUI **auto-loads the
-package's `./tui` entrypoint by itself** — the sidebar credits box and the composer
+package's `./tui` entrypoint by itself** — the sidebar credits box and the prompt footer
 credits chip appear with no further configuration. **No `cli.json` TUI entry is
-needed.** (The beta.1 two-file setup is obsolete: if you added `"opencode-kiro"` to
-your global `cli.json` `plugins` array for beta.1, remove it.)
+needed.**
+
+### Plugin options
+
+All options are optional; omit the `options` object entirely to get the defaults.
+
+| Option | Type | Default | Meaning |
+|---|---|---|---|
+| `agent` | string | `"opencode"` | kiro-cli agent name the provider runs under |
+| `mcpTimeout` | number | `45` | MCP tool-call timeout, in **minutes** |
+| `discover` | boolean | `true` | Set `false` to skip the setup-time model discovery kick-off when Kiro is already connected. Discovery triggered by login/credential events still runs. |
+
+```json
+{
+  "plugins": [
+    {
+      "package": "opencode-kiro@0.5.0-beta.4",
+      "options": {
+        "agent": "opencode",
+        "mcpTimeout": 45,
+        "discover": true
+      }
+    }
+  ]
+}
+```
+
+A value of the wrong type falls back to its default; unknown keys are ignored. The
+contract per option: `mcpTimeout` must be a positive number of minutes; zero, negative,
+or non-numeric values fall back to the default (`45`); an empty `agent` string falls
+back to `"opencode"`.
+
+> ⚠️ **Options work on the npm channel only.** The host passes `options` to plugins it
+> installed from npm (the `"package": "opencode-kiro@<version>"` form above). Local
+> `name@file:` tarball installs count as the npm channel, so options work there too.
+> Bundled or built-in plugin loads receive an empty options object, so **the defaults
+> always apply there** regardless of what you write in `options`.
+
+There is **no `cwd` option**. The working directory handed to kiro-cli is derived
+automatically from the OpenCode location the plugin is set up for, once per location;
+a user-supplied path could only be less accurate.
 
 ### Disabling
 
@@ -91,7 +137,7 @@ activates either:
 
 ```json
 {
-  "plugins": ["opencode-kiro@0.5.0-beta.2", "-kiro"]
+  "plugins": ["opencode-kiro@0.5.0-beta.4", "-kiro"]
 }
 ```
 
@@ -113,14 +159,14 @@ npm install && npm run build && npm pack
 ```
 
 ```json
-{ "plugins": ["opencode-kiro@file:/absolute/path/to/opencode-kiro-0.5.0-beta.2.tgz"] }
+{ "plugins": ["opencode-kiro@file:/absolute/path/to/opencode-kiro-0.5.0-beta.4.tgz"] }
 ```
 
 A bare path or bare `file:` spec is rejected at the tested SHA — the `name@file:` form
 is required. **Caveat (local `file:` installs only)**: the colon in the resulting
 install dirname defeats the host's OpenTUI loader shim, so the TUI surfaces render a
 contained per-slot error notice instead of the credits views (the rest of the TUI keeps
-working). Registry installs (`opencode-kiro@0.5.0-beta.2`) use colon-free paths and are
+working). Registry installs (`opencode-kiro@0.5.0-beta.4`) use colon-free paths and are
 fully green — this affects local tarball validation only.
 
 The host resolves entrypoints from the package `exports` (`./server` for the server
@@ -143,10 +189,8 @@ Select the **Kiro** integration, then the **Kiro CLI Login** method:
   Complete the login there; the plugin polls for up to 120 seconds and stores a minimal
   credential record when kiro-cli reports success.
 
-There is no configuration prompt during login anymore: the beta.1
-"Enable the Kiro credits sidebar?" consent select was removed (upstream deleted the
-prompts API in favor of forms — and the sidebar no longer needs consent-driven config,
-since `tui: true` auto-loads it).
+There is no configuration prompt during login; the sidebar and footer credits surfaces
+auto-load from the single `plugins` entry.
 
 If the flow times out, authenticate directly with kiro-cli (`kiro-cli login`) and run
 `opencode auth login` again; the fast path then completes immediately.
@@ -171,16 +215,11 @@ opencode models
 opencode run -m kiro/<exact-model-id> "hello"
 ```
 
-Effort-capable models expose their variants through OpenCode's model-variant selection.
-The chosen level reaches the SDK through the provider-settings path: OpenCode overlays
-the selected variant's `settings` onto the model's `settings`, hands them to the
-plugin's `aisdk` hook as `event.options`, and the plugin passes them verbatim to
-`createKiroAcp({ effort })`. That is why the plugin emits the SDK's own `effort` key
-(not `reasoningEffort`) — and why the SDK factory setting, not per-call provider
-options, is the working carrier: OpenCode builds per-call `providerOptions` only for
-the first-party `@ai-sdk/*` provider families, so `providerOptions.kiro.*` is never
-populated for an `aisdk:` package provider like this one. Kiro cannot disable thinking,
-so even the lowest level still produces a reasoning trail.
+Effort-capable models expose their variants through OpenCode's model-variant selection:
+pick the variant to choose a reasoning-effort level. The selected level is applied per
+request, and one provider instance (one kiro-cli process) serves every effort level, so
+switching effort does not start additional kiro-cli processes. Kiro cannot disable
+thinking, so even the lowest level still produces a reasoning trail.
 
 ## Credits in the TUI
 
@@ -191,7 +230,7 @@ plugin renders two surfaces:
 - a Kiro credits box in the sidebar (`sidebar.content` claim), showing the session's
   live credits total and unit
 - a compact credits chip in the prompt footer row beside the host cost/context
-  display (`prompt.footer.status` claim, v1 placement restored) with the same total
+  display (`prompt.footer.status` claim) with the same total
 
 Both are additive `append` claims — they compose with the host's built-in content and
 never replace it — and both pick up the active theme's text tokens (feature-detected;
@@ -203,11 +242,11 @@ The only configuration needed is the single `plugins` entry from
 [Install](#install-and-configure) — the TUI half auto-loads via `tui: true`.
 
 Durable credits are read straight from host message state (the host persists provider
-state on text end — fixed upstream since beta.1). While a turn is still streaming,
+state on text end). While a turn is still streaming,
 credits for just-ended text are picked up live through a transient overlay that works
 around a host reducer bug at the pinned snapshot (the live event path still drops
 provider state); once durable state arrives it is authoritative and nothing is
-double-counted. See the release notes for details.
+double-counted. See [CHANGELOG.md](./CHANGELOG.md) for details.
 
 ## Known limitations (prerelease)
 
@@ -215,7 +254,7 @@ double-counted. See the release notes for details.
   upstream, but the live `session.text.ended` reducer still drops provider state at
   the tested SHA, so in-turn updates come from the plugin's transient overlay
   (durable state always wins on reconcile). See
-  [Credits in the TUI](#credits-in-the-tui) and the release notes.
+  [Credits in the TUI](#credits-in-the-tui) and [CHANGELOG.md](./CHANGELOG.md).
 - **Credits render in the TUI only.** Every other cost surface (ACP clients, web,
   desktop, share pages, CLI cost output) shows $0.00 for Kiro sessions because the
   catalog declares Kiro's per-token `cost` as 0 (subscription-metered, no per-token
@@ -234,17 +273,30 @@ double-counted. See the release notes for details.
 ## How it works
 
 - **Auth (Integration + Credential)**: the plugin upserts the `kiro` integration with a
-  "Kiro CLI Login" OAuth method. `verifyAuth` from `kiro-acp-ai-provider` is the auth
-  authority (it delegates to kiro-cli); success is stored as a minimal
-  `Credential.OAuth` presence record.
+  "Kiro CLI Login" OAuth method. `verifyAuthAsync` from `kiro-acp-ai-provider` is the
+  auth authority (it delegates to kiro-cli without blocking the host's event loop);
+  success is stored as a minimal `Credential.OAuth` presence record. Starting a new
+  login while one is pending cancels the earlier attempt.
 - **Model discovery (catalog transform)**: after login (and on later login events) the
   plugin runs `listModels()` outside the transform, then applies the validated capture
   via a catalog transform and reload — exact ID matching, catalog metadata preserved,
   effort variants projected, fail-open on any discovery error.
-- **Provider ownership (AISDK hook)**: the plugin's SDK hook always constructs the
-  provider from `kiro-acp-ai-provider` with the plugin-supplied options and sets it as
-  the event's SDK, so the Kiro provider is always plugin-owned. The options relay each
-  model's context window into the SDK's `contextWindows` map keyed by model ID.
+- **Provider ownership (AISDK hooks)**: the plugin's `sdk` hook constructs the provider
+  from `kiro-acp-ai-provider` with the plugin-supplied settings (identifying itself to
+  kiro-cli as `opencode-kiro`) and sets it as the event's SDK, so the Kiro provider is
+  always plugin-owned; one instance is cached per distinct settings and shared across
+  effort variants. The `language` hook applies the selected effort per request. The
+  settings relay each model's context window into the SDK's `contextWindows` map keyed
+  by model ID.
+- **Effort carrier (why SDK settings, not `providerOptions`)**: OpenCode overlays the
+  selected variant's `settings` onto the model's `settings` and hands them to the
+  plugin's `aisdk` hooks as `event.options`; the `language` hook reads
+  `event.options.effort` and passes it to the shared provider as a per-model override
+  (`languageModel(id, { effort })`). The plugin emits the SDK's own `effort` key (not
+  `reasoningEffort`), and the settings path is the working carrier because OpenCode
+  builds per-call `providerOptions` only for the first-party `@ai-sdk/*` provider
+  families - `providerOptions.kiro.*` is never populated for an `aisdk:` package
+  provider like this one.
 - **Session affinity & reset (in-SDK)**: the SDK keys kiro-cli sessions off OpenCode's
   session affinity, isolates tool-less utility calls on an ephemeral session, detects
   prompt-history divergence, and starts a fresh kiro session when needed.
@@ -264,7 +316,7 @@ double-counted. See the release notes for details.
 | `kiro` provider not showing in `opencode models` | Run `opencode auth login` first: models are discovered after auth. If the loaded catalog lacks a `kiro` entry, the plugin self-registers a minimal fallback during discovery. |
 | Path install rejected (`must export id`) | Use the `name@file:<absolute tarball path>` form after `npm run build && npm pack` in your checkout (both entry modules export ids). |
 | Provider visible but runs fail | The provider can be selectable before any credential exists. Run `opencode auth login` first. |
-| Worked yesterday, broken today | This prerelease targets one pinned OpenCode snapshot (see [Compatibility](#compatibility)). If your OpenCode build moved past the tested SHA, the v2 plugin surface may have changed underneath it. |
+| Worked yesterday, broken today | This prerelease targets one pinned OpenCode snapshot (see [Compatibility](#compatibility)). If your OpenCode build moved past the tested SHA, the v2 plugin surface may have changed underneath it. The other cause is an **unpinned** `plugins` entry (a bare `"opencode-kiro"`): the host background-auto-refreshes unpinned npm plugin packages, so the plugin itself can move off the tested build without you changing anything — pin the exact `opencode-kiro@0.5.0-beta.4` spec. |
 
 ## Legacy: v1 / OpenCode v1 users (`0.4.0`)
 
@@ -273,7 +325,7 @@ v1 (`opencode >= 1.16.0`). It uses the v1 contract throughout: singular `plugin`
 arrays in `opencode.json` and `tui.json`, the `opencode plugin opencode-kiro`
 installer, and `part.metadata.kiro` credits. Its full documentation is the README at
 the [`v0.4.0` tag](https://github.com/NachoFLizaur/opencode-kiro/tree/v0.4.0)
-(equivalently, `main`). Do not install `0.5.0-beta.2` into an OpenCode v1 setup.
+(equivalently, `main`). Do not install `0.5.0-beta.4` into an OpenCode v1 setup.
 
 ## Development
 

package/dist/server.js

@@ -1,3 +1,6 @@
+// package.json
+var version = "0.5.0-beta.4";
+
 // src/server/auth.ts
 var KIRO_INTEGRATION_ID = "kiro";
 var KIRO_INTEGRATION_NAME = "Kiro";
@@ -8,7 +11,9 @@ var POLL_INTERVAL_MS = 2e3;
 var MAX_WAIT_MS = 12e4;
 var NOT_INSTALLED_MESSAGE = "kiro-cli is not installed. Install it from https://kiro.dev/docs/cli/";
 var TIMEOUT_MESSAGE = "Kiro authentication timed out. Run `kiro-cli login` manually, then re-run `opencode auth login`.";
-var LOGIN_INSTRUCTIONS = "Complete Kiro authentication in the browser window that just opened. Waiting for login...";
+var CANCELLED_MESSAGE = "Kiro authentication was cancelled.";
+var SUPERSEDED_MESSAGE = "Kiro CLI login superseded by a new login attempt.";
+var LOGIN_INSTRUCTIONS = "Complete Kiro authentication in the browser window that just opened (if no browser opened, run `kiro-cli login` in another terminal). Waiting for login...";
 var ALREADY_AUTHENTICATED_INSTRUCTIONS = "Already authenticated with Kiro CLI.";
 function createAuthResources() {
   return {
@@ -18,7 +23,7 @@ function createAuthResources() {
     disposeRegistration: void 0
   };
 }
-function releaseLoginResources(resources) {
+function releaseLoginResources(resources, reason) {
   if (resources.pollTimer !== void 0) {
     clearTimeout(resources.pollTimer);
     resources.pollTimer = void 0;
@@ -30,7 +35,7 @@ function releaseLoginResources(resources) {
   if (resources.cancelPoll !== void 0) {
     const cancel = resources.cancelPoll;
     resources.cancelPoll = void 0;
-    cancel();
+    cancel(reason);
   }
 }
 function kiroCredential() {
@@ -45,12 +50,15 @@ function kiroCredential() {
 function pollForLogin(verifyAuth, resources) {
   return new Promise((resolve, reject) => {
     const start = Date.now();
-    resources.cancelPoll = () => {
-      reject(new Error("Kiro authentication was cancelled."));
+    const cancel = (reason) => {
+      reject(reason ?? new Error(CANCELLED_MESSAGE));
     };
-    const tick = () => {
+    resources.cancelPoll = cancel;
+    const tick = async () => {
       resources.pollTimer = void 0;
-      if (verifyAuth().authenticated) {
+      const status = await verifyAuth();
+      if (resources.cancelPoll !== cancel) return;
+      if (status.authenticated) {
         resources.cancelPoll = void 0;
         releaseLoginResources(resources);
         resolve(kiroCredential());
@@ -62,14 +70,19 @@ function pollForLogin(verifyAuth, resources) {
         reject(new Error(TIMEOUT_MESSAGE));
         return;
       }
-      resources.pollTimer = setTimeout(tick, POLL_INTERVAL_MS);
+      resources.pollTimer = setTimeout(() => {
+        void tick();
+      }, POLL_INTERVAL_MS);
     };
-    resources.pollTimer = setTimeout(tick, POLL_INTERVAL_MS);
+    resources.pollTimer = setTimeout(() => {
+      void tick();
+    }, POLL_INTERVAL_MS);
   });
 }
 async function authorize(resources) {
-  const { verifyAuth } = await import("kiro-acp-ai-provider");
-  const status = verifyAuth();
+  const { verifyAuthAsync } = await import("kiro-acp-ai-provider");
+  const { execFile } = await import("child_process");
+  const status = await verifyAuthAsync();
   if (!status.installed) throw new Error(NOT_INSTALLED_MESSAGE);
   if (status.authenticated) {
     return {
@@ -79,16 +92,16 @@ async function authorize(resources) {
       callback: Promise.resolve(kiroCredential())
     };
   }
-  const { execFile } = await import("child_process");
+  if (resources.cancelPoll !== void 0) {
+    releaseLoginResources(resources, new Error(SUPERSEDED_MESSAGE));
+  }
   resources.child = execFile("kiro-cli", ["login"], {
     shell: process.platform === "win32"
   });
-  return {
-    url: KIRO_DOCS_URL,
-    instructions: LOGIN_INSTRUCTIONS,
-    mode: "auto",
-    callback: pollForLogin(verifyAuth, resources)
-  };
+  const callback = pollForLogin(verifyAuthAsync, resources);
+  callback.catch(() => {
+  });
+  return { url: KIRO_DOCS_URL, instructions: LOGIN_INSTRUCTIONS, mode: "auto", callback };
 }
 async function registerAuth(context, resources) {
   const registration = await context.integration.transform((draft) => {
@@ -184,9 +197,10 @@ function applyCatalogSnapshot(draft, state) {
     provider.settings = {
       ...provider.settings,
       cwd: state.cwd,
-      agent: "opencode",
+      agent: state.options.agent,
       trustAllTools: true,
-      mcpTimeout: 45,
+      // intentionally not exposed as a plugin option
+      mcpTimeout: state.options.mcpTimeout,
       contextWindows
     };
   });
@@ -221,15 +235,26 @@ function createDiscover(context, state) {
     return run;
   };
 }
+function isKiroCredentialEvent(event) {
+  const type = event.type;
+  if (type === "integration.connection.updated") {
+    const data = event.data;
+    return data?.integrationID === KIRO_INTEGRATION_ID;
+  }
+  if (event.type === "credential.switched") {
+    return asString(event.data.integrationID) === KIRO_INTEGRATION_ID;
+  }
+  return type === "credential.updated";
+}
 async function consumeEvents(iterator, discover) {
   try {
     while (true) {
       const result = await iterator.next();
       if (result.done) return;
       const event = result.value;
-      if (event.type === "integration.connection.updated" && event.data.integrationID === KIRO_INTEGRATION_ID) {
+      if (isKiroCredentialEvent(event)) {
         try {
-          await discover("connection-updated");
+          await discover(event.type);
         } catch {
         }
       }
@@ -237,10 +262,11 @@ async function consumeEvents(iterator, discover) {
   } catch {
   }
 }
-async function registerDiscovery(context, resources) {
+async function registerDiscovery(context, resources, options) {
   const { location } = await context.integration.list();
   const state = {
     cwd: location.directory,
+    options,
     snapshot: void 0,
     generation: 0,
     inflight: void 0
@@ -254,7 +280,7 @@ async function registerDiscovery(context, resources) {
   const iterator = context.event.subscribe()[Symbol.asyncIterator]();
   resources.eventIterator = iterator;
   resources.eventTask = consumeEvents(iterator, discover);
-  if (await context.integration.connection.active(KIRO_INTEGRATION_ID)) {
+  if (options.discover && await context.integration.connection.active(KIRO_INTEGRATION_ID)) {
     void discover("setup").catch(() => {
     });
   }
@@ -288,16 +314,38 @@ async function registerDiscovery(context, resources) {
 
 // src/server/aisdk.ts
 var KIRO_SDK_PACKAGE = "kiro-acp-ai-provider";
+var CLIENT_INFO = { name: "opencode-kiro", version };
 function createAisdkResources() {
   return {
     ownedSdks: /* @__PURE__ */ new Set(),
     cache: /* @__PURE__ */ new Map(),
-    disposeHook: void 0
+    disposeHooks: []
   };
 }
 function isKiroPackage(pkg) {
   return pkg === KIRO_SDK_PACKAGE || pkg === `aisdk:${KIRO_SDK_PACKAGE}`;
 }
+var SETTINGS_ALLOWLIST = [
+  "cwd",
+  "model",
+  "agent",
+  "trustAllTools",
+  "agentPrompt",
+  "env",
+  "clientInfo",
+  "sessionId",
+  "contextWindow",
+  "contextWindows",
+  "mcpTimeout"
+];
+function sanitizeSettings(options) {
+  const settings = {};
+  for (const key of SETTINGS_ALLOWLIST) {
+    const value = options[key];
+    if (value !== void 0) settings[key] = value;
+  }
+  return settings;
+}
 function isJsonSafe(value) {
   if (value === null) return true;
   const kind = typeof value;
@@ -318,19 +366,20 @@ function stableStringify(value) {
   }
   return JSON.stringify(value);
 }
-function stableOptionsKey(options) {
-  return isJsonSafe(options) ? stableStringify(options) : void 0;
+function stableSettingsKey(settings) {
+  return isJsonSafe(settings) ? stableStringify(settings) : void 0;
 }
 async function registerAisdkHook(context, resources) {
-  const registration = await context.aisdk.hook(
+  const sdkRegistration = await context.aisdk.hook(
     "sdk",
     async (event) => {
       if (!isKiroPackage(event.package)) return;
-      const { createKiroAcp } = await import("kiro-acp-ai-provider");
-      const key = stableOptionsKey(event.options);
+      const settings = { ...sanitizeSettings(event.options), clientInfo: CLIENT_INFO };
+      const key = stableSettingsKey(settings);
       let sdk = key === void 0 ? void 0 : resources.cache.get(key);
       if (sdk === void 0) {
-        sdk = createKiroAcp(event.options);
+        const { createKiroAcp } = await import("kiro-acp-ai-provider");
+        sdk = createKiroAcp(settings);
         resources.ownedSdks.add(sdk);
         if (key !== void 0) resources.cache.set(key, sdk);
       }
@@ -338,14 +387,34 @@ async function registerAisdkHook(context, resources) {
     },
     { providerID: KIRO_PROVIDER_ID }
   );
-  resources.disposeHook = registration.dispose;
+  resources.disposeHooks.push(sdkRegistration.dispose);
+  let languageRegistration;
+  try {
+    languageRegistration = await context.aisdk.hook(
+      "language",
+      async (event) => {
+        const effort = typeof event.options.effort === "string" ? event.options.effort : void 0;
+        const overrides = effort === void 0 ? void 0 : { effort };
+        event.language = event.sdk.languageModel(String(event.model.modelID), overrides);
+      },
+      { providerID: KIRO_PROVIDER_ID }
+    );
+  } catch (error) {
+    await sdkRegistration.dispose().catch(() => {
+    });
+    resources.disposeHooks.length = 0;
+    throw error;
+  }
+  resources.disposeHooks.push(languageRegistration.dispose);
   return async () => {
     const errors = [];
-    resources.disposeHook = void 0;
-    try {
-      await registration.dispose();
-    } catch (error) {
-      errors.push(error);
+    const disposeHooks = resources.disposeHooks.splice(0);
+    for (const dispose of disposeHooks) {
+      try {
+        await dispose();
+      } catch (error) {
+        errors.push(error);
+      }
     }
     const owned = Array.from(resources.ownedSdks);
     resources.ownedSdks.clear();
@@ -394,17 +463,25 @@ function buildCleanup(state) {
 }
 
 // src/server.ts
+function resolveOptions(raw) {
+  return {
+    agent: typeof raw.agent === "string" && raw.agent !== "" ? raw.agent : "opencode",
+    mcpTimeout: typeof raw.mcpTimeout === "number" && Number.isFinite(raw.mcpTimeout) && raw.mcpTimeout > 0 ? raw.mcpTimeout : 45,
+    discover: typeof raw.discover === "boolean" ? raw.discover : true
+  };
+}
 var plugin = {
   id: "kiro",
-  // tui: true (dist/promise/plugin.d.ts:40) — the host auto-loads this
+  // tui: true (dist/promise/plugin.d.ts) — the host auto-loads this
   // package's `./tui` entrypoint for npm-channel installs (single config entry)
   tui: true,
   async setup(context) {
+    const options = resolveOptions(context.options ?? {});
     const state = createServerState();
     const cleanup = buildCleanup(state);
     try {
       state.disposers.push(await registerAuth(context, state.auth));
-      state.disposers.push(await registerDiscovery(context, state.discovery));
+      state.disposers.push(await registerDiscovery(context, state.discovery, options));
       state.disposers.push(await registerAisdkHook(context, state.aisdk));
     } catch (error) {
       await Promise.resolve(cleanup()).catch(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-kiro",
-  "version": "0.5.0-beta.2",
+  "version": "0.5.0-beta.4",
   "description": "The ACP-compliant Kiro plugin for opencode: auth via the official kiro-cli login, the live Kiro model lineup through the Agent Client Protocol, and TUI credits display",
   "license": "MIT",
   "author": "Nacho F. Lizaur (https://github.com/NachoFLizaur)",
@@ -38,16 +38,19 @@
   "engines": {
     "node": ">=20"
   },
+  "publishConfig": {
+    "tag": "beta"
+  },
   "peerDependencies": {
-    "@opencode-ai/plugin": "0.0.0-dev-17968"
+    "@opencode-ai/plugin": "0.0.0-dev-18686"
   },
   "dependencies": {
-    "@opentui/solid": "0.5.7",
-    "kiro-acp-ai-provider": "3.0.0",
+    "@opentui/solid": "0.5.9",
+    "kiro-acp-ai-provider": "3.1.0",
     "solid-js": "1.9.12"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "0.0.0-dev-17968",
+    "@opencode-ai/plugin": "0.0.0-dev-18686",
     "@types/node": "^20.19.42",
     "tsup": "^8.0.0",
     "typescript": "^5.7.0",