opencode-kiro 0.4.0 → 0.5.0-beta.1

package/README.md

@@ -1,22 +1,45 @@
 # opencode-kiro
 
-The ACP-compliant [Kiro](https://kiro.dev) auth plugin for [opencode](https://opencode.ai).
-
-opencode learns the `kiro` provider and its available models (US region) from the
-[models.dev](https://models.dev) catalog. This plugin supplies the following pieces:
-
-- **Auth** via the official `kiro-cli` login flow (`opencode auth login`, then "Kiro CLI Login")
-- **Provider options loader**: the `cwd`, `agent`, `trustAllTools`, `mcpTimeout` values
-  opencode forwards into the SDK factory
-- **TUI credits display**: an opt-in Kiro credits box in the sidebar (appended below the
-  native Context box) plus a matching footer credits chip
+> ⚠️ **Experimental prerelease** — `0.5.0-beta.1` 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.1.md](./RELEASE_NOTES_0.5.0-beta.1.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.
+
+The ACP-compliant [Kiro](https://kiro.dev) plugin for [opencode](https://opencode.ai).
+
+The plugin supplies:
+
+- **Auth** via the official `kiro-cli` login flow: it registers the `kiro` integration
+  with a **Kiro CLI Login** OAuth method (`opencode auth login`)
+- **Model discovery**: after auth it captures Kiro's live model lineup and merges it
+  into OpenCode's catalog (exact ID intersection, reasoning-effort variants), with a
+  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`)
+- **TUI credits display**: a live Kiro credits box in the sidebar
+
+`kiro-acp-ai-provider` talks to your locally installed `kiro-cli` over Kiro's
+[Agent Client Protocol](https://agentclientprotocol.com) (ACP). This is the supported
+integration path: requests go through kiro-cli exactly like Kiro's own IDE clients,
+with no credential scraping and no reuse of Kiro credentials against other providers.
+
+## Compatibility
+
+This prerelease is built and tested against **one pinned OpenCode v2 snapshot**:
+
+| Item | Value |
+|---|---|
+| Tested OpenCode commit (`upstream/v2`) | `b47cfbee7c4fd24e5d73e5753b4755db62a92a63` |
+| `@opencode-ai/plugin` | `0.0.0-next-16420` (exact) |
+| Package version | `0.5.0-beta.1` |
 
-The `kiro` provider resolves to [`kiro-acp-ai-provider`](https://www.npmjs.com/package/kiro-acp-ai-provider),
-an AI-SDK provider that talks to your locally installed `kiro-cli` over Kiro's
-[Agent Client Protocol](https://agentclientprotocol.com) (ACP); opencode picks it up from
-the catalog's `npm` field. This is the supported integration path: requests go through
-kiro-cli exactly like Kiro's own IDE clients, with no credential scraping and no reuse of
-Kiro credentials against other providers.
+Full pin table and verification evidence: [PINNED_VERSIONS.md](./PINNED_VERSIONS.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.
 
 ## Prerequisites
 
@@ -24,57 +47,68 @@ Kiro credentials against other providers.
 |---|---|
 | [kiro-cli](https://kiro.dev/docs/cli/) | Must be installed and on `PATH`; a Kiro subscription / AWS Builder ID account |
 | [Node.js](https://nodejs.org) `>= 20` | Enforced via `engines.node`. |
-| opencode `>= 1.16.0` | Enforced via `engines.opencode` on released builds. The shipped catalog must include the `kiro` provider (see [Troubleshooting](#troubleshooting)). |
-
-## Install
-
-```bash
-opencode plugin opencode-kiro
-```
-
-(alias: `opencode plug opencode-kiro`; add `--global`/`-g` to install into your global config instead of the project)
-
-The installer reads this package's `exports` and detects both plugin entrypoints
-(`./server` and `./tui`), then patches **both** config files automatically:
+| OpenCode v2 at the tested snapshot | See [Compatibility](#compatibility). This prerelease does not support OpenCode v1. |
 
-- `.opencode/opencode.json`: the server plugin (auth)
-- `.opencode/tui.json`: the TUI plugin (credits sidebar box + footer chip)
+## Install and configure
 
-(with `--global`: `~/.config/opencode/opencode.json` and `~/.config/opencode/tui.json`)
+OpenCode v2 splits plugin configuration into **two separate files**, and both entries
+are configured manually:
 
-You do **not** add a `provider.kiro` block; opencode loads the `kiro` provider and its
-models straight from the models.dev catalog. See
-[Credits in the sidebar](#credits-in-the-sidebar) for what the TUI plugin adds.
+### 1. Server plugin — `plugins` in your OpenCode config
 
-### Manual alternative
+Add the package to the **`plugins`** array (plural) of your OpenCode config
+(`opencode.json`, project or global). The object form pins the version and leaves room
+for future options:
 
-Add the package name to the `plugin` array of **both** files yourself (in the
-project's `.opencode/` directory, at the project root, or in the global
-`~/.config/opencode/`, all are valid config locations):
+```json
+{
+  "plugins": [
+    {
+      "package": "opencode-kiro@0.5.0-beta.1",
+      "options": {}
+    }
+  ]
+}
+```
 
-`opencode.json`:
+A plain package string is also accepted:
 
 ```json
 {
-  "plugin": ["opencode-kiro"]
+  "plugins": ["opencode-kiro@0.5.0-beta.1"]
 }
 ```
 
-`tui.json`:
+This loads the server entry (`./server` export): auth, model discovery, and provider
+ownership.
+
+### 2. TUI plugin — `plugins` in your global `cli.json`
+
+To enable the Kiro credits sidebar, add `"opencode-kiro"` to the **`plugins`** array in
+your **global `cli.json`** (typically `~/.config/opencode/cli.json`) and restart
+opencode:
 
 ```json
 {
-  "plugin": ["opencode-kiro"]
+  "plugins": ["opencode-kiro"]
 }
 ```
 
-That single `plugin` entry is all the [credits sidebar](#credits-in-the-sidebar) box and
-footer chip need; there is no `plugin_enabled` step.
+This loads the TUI entry (`./tui` export): the sidebar credits box. The connect flow
+shows these same steps when you answer **Yes** to the
+"Enable the Kiro credits sidebar?" prompt during `opencode auth login`.
+
+### Legacy `tui.json` (v1)
+
+`tui.json` is **legacy v1 configuration** and, under v2, is **migration input only**:
+the host may read it when migrating old setups, and this plugin **never modifies it**
+(the v1 consent-driven update of that file was deleted in v2). Do not add new entries
+to `tui.json`; use the global `cli.json` `plugins` array described above.
 
 ### Local development (path source)
 
-Run a local checkout without npm: build first, then reference the repo directory by
-absolute path in both `plugin` arrays:
+Run a local checkout without npm — build first, then reference the repo directory by
+absolute path in both `plugins` arrays:
 
 ```bash
 git clone https://github.com/NachoFLizaur/opencode-kiro && cd opencode-kiro
@@ -82,25 +116,14 @@ npm install && npm run build
 ```
 
 ```json
-{ "plugin": ["/absolute/path/to/opencode-kiro"] }
+{ "plugins": ["/absolute/path/to/opencode-kiro"] }
 ```
 
-opencode resolves the right entrypoint per file from the package `exports`. Note that
-path-sourced TUI plugins **must export an `id`** (opencode rejects them otherwise);
-this package ships `{ id: "opencode-kiro", tui }`, so the id is identical across path
-and npm installs.
-
-Because the provider now comes from the catalog rather than the plugin, a local checkout
-also needs a catalog that includes `kiro`. opencode reads its catalog from
-`OPENCODE_MODELS_PATH` when set; point it at an `api.json` that contains the `kiro`
-provider (for example one generated from a [models.dev](https://models.dev) checkout):
-
-```bash
-OPENCODE_MODELS_PATH=/path/to/api.json opencode models | grep '^kiro/'
-```
-
-Until the catalog opencode loads contains `kiro`, the provider will not appear regardless
-of this plugin being installed (the plugin only adds auth, not the provider definition).
+OpenCode resolves the right entrypoint per file from the package `exports`
+(`./server` for the server config, `./tui` for `cli.json`). Each entry module exports
+its own `id`, which file-source TUI installs require: the server plugin's id is
+`kiro` and the TUI plugin's id is `opencode-kiro`. Enable/disable directives and
+host logs use `kiro` for the server plugin and `opencode-kiro` for the TUI plugin.
 
 ## Auth
 
@@ -108,24 +131,28 @@ of this plugin being installed (the plugin only adds auth, not the provider defi
 opencode auth login
 ```
 
-Select the **Kiro (plugin)** provider, then the **Kiro CLI Login** method:
+Select the **Kiro** integration, then the **Kiro CLI Login** method:
 
 - **Already logged in to kiro-cli**: immediate success; the existing kiro-cli session is reused.
 - **Not logged in**: the plugin launches `kiro-cli login`, which opens a browser window.
-  Complete the login there; the plugin polls for up to 120 seconds and stores the
-  credential when kiro-cli reports success.
+  Complete the login there; the plugin polls for up to 120 seconds and stores a minimal
+  credential record when kiro-cli reports success.
 
 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.
 
-> **Note:** opencode will also surface `kiro` if the `KIRO_API_KEY` environment variable
-> is set, because the catalog entry declares `env: ["KIRO_API_KEY"]`. The intended auth
-> path for this plugin is still **Kiro CLI Login** above (it reuses your local kiro-cli
-> session); the env var is a secondary route opencode offers for any catalog provider.
+kiro-cli owns credential storage and refresh — OpenCode never stores real AWS tokens,
+and the plugin implements no refresh callback.
 
 ## Models
 
-After authentication, the plugin exposes the exact, case-sensitive intersection of Kiro's runtime `modelId` values and the models.dev catalog's `model.api.id` values. The runtime `listModels()` result is authoritative: `runtimeEfforts` is always an array, an empty array leaves the matching catalog model unchanged, and nonempty arrays merge exact effort variants into the catalog. Existing variant metadata survives key collisions while the runtime effort sets `reasoningEffort`; an optional runtime `baselineEffort` sets the model's base effort. Successful discovery keeps every matching catalog key and all other metadata while omitting runtime-only and catalog-only IDs. A discovery exception or duplicate runtime ID preserves the exact original catalog unchanged.
+After authentication, the plugin captures Kiro's runtime model list and transforms
+OpenCode's catalog to the exact, case-sensitive intersection of runtime `modelId`
+values and catalog model IDs. Runtime reasoning-effort levels are merged as model
+variants (per model family, native levels only); an optional runtime baseline effort
+sets the model's base effort. A discovery failure or duplicate runtime ID leaves the
+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.
 
 List the resulting models with:
 
@@ -134,95 +161,79 @@ opencode models
 opencode run -m kiro/<exact-model-id> "hello"
 ```
 
-Image input is capability-driven: paste an image path into the TUI prompt and
-image-capable models receive it as an attachment.
-
-### Reasoning effort
+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 a reasoning-effort toggle: cycle it in opencode with the
-**Cycle model variants** action (default keybind `ctrl+t`). It is **per model**, showing
-each family's native levels.
-
-Models without effort control show no effort option. opencode's **Default** (unset) returns the model to its native
-default effort. No config is required: the plugin's `provider.models` hook supplies the
-variants automatically and the chosen level flows to the SDK as
-`providerOptions.kiro.reasoningEffort`. Kiro cannot disable thinking, so even the lowest
-level still produces a reasoning trail.
-
-## Credits in the sidebar
+## Credits in the TUI
 
 Kiro is subscription-metered: requests consume **credits**, and the dollar cost
-opencode normally displays for Kiro turns is always $0.00. To surface credits the
-plugin **appends** a small Kiro credits box in the sidebar, rendered right below the
-native **Context** box. It does **not** replace or disable any builtin section: the
-native Context box stays and keeps showing the usual tokens, context percentage, and
-cost.
-
-The credits box renders only for Kiro sessions; for a non-Kiro session it shows nothing,
-so that session's sidebar is unchanged. The credits value and its unit come from the
-metadata the SDK attaches to each message part (kiro-cli reports the unit); nothing is
-hardcoded client-side.
-
-All you need in `tui.json` is the plugin entry:
-
-```json
-{
-  "plugin": ["opencode-kiro"]
-}
-```
-
-There is no `plugin_enabled` step anymore.
-
-### Migrating from 0.2.1 and earlier
-
-Older versions replaced the native Context box with a clone and disabled the builtin via:
-
-```json
-{
-  "plugin_enabled": { "internal:sidebar-context": false }
-}
-```
-
-If you upgraded from 0.2.1 or earlier and still have that line in your `tui.json`,
-remove it yourself: the plugin no longer manages `plugin_enabled`. Once the line is
-gone the native Context box returns and shows the usual tokens / context % / cost, and
-the Kiro credits box appears in a separate box right below it.
-
-## Known limitation
-
-**Credits render in the TUI only.** Two TUI surfaces show them: the sidebar credits
-box (above) and the input/prompt meta row chip (`session_prompt_right`), which sits
-above the host's `$` cost chip. Every other cost surface (ACP clients, the web app,
-desktop, web share pages, and CLI cost output) shows $0.00 for Kiro sessions. The
-models.dev catalog declares Kiro's per-token `cost` as 0 (it is a subscription-metered
-provider with no per-token pricing), so opencode core computes $0.00 everywhere it
-renders dollar cost. That is expected, not a defect. A cross-surface credits display
-would require opencode core changes and is intentionally out of scope for this plugin.
+OpenCode normally displays for Kiro turns is always $0.00. To surface credits the TUI
+plugin renders one surface:
+
+- a Kiro credits box in the sidebar (`sidebar.content` slot), showing the session's
+  live credits total and unit
+
+It renders only for sessions that carry Kiro credit data; other sessions are
+unchanged. The credits value and unit come from the provider state the SDK attaches to
+each message part (`part.state.credits` / `part.state.creditsUnit`); nothing is
+hardcoded client-side. The only configuration needed is the `cli.json` `plugins` entry
+from [Install](#2-tui-plugin--plugins-in-your-global-clijson).
+
+While a turn is still streaming, credits for just-ended text are picked up live through
+a transient store that works around a host reducer bug at the pinned snapshot (the
+text-ended event's provider state is dropped by the host); once durable message state
+arrives, it is authoritative and nothing is double-counted. See the release notes for
+details.
+
+## Known limitations (prerelease)
+
+- **No slot ordering.** OpenCode v2 slots have no order parameter, so the sidebar
+  credits box renders where the host places `sidebar.content` contributions (after the
+  built-in sidebar sections), not at a plugin-chosen position.
+- **Default styling.** The pinned snapshot has no supported theme-token API for plugin
+  views, so the credits box uses default/inherited terminal styling instead of
+  matching the active theme.
+- **Reduced toast feedback.** Auth-flow feedback is delivered as connect-flow text
+  (method instructions and the sidebar setup steps) rather than toasts. A toast API
+  exists at the pinned snapshot, but this plugin's core deliberately does not depend on
+  it — the TUI context surface is churning and toast availability is not guaranteed
+  across snapshots.
+- **Live text credits use a workaround.** See [Credits in the TUI](#credits-in-the-tui)
+  and the release notes.
+- **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
+  pricing). That is expected, not a defect.
 
 ## How it works
 
-- **Provider metadata and runtime models**: opencode loads the `kiro` provider and model
-  metadata from models.dev. After auth, this plugin keeps only exact catalog/runtime ID
-  matches, preserves catalog metadata, and projects the runtime-authoritative effort
-  options; a discovery exception or duplicate runtime ID keeps the input catalog unchanged.
-- **SDK resolution (resolveSDK)**: opencode reads the catalog's `npm` field
-  (`kiro-acp-ai-provider`), installs that package into its package cache on first model
-  use, and imports it. This plugin's `auth` loader supplies the provider options
-  (`cwd`, `agent`, `trustAllTools`, `mcpTimeout`, `contextWindows`) that opencode forwards
-  into `createKiroAcp(...)`. The loader relays each model's `limit.context` (from
-  models.dev, via opencode's resolved catalog) into the SDK's `contextWindows` map keyed
-  by `api.id`, so the SDK keeps no hardcoded per-model data and falls back to 1,000,000
-  for any model absent from the relay.
-- **Auth (this plugin)**: registers the "Kiro CLI Login" OAuth method (kiro-cli login
-  flow) plus the options loader above. The same plugin also imports `verifyAuth` from
-  `kiro-acp-ai-provider` to check kiro-cli installation/login state.
-- **Session affinity & reset (in-SDK)**: the SDK keys kiro-cli sessions off opencode's
-  `x-session-affinity` header, isolates tool-less utility calls (title generation) on
-  an ephemeral session, detects prompt-history divergence (`fork/undo`), and starts a
-  fresh kiro session when needed. No host-side session plumbing.
-- **Credits metadata**: the SDK attaches `{ kiro: { credits, creditsUnit } }` to the
-  `metadata` of the final message part of each turn; opencode persists it, and the TUI
-  plugin sums it per assistant message (deduped across text/reasoning parts) for the sidebar.
+- **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.
+- **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.
+- **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.
+- **Credits state**: the SDK reports `credits` / `creditsUnit` in each turn's provider
+  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).
 
 ## Troubleshooting
 
@@ -230,11 +241,21 @@ would require opencode core changes and is intentionally out of scope for this p
 |---|---|
 | `kiro-cli is not installed` during auth | Install kiro-cli from <https://kiro.dev/docs/cli/> and ensure it is on `PATH` for the opencode process. |
 | 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 metadata contribute nothing. Check the TUI plugin is `active` in the Plugins dialog (and listed in `tui.json`). |
-| Credits box never appears (even with `tui.json` configured correctly) | The TUI credits box renders only when `opencode-kiro` is resolvable in opencode's package cache. If the package is missing from the cache the box silently does not appear. Fix: ensure `opencode-kiro` is installed so it resolves in the cache. Do **not** manually clear the package cache: clearing can trigger a flaky on-demand refetch that fails with an "unknown git error". |
-| `kiro` provider not showing in `opencode models` | The provider comes from the models.dev catalog, not this plugin. Ensure your opencode version ships a catalog that includes `kiro` (run `opencode models --refresh` to update the cache). For local development, point opencode at a kiro-inclusive catalog via `OPENCODE_MODELS_PATH=/path/to/api.json` (see [Local development](#local-development-path-source)). |
+| No credits line / credits stay 0 | Credits appear after the first **completed** kiro turn; cancelled turns and turns without usage state contribute nothing. Check `"opencode-kiro"` is listed in your global `cli.json` `plugins` array. |
+| Credits box never appears | The TUI entry loads from the global `cli.json` `plugins` array only — a server-side `plugins` entry alone does not enable it. Add the `cli.json` entry and restart opencode. |
+| `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`) | Run `npm run build` in your checkout first and reference the repo root (both entry modules export ids). |
-| Provider visible but runs fail | The provider is selectable (from the catalog) before any credential exists. Run `opencode auth login` first. |
+| 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. |
+
+## Legacy: v1 / OpenCode v1 users (`0.4.0`)
+
+`opencode-kiro@0.4.0` on the `main` branch is the supported stable line for OpenCode
+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.1` into an OpenCode v1 setup.
 
 ## Development
 

package/dist/chunk-M7OUVABX.js

@@ -0,0 +1,40 @@
+// 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
+};

package/dist/credits-box-view-FIHO6TR6.js

@@ -0,0 +1,35 @@
+import {
+  formatCredits
+} from "./chunk-M7OUVABX.js";
+
+// src/tui/credits-box-view.ts
+import { createElement, insert, insertNode } from "@opentui/solid";
+import { createMemo } from "solid-js";
+function createCreditsBoxView(credits) {
+  const current = createMemo(credits);
+  const root = createElement("box");
+  insertNode(
+    root,
+    headerLine(() => current().present ? "Kiro" : "")
+  );
+  insertNode(
+    root,
+    plainLine(() => current().present ? formatCredits(current().total, current().unit) : "")
+  );
+  return root;
+}
+function headerLine(content) {
+  const line = createElement("text");
+  const bold = createElement("b");
+  insert(bold, content);
+  insertNode(line, bold);
+  return line;
+}
+function plainLine(content) {
+  const line = createElement("text");
+  insert(line, content);
+  return line;
+}
+export {
+  createCreditsBoxView
+};

package/dist/server.d.ts

@@ -1,20 +1,7 @@
-import { Plugin, PluginInput, Hooks } from '@opencode-ai/plugin';
+import { Plugin } from '@opencode-ai/plugin';
 
-declare function kiroTokenPath(): string;
-declare function readToken(tokenPath: string | undefined): Promise<{
-    type: "success";
-    refresh: string;
-    access: string;
-    expires: number;
-} | {
-    type: "failed";
-}>;
-declare function notifyIfTokenExpired(client: PluginInput["client"] | undefined): Promise<void>;
-declare function enableSidebarConfig(path: string, input: PluginInput): Promise<void>;
-declare const KiroAuthPlugin: Plugin;
-declare const _default: {
-    id: string;
-    server: (input: PluginInput) => Promise<Hooks>;
-};
+declare const plugin: Plugin.Plugin;
 
-export { KiroAuthPlugin, _default as default, enableSidebarConfig, kiroTokenPath, notifyIfTokenExpired, readToken };
+declare const KiroAuthPlugin: Plugin.Plugin;
+
+export { KiroAuthPlugin, plugin as default };