opencode-kiro 0.5.0-beta.3 → 0.5.0-beta.5

package/README.md

@@ -1,12 +1,11 @@
 # opencode-kiro
 
-> ⚠️ **Experimental prerelease** — `0.5.0-beta.3` targets the **unreleased OpenCode v2**
+> ⚠️ **Experimental prerelease** — `0.5.0-beta.5` 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.3.md](./RELEASE_NOTES_0.5.0-beta.3.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).
 
@@ -19,7 +18,7 @@ The plugin supplies:
   minimal self-registration fallback when the catalog lacks a `kiro` entry
 - **Provider ownership**: an AISDK hook constructs the provider from
   [`kiro-acp-ai-provider`](https://www.npmjs.com/package/kiro-acp-ai-provider) with the
-  right options (`cwd`, `agent`, `trustAllTools`, `mcpTimeout`, `contextWindows`)
+  right options (`cwd`, `agent`, `trustAllTools`, `mcpTimeout`, `stall`, `contextWindows`)
 - **TUI credits display**: a live Kiro credits box in the sidebar and a compact
   credits chip in the prompt footer row beside the host cost/context display, both
   styled with the host's active theme tokens — auto-loaded from the same single
@@ -36,11 +35,11 @@ This prerelease is built and tested against **one pinned OpenCode v2 snapshot**:
 
 | Item | Value |
 |---|---|
-| Tested OpenCode commit (`upstream/v2`) | `8ba434b5973856b2f32b8cd3543e154b25c413e6` |
+| 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.3` |
+| Package version | `0.5.0-beta.5` |
 
-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,26 +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.3"]
+  "plugins": ["opencode-kiro@0.5.0-beta.5"]
 }
 ```
 
-> ⚠️ **Always pin the exact version, as above.** The host now background-auto-refreshes
-> UNPINNED npm plugin packages to whatever the registry serves — a bare `"opencode-kiro"`
+> ⚠️ **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.3` spec.
+> `opencode-kiro@0.5.0-beta.5` spec.
 
-The object form pins the same version and leaves room for future options:
+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.3",
+      "package": "opencode-kiro@0.5.0-beta.5",
       "options": {}
     }
   ]
@@ -85,8 +87,95 @@ This loads the server entry (`./server` export): auth, model discovery, and prov
 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 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. |
+| `stall` | object | `{ "afterMs": 10000, "live": "reasoning" }` | Stall notice for turns with no model output. `afterMs` is the silence threshold in milliseconds (`0` disables the notice entirely); `live` is `"reasoning"` (live notice in the transcript, visible only when thinking is shown) or `"off"` (summary line only). See [Slow responses](#slow-responses). |
+
+```json
+{
+  "plugins": [
+    {
+      "package": "opencode-kiro@0.5.0-beta.5",
+      "options": {
+        "agent": "opencode",
+        "mcpTimeout": 45,
+        "discover": true,
+        "stall": { "afterMs": 10000, "live": "reasoning" }
+      }
+    }
+  ]
+}
+```
+
+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"`. `stall` must be an object; both members are optional and each is
+checked on its own - `afterMs` must be a number of milliseconds of `0` or more, `live`
+must be exactly `"off"` or `"reasoning"`. An invalid member is dropped while the valid
+one is kept, and an object with nothing valid left counts as omitted (defaults apply).
+
+> ⚠️ **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.
+
+### Slow responses
+
+When the Kiro backend is overloaded, kiro-cli retries the request on its own and the
+turn produces no output for a while - a spinner with nothing behind it. The `stall`
+option controls how the plugin surfaces that wait:
+
+- **By default** (`afterMs: 10000`, `live: "reasoning"`): after 10 seconds without
+  model output, a short reasoning block appears in the transcript, along the lines of
+  *"Kiro: no output for 10s - the model may be overloaded and kiro-cli is retrying."*
+  It refreshes every further 10 seconds while the silence lasts and closes with
+  *"output resumed after Ns"* once real output arrives, or *"turn ended after Ns
+  without further output"* if the turn ends first. The block is separate from the
+  model's own reasoning and text; the answer is unaffected. Because the live notice is
+  rendered as a reasoning block, the TUI shows it **collapsed by default (click to
+  expand)**, and only when the TUI shows thinking (`session.thinking: "show"` in
+  `cli.json`); with reasoning hidden the notice is hidden too, while the
+  after-the-turn summary line described next still appears.
+- **After the turn**, the credits box in the sidebar and the credits chip in the prompt
+  footer add one line, `last turn stalled Ns (Reason)`, for as long as the last
+  completed turn is the one that stalled. The parenthesized reason (for example
+  `ModelOverloaded`) is taken, best-effort, from the last error kiro-cli wrote to its
+  own log during that turn; when no such line is available the summary shows the
+  duration alone.
+- **`live: "off"`** hides the live transcript block; the after-the-turn summary line
+  still appears.
+- **`afterMs: 0`** disables the feature entirely: no transcript block and no summary.
+  Any other value changes the silence threshold (in milliseconds).
+
+```json
+{
+  "plugins": [
+    {
+      "package": "opencode-kiro@0.5.0-beta.5",
+      "options": { "stall": { "live": "off" } }
+    }
+  ]
+}
+```
+
+The notice is informational only; the plugin never cancels or retries the turn itself.
+Requires `kiro-acp-ai-provider` 3.2.0 (see [docs/COMPATIBILITY.md](./docs/COMPATIBILITY.md)
+for the pinned SDK version).
 
 ### Disabling
 
@@ -96,7 +185,7 @@ activates either:
 
 ```json
 {
-  "plugins": ["opencode-kiro@0.5.0-beta.3", "-kiro"]
+  "plugins": ["opencode-kiro@0.5.0-beta.5", "-kiro"]
 }
 ```
 
@@ -118,14 +207,14 @@ npm install && npm run build && npm pack
 ```
 
 ```json
-{ "plugins": ["opencode-kiro@file:/absolute/path/to/opencode-kiro-0.5.0-beta.3.tgz"] }
+{ "plugins": ["opencode-kiro@file:/absolute/path/to/opencode-kiro-0.5.0-beta.5.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.3`) use colon-free paths and are
+working). Registry installs (`opencode-kiro@0.5.0-beta.5`) 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
@@ -148,10 +237,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.
@@ -169,6 +256,14 @@ sets the model's base effort. A discovery failure or duplicate runtime ID leaves
 catalog unchanged (fail-open). If the loaded catalog has no `kiro` provider at all, the
 plugin self-registers a minimal fallback entry so discovered models remain usable.
 
+Discovery is bounded and self-healing: a probe that gets no answer from kiro-cli within
+60 seconds is treated as failed, and a failed probe is retried while Kiro stays
+connected (after 5, 20, and 60 seconds) before giving up until the next login or
+credential change. Each failure is reported on the server's stderr with an
+`[opencode-kiro]` prefix - visible in `opencode serve` output, or from the TUI with
+`OPENCODE_PRINT_LOGS=1` - so a missing model list is never silent. A login triggers one
+probe per project location, however many credential events the host emits for it.
+
 List the resulting models with:
 
 ```bash
@@ -176,16 +271,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
 
@@ -196,7 +286,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;
@@ -208,11 +298,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)
 
@@ -220,7 +310,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
@@ -239,17 +329,33 @@ 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.
+  via a catalog transform and reload - exact ID matching, catalog metadata preserved,
+  effort variants projected, fail-open on any discovery error. Each probe runs under a
+  generation token: a logout, a newer probe, or a retry bumps the generation, and a
+  result that arrives for an older generation is discarded instead of overwriting the
+  catalog.
+- **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.
@@ -257,6 +363,11 @@ double-counted. See the release notes for details.
   metadata; OpenCode persists them key-unwrapped on message part state
   (`part.state.credits`, `part.state.creditsUnit`), and the TUI plugin sums them per
   assistant message (deduped across parts).
+- **Stall status**: when a turn stalled, the SDK attaches `status`
+  (`{ stalledMs, hint? }`) to the same provider metadata; the TUI plugin reads it from
+  `part.state.status` on the same path as credits and renders the one-line summary
+  described in [Slow responses](#slow-responses). The live transcript notice is a
+  reasoning fragment emitted by the SDK itself, so it needs no TUI support.
 
 ## Troubleshooting
 
@@ -266,10 +377,11 @@ double-counted. See the release notes for details.
 | Auth times out after ~120s | Complete the browser login faster, or run `kiro-cli login` yourself, then re-run `opencode auth login` (fast path). |
 | No credits line / credits stay 0 | Credits appear after the first **completed** kiro turn; cancelled turns and turns without usage state contribute nothing. Check the plugin is active (no stray `"-kiro"` directive — note that directive residue can persist on a reused data dir). |
 | Credits surfaces never appear | The TUI half auto-loads from the server `plugins` entry via `tui: true` — no separate TUI config exists. If the box/chip are missing, the server plugin itself is not loading (check your `plugins` entry and restart opencode). For local `name@file:` tarball installs, a contained per-slot error notice instead of the credits views is the known colon-path caveat; use a registry install. |
-| `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. |
+| `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. If you are logged in and the list (or the effort variants) is still missing, the discovery probe may have failed or timed out: it is retried automatically for a few minutes, and each attempt is reported on the server's stderr with an `[opencode-kiro]` prefix (`opencode serve`, or `OPENCODE_PRINT_LOGS=1` with the TUI). Logging in again starts a fresh probe. |
+| Spinner with no output for a long time | The Kiro backend is likely overloaded and kiro-cli is retrying the request. With the default `stall` option a collapsed reasoning block saying so appears in the transcript after 10 seconds (only when thinking is shown; see [Slow responses](#slow-responses)), and the credits box/chip show `last turn stalled Ns (Reason)` once the turn ends. If no such block appears and the model list or effort variants are also missing, discovery may be the problem instead: watch the server log (`OPENCODE_PRINT_LOGS=1`, or run under `opencode serve`) for `[opencode-kiro]` lines. kiro-cli's own errors are in its log under your temp directory (`kiro-log/kiro-chat.log`). |
 | 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.5` spec. |
 
 ## Legacy: v1 / OpenCode v1 users (`0.4.0`)
 
@@ -278,7 +390,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.3` into an OpenCode v1 setup.
+(equivalently, `main`). Do not install `0.5.0-beta.5` into an OpenCode v1 setup.
 
 ## Development
 

package/dist/chunk-LRAGM3PR.js

@@ -0,0 +1,103 @@
+// src/tui/credits.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readCreditState(state) {
+  if (!isRecord(state)) return void 0;
+  if (typeof state.credits !== "number" || !Number.isFinite(state.credits)) return void 0;
+  return {
+    credits: state.credits,
+    unit: typeof state.creditsUnit === "string" && state.creditsUnit.length > 0 ? state.creditsUnit : void 0
+  };
+}
+function readStallStatus(status) {
+  if (!isRecord(status)) return void 0;
+  const { stalledMs, hint } = status;
+  if (typeof stalledMs !== "number" || !Number.isFinite(stalledMs) || stalledMs <= 0) return void 0;
+  return typeof hint === "string" && hint.length > 0 ? { stalledMs, hint } : { stalledMs };
+}
+function readPartMetadata(state) {
+  if (!isRecord(state)) return void 0;
+  const credits = readCreditState(state);
+  const status = readStallStatus(state.status);
+  if (!credits && !status) return void 0;
+  return { ...credits, ...status ? { status } : {} };
+}
+function carrierState(part) {
+  if (!isRecord(part)) return void 0;
+  if (part.type !== "text" && part.type !== "reasoning") return void 0;
+  return part.state;
+}
+function readPartCredits(part) {
+  return readCreditState(carrierState(part));
+}
+function readPartStatus(part) {
+  const state = carrierState(part);
+  return isRecord(state) ? readStallStatus(state.status) : void 0;
+}
+function messageCredits(parts) {
+  const carriers = parts.map(readPartCredits).filter((value) => value !== void 0);
+  const last = carriers.at(-1);
+  if (!last) return void 0;
+  return {
+    credits: last.credits,
+    unit: last.unit ?? carriers.findLast((carrier) => carrier.unit !== void 0)?.unit
+  };
+}
+function messageStatus(parts) {
+  return parts.map(readPartStatus).findLast((value) => value !== void 0);
+}
+function messageMetadata(parts) {
+  const credits = messageCredits(parts);
+  const status = messageStatus(parts);
+  if (!credits && !status) return void 0;
+  return { ...credits, ...status ? { status } : {} };
+}
+function addMessageMetadata(acc, hit) {
+  if (!hit) return acc;
+  return {
+    total: acc.total + (hit.credits ?? 0),
+    unit: hit.unit ?? acc.unit,
+    present: true,
+    ...hit.status ? { status: hit.status } : {}
+  };
+}
+var creditsAmount = new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 });
+function formatCredits(value, unit) {
+  const amount = creditsAmount.format(Number.isFinite(value) ? value : 0);
+  if (!unit) return amount;
+  const label = value === 1 || unit.endsWith("s") ? unit : `${unit}s`;
+  return `${amount} ${label}`;
+}
+var ERROR_SUFFIX = "Error";
+function stallReason(hint) {
+  if (typeof hint !== "string" || hint.length === 0) return void 0;
+  const token = /\bkind:\s*([A-Z][A-Za-z0-9]*)/.exec(hint)?.[1] ?? /\b([A-Z][A-Za-z0-9]*Error)\b/.exec(hint)?.[1];
+  if (!token) return void 0;
+  const reason = token.endsWith(ERROR_SUFFIX) ? token.slice(0, -ERROR_SUFFIX.length) : token;
+  return reason.length > 0 ? reason : void 0;
+}
+function formatStallSummary(status) {
+  const valid = readStallStatus(status);
+  if (!valid) return void 0;
+  const seconds = Math.max(1, Math.round(valid.stalledMs / 1e3));
+  const reason = stallReason(valid.hint);
+  return reason ? `last turn stalled ${seconds}s (${reason})` : `last turn stalled ${seconds}s`;
+}
+var STALL_SEPARATOR = " \xB7 ";
+function creditsChipText(credits) {
+  if (!credits.present) return "";
+  const total = formatCredits(credits.total, credits.unit);
+  const stall = formatStallSummary(credits.status);
+  return stall ? `${total}${STALL_SEPARATOR}${stall}` : total;
+}
+var money = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" });
+
+export {
+  readPartMetadata,
+  messageMetadata,
+  addMessageMetadata,
+  formatCredits,
+  formatStallSummary,
+  creditsChipText
+};

package/dist/{credits-box-view-GLFJSV6M.js → credits-box-view-2OGZPIW6.js}

@@ -1,6 +1,7 @@
 import {
-  formatCredits
-} from "./chunk-M7OUVABX.js";
+  formatCredits,
+  formatStallSummary
+} from "./chunk-LRAGM3PR.js";
 
 // src/tui/credits-box-view.ts
 import { createElement, insert, insertNode, setProp } from "@opentui/solid";
@@ -16,6 +17,10 @@ function createCreditsBoxView(credits, tokens) {
     root,
     plainLine(() => current().present ? formatCredits(current().total, current().unit) : "", tokens?.subdued)
   );
+  insertNode(
+    root,
+    plainLine(() => current().present ? formatStallSummary(current().status) ?? "" : "", tokens?.subdued)
+  );
   return root;
 }
 function headerLine(content, fg) {

package/dist/{credits-chip-view-YP4RPX26.js → credits-chip-view-M7PLKDN4.js}

@@ -1,6 +1,6 @@
 import {
-  formatCredits
-} from "./chunk-M7OUVABX.js";
+  creditsChipText
+} from "./chunk-LRAGM3PR.js";
 
 // src/tui/credits-chip-view.ts
 import { createElement, insert, setProp } from "@opentui/solid";
@@ -12,7 +12,7 @@ function createCreditsChipView(credits, tokens) {
   setProp(chip, "wrapMode", "none");
   setProp(chip, "flexShrink", 0);
   if (tokens?.subdued !== void 0) setProp(chip, "fg", tokens.subdued);
-  insert(chip, () => current().present ? formatCredits(current().total, current().unit) : "");
+  insert(chip, () => creditsChipText(current()));
   return chip;
 }
 export {

package/dist/server.js

@@ -1,3 +1,6 @@
+// package.json
+var version = "0.5.0-beta.5";
+
 // src/server/auth.ts
 var KIRO_INTEGRATION_ID = "kiro";
 var KIRO_INTEGRATION_NAME = "Kiro";
@@ -8,6 +11,8 @@ 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 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() {
@@ -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) => {
@@ -120,6 +133,25 @@ var KIRO_PROVIDER_PACKAGE = "aisdk:kiro-acp-ai-provider";
 function asString(value) {
   return value;
 }
+var DISCOVERY_TIMEOUT_MS = 6e4;
+var RETRY_BACKOFF_MS = [5e3, 2e4, 6e4];
+var LOG_PREFIX = "[opencode-kiro]";
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function cancelRetry(state) {
+  if (state.retryTimer !== void 0) {
+    clearTimeout(state.retryTimer);
+    state.retryTimer = void 0;
+  }
+}
+function clearDiscoveryTimers(state) {
+  if (state.probeTimer !== void 0) {
+    clearTimeout(state.probeTimer);
+    state.probeTimer = void 0;
+  }
+  cancelRetry(state);
+}
 function createDiscoveryResources() {
   return {
     state: void 0,
@@ -184,41 +216,95 @@ 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,
+      ...state.options.stall !== void 0 ? { stall: state.options.stall } : {},
       contextWindows
     };
   });
 }
 function createDiscover(context, state) {
-  async function runDiscovery(gen) {
+  async function publish(gen, discovered) {
+    if (gen !== state.generation) return;
+    const uniqueIds = new Set(discovered.map((model) => model.modelId));
+    if (uniqueIds.size !== discovered.length) {
+      console.error(
+        `${LOG_PREFIX} model discovery for ${state.cwd} returned duplicate model ids; catalog left unchanged`
+      );
+      return;
+    }
+    cancelRetry(state);
+    state.snapshot = discovered;
+    await context.catalog.reload();
+  }
+  function probeDeadline(gen, probe) {
+    return new Promise((_resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (state.probeTimer === timer) state.probeTimer = void 0;
+        void probe.then((discovered) => publish(gen, discovered)).catch(() => {
+        });
+        reject(new Error(`no response after ${DISCOVERY_TIMEOUT_MS / 1e3}s`));
+      }, DISCOVERY_TIMEOUT_MS);
+      state.probeTimer = timer;
+      const settle = () => {
+        clearTimeout(timer);
+        if (state.probeTimer === timer) state.probeTimer = void 0;
+      };
+      probe.then(settle, settle);
+    });
+  }
+  async function runDiscovery(gen, attempt) {
     try {
       const { listModels } = await import("kiro-acp-ai-provider");
-      const discovered = await listModels({ cwd: state.cwd });
+      const probe = listModels({ cwd: state.cwd });
+      const discovered = await Promise.race([probe, probeDeadline(gen, probe)]);
+      await publish(gen, discovered);
+    } catch (error) {
       if (gen !== state.generation) return;
-      const uniqueIds = new Set(discovered.map((model) => model.modelId));
-      if (uniqueIds.size !== discovered.length) return;
-      state.snapshot = discovered;
-      await context.catalog.reload();
-    } catch {
+      const delay = RETRY_BACKOFF_MS[attempt];
+      const next = delay === void 0 ? "giving up until the next credential change" : `retrying in ${delay / 1e3}s`;
+      console.error(
+        `${LOG_PREFIX} model discovery failed for ${state.cwd} (attempt ${attempt + 1}/${RETRY_BACKOFF_MS.length + 1}): ${describeError(error)}; ${next}`
+      );
+      if (delay !== void 0) scheduleRetry(gen, attempt + 1, delay);
     }
   }
+  function start(attempt) {
+    const gen = ++state.generation;
+    const run = runDiscovery(gen, attempt).finally(() => {
+      if (state.inflight === run) state.inflight = void 0;
+    });
+    state.inflight = run;
+    return run;
+  }
+  function scheduleRetry(gen, attempt, delay) {
+    cancelRetry(state);
+    state.retryTimer = setTimeout(() => {
+      state.retryTimer = void 0;
+      void retry(gen, attempt).catch(() => {
+      });
+    }, delay);
+  }
+  async function retry(gen, attempt) {
+    if (gen !== state.generation) return;
+    const active = await context.integration.connection.active(KIRO_INTEGRATION_ID);
+    if (!active || gen !== state.generation) return;
+    await start(attempt);
+  }
   return async function discover(_reason) {
     const active = await context.integration.connection.active(KIRO_INTEGRATION_ID);
     if (!active) {
+      cancelRetry(state);
       state.generation += 1;
       state.snapshot = void 0;
       await context.catalog.reload();
       return;
     }
     if (state.inflight !== void 0) return state.inflight;
-    const gen = ++state.generation;
-    const run = runDiscovery(gen).finally(() => {
-      if (state.inflight === run) state.inflight = void 0;
-    });
-    state.inflight = run;
-    return run;
+    cancelRetry(state);
+    return start(0);
   };
 }
 function isKiroCredentialEvent(event) {
@@ -239,22 +325,23 @@ async function consumeEvents(iterator, discover) {
       if (result.done) return;
       const event = result.value;
       if (isKiroCredentialEvent(event)) {
-        try {
-          await discover(event.type);
-        } catch {
-        }
+        void discover(event.type).catch(() => {
+        });
       }
     }
   } 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
+    inflight: void 0,
+    probeTimer: void 0,
+    retryTimer: void 0
   };
   resources.state = state;
   const discover = createDiscover(context, state);
@@ -265,12 +352,13 @@ 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(() => {
     });
   }
   return async () => {
     state.generation += 1;
+    clearDiscoveryTimers(state);
     const errors = [];
     const eventIterator = resources.eventIterator;
     resources.eventIterator = void 0;
@@ -299,16 +387,39 @@ 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",
+  "stall"
+];
+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;
@@ -329,19 +440,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);
       }
@@ -349,14 +461,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();
@@ -405,17 +537,35 @@ function buildCleanup(state) {
 }
 
 // src/server.ts
+function resolveOptions(raw) {
+  const stall = resolveStall(raw.stall);
+  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,
+    ...stall !== void 0 ? { stall } : {}
+  };
+}
+function resolveStall(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+  const { afterMs, live } = raw;
+  const stall = {};
+  if (typeof afterMs === "number" && Number.isFinite(afterMs) && afterMs >= 0) stall.afterMs = afterMs;
+  if (live === "off" || live === "reasoning") stall.live = live;
+  return Object.keys(stall).length > 0 ? stall : void 0;
+}
 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/dist/tui.js

@@ -1,7 +1,8 @@
 import {
-  messageCredits,
-  readCreditState
-} from "./chunk-M7OUVABX.js";
+  addMessageMetadata,
+  messageMetadata,
+  readPartMetadata
+} from "./chunk-LRAGM3PR.js";
 
 // src/tui/transient-credits.ts
 var SEPARATOR = "\0";
@@ -26,34 +27,31 @@ function recordTextEnded(store, event) {
   const { sessionID, assistantMessageID, ordinal, state } = data;
   if (!isValidKeyPart(sessionID) || !isValidKeyPart(assistantMessageID)) return;
   if (typeof ordinal !== "number" || !Number.isInteger(ordinal) || ordinal < 0) return;
-  const credits = readCreditState(state);
-  if (!credits) return;
-  store.entries.set(transientKey(sessionID, assistantMessageID, ordinal), credits);
+  const metadata = readPartMetadata(state);
+  if (!metadata) return;
+  store.entries.set(transientKey(sessionID, assistantMessageID, ordinal), metadata);
 }
 function transientForMessage(store, sessionID, assistantMessageID) {
-  let best;
-  let bestOrdinal = -1;
+  const entries = [];
   for (const [key, value] of store.entries) {
     const parsed = parseKey(key);
     if (!parsed || parsed[0] !== sessionID || parsed[1] !== assistantMessageID) continue;
-    if (parsed[2] > bestOrdinal) {
-      bestOrdinal = parsed[2];
-      best = value;
-    }
+    entries.push([parsed[2], value]);
   }
-  return best;
+  if (entries.length === 0) return void 0;
+  entries.sort((a, b) => a[0] - b[0]);
+  const credits = entries.findLast(([, value]) => value.credits !== void 0)?.[1];
+  const status = entries.findLast(([, value]) => value.status !== void 0)?.[1]?.status;
+  return {
+    ...credits ? { credits: credits.credits, unit: credits.unit } : {},
+    ...status ? { status } : {}
+  };
 }
 function mergedMessageCredits(store, sessionID, durableMessages) {
   return durableMessages.filter((message) => message.type === "assistant").reduce(
     (acc, message) => {
-      const durable = messageCredits(message.content ?? []);
-      const hit = durable ?? transientForMessage(store, sessionID, message.id);
-      if (!hit) return acc;
-      return {
-        total: acc.total + hit.credits,
-        unit: hit.unit ?? acc.unit,
-        present: true
-      };
+      const durable = messageMetadata(message.content ?? []);
+      return addMessageMetadata(acc, durable ?? transientForMessage(store, sessionID, message.id));
     },
     { total: 0, unit: void 0, present: false }
   );
@@ -68,7 +66,7 @@ function reconcile(store, sessionID, durableMessages) {
       store.entries.delete(key);
       continue;
     }
-    if (messageCredits(message.content ?? []) !== void 0) store.entries.delete(key);
+    if (messageMetadata(message.content ?? []) !== void 0) store.entries.delete(key);
   }
 }
 function clear(store) {
@@ -109,19 +107,20 @@ var plugin = {
     const store = memoryStore ? memoryStore[0] : createTransientStore();
     if (!memoryStore) disposers.push(() => clear(store));
     const [{ createCreditsBoxView }, { createCreditsChipView }, { createSignal }] = await Promise.all([
-      import("./credits-box-view-GLFJSV6M.js"),
-      import("./credits-chip-view-YP4RPX26.js"),
+      import("./credits-box-view-2OGZPIW6.js"),
+      import("./credits-chip-view-M7PLKDN4.js"),
       import("solid-js")
     ]);
     const [transientVersion, setTransientVersion] = createSignal(0);
-    const unsubscribeTextEnded = context.data.on("session.text.ended", (event) => {
+    const recordEnded = (event) => {
       try {
         recordTextEnded(store, event);
         setTransientVersion((version) => version + 1);
       } catch {
       }
-    });
-    disposers.push(unsubscribeTextEnded);
+    };
+    disposers.push(context.data.on("session.text.ended", recordEnded));
+    disposers.push(context.data.on("session.reasoning.ended", recordEnded));
     const creditsFor = (sessionID) => () => {
       if (!sessionID) return EMPTY_CREDITS;
       transientVersion();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-kiro",
-  "version": "0.5.0-beta.3",
+  "version": "0.5.0-beta.5",
   "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,12 +38,15 @@
   "engines": {
     "node": ">=20"
   },
+  "publishConfig": {
+    "tag": "beta"
+  },
   "peerDependencies": {
     "@opencode-ai/plugin": "0.0.0-dev-18686"
   },
   "dependencies": {
     "@opentui/solid": "0.5.9",
-    "kiro-acp-ai-provider": "3.0.0",
+    "kiro-acp-ai-provider": "3.2.0",
     "solid-js": "1.9.12"
   },
   "devDependencies": {

package/dist/chunk-M7OUVABX.js

@@ -1,40 +0,0 @@
-// src/tui/credits.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function readCreditState(state) {
-  if (!isRecord(state)) return void 0;
-  if (typeof state.credits !== "number" || !Number.isFinite(state.credits)) return void 0;
-  return {
-    credits: state.credits,
-    unit: typeof state.creditsUnit === "string" && state.creditsUnit.length > 0 ? state.creditsUnit : void 0
-  };
-}
-function readPartCredits(part) {
-  if (!isRecord(part)) return void 0;
-  if (part.type !== "text" && part.type !== "reasoning") return void 0;
-  return readCreditState(part.state);
-}
-function messageCredits(parts) {
-  const carriers = parts.map(readPartCredits).filter((value) => value !== void 0);
-  const last = carriers.at(-1);
-  if (!last) return void 0;
-  return {
-    credits: last.credits,
-    unit: last.unit ?? carriers.findLast((carrier) => carrier.unit !== void 0)?.unit
-  };
-}
-var creditsAmount = new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 });
-function formatCredits(value, unit) {
-  const amount = creditsAmount.format(Number.isFinite(value) ? value : 0);
-  if (!unit) return amount;
-  const label = value === 1 || unit.endsWith("s") ? unit : `${unit}s`;
-  return `${amount} ${label}`;
-}
-var money = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" });
-
-export {
-  readCreditState,
-  messageCredits,
-  formatCredits
-};