@bogyie/opencode-kiro-plugin 0.3.12 → 0.3.15

package/README.md

@@ -38,7 +38,7 @@ The plugin resolves credentials in this order:
 3. Local Kiro CLI session token from the Kiro CLI SQLite store
 4. `kiro-cli whoami` diagnostics for CLI session visibility
 
-OpenCode startup does not start Kiro login or model discovery. The plugin injects `provider.kiro` with an `auto` placeholder model so Kiro appears in OpenCode's provider connector. Model discovery runs only when you explicitly call the `kiro_refresh_models` plugin tool; if discovery succeeds, later model-list requests use the latest in-memory cache. If discovery fails, the previous cache remains in use.
+OpenCode startup does not start Kiro login. It does run best-effort model discovery with `kiro-cli chat --list-models --format json` so the model picker can track the current Kiro CLI list. If startup discovery succeeds, the result is stored in a local cache and used immediately. If startup discovery fails, the plugin keeps the last stored model list. If no stored list exists yet, it injects an `auto` placeholder model so Kiro still appears in OpenCode's provider connector.
 
 You can open OpenCode's provider connector, choose Kiro, and select `Kiro device login`. The connector runs `kiro-cli login --use-device-flow`, waits for the local Kiro CLI session to become authenticated, then stores a local transport marker in OpenCode auth. If `login.identityProvider`, `login.region`, `login.license`, or `login.extraArgs` are configured, those options are passed to `kiro-cli login` along with `--use-device-flow`. After login succeeds, the plugin also tries to refresh the runtime model cache. If no OpenCode connector marker or API key is configured, direct fetch still reads the active Kiro CLI session token and calls Kiro's REST/EventStream endpoint directly. If an API/model call fails with an auth error, the selected transport starts the same configured Kiro CLI login flow and retries the request once. `cli-chat` mode uses the official `kiro-cli chat --no-interactive` surface and depends on the local Kiro CLI login state. `acp` mode uses the official `kiro-cli acp` surface, but is still treated as an explicit backend while its real-world protocol behavior is validated across Kiro CLI versions.
 
@@ -64,7 +64,7 @@ For AWS IAM Identity Center login, configure the default device-flow Start URL s
 
 For IAM Identity Center, configure `login.identityProvider` and `login.region` in plugin options so they are passed to `kiro-cli login --use-device-flow`.
 
-Use the `kiro_status` plugin tool to inspect provider id, backend, region, auth method, and discovered model count. Use `kiro_refresh_models` when you explicitly want to run the configured model discovery command and update the in-memory model cache. Secrets are redacted in diagnostics.
+Use the `kiro_status` plugin tool to inspect provider id, backend, region, auth method, and discovered model count. Use `kiro_refresh_models` when you explicitly want to run the configured model discovery command and update the in-memory and stored model cache. Secrets are redacted in diagnostics.
 
 ## Backend Modes
 
@@ -105,7 +105,7 @@ Supported values:
 
 ## Model Churn Handling
 
-The resolver intentionally avoids a hard whitelist. Startup adds a fallback `auto` model so the provider can be connected before discovery succeeds. When you run `kiro_refresh_models`, the plugin reads the current Kiro CLI model list with `kiro-cli chat --list-models --format json`. Runtime discovery is the source of truth for the model picker once it has succeeded; failed refreshes do not clear the last successful cache.
+The resolver intentionally avoids a hard whitelist. At startup, the plugin reads the current Kiro CLI model list with `kiro-cli chat --list-models --format json` and stores successful results in a local cache. Failed refreshes do not clear the last successful cache. If there is no successful cache yet, startup falls back to the `auto` placeholder so the provider can still be connected before discovery succeeds.
 
 Useful options:
 
@@ -151,11 +151,11 @@ Resolution order:
 6. Hidden/manual model mapping
 7. Optimistic pass-through unless disabled
 
-This keeps new Kiro model ids usable before the package is updated without advertising unavailable models in OpenCode's picker after discovery has succeeded. Use `extraModels` only when you explicitly want a model to appear even though it is not listed by your installed Kiro CLI. Set `disableModelPassThrough: true` only when you need strict model governance.
+This keeps new Kiro model ids usable before the package is updated without advertising unavailable models in OpenCode's picker after discovery has succeeded. The stored model cache lives at `$OPENCODE_KIRO_MODEL_CACHE` when set, otherwise `$XDG_CACHE_HOME/opencode-kiro-plugin/models.json` or `~/.cache/opencode-kiro-plugin/models.json`. Use `extraModels` only when you explicitly want a model to appear even though it is not listed by your installed Kiro CLI. Set `disableModelPassThrough: true` only when you need strict model governance.
 
 The plugin injects `provider.kiro` with the `auto` placeholder needed for OpenCode's provider connector. Define `provider.kiro.models` yourself only when you need explicit model-picker metadata such as a display name or context limit. Use plugin `modelAliases` for aliases that should resolve one requested model id to another.
 
-`modelDiscoveryCommand` defaults to `["kiro-cli", "chat", "--list-models", "--format", "json"]`. Set `modelDiscovery` to `"off"` to disable `kiro_refresh_models`. Discovery is best-effort and never runs during OpenCode startup; authenticate manually through the connector or let an API/model request handle auth failure. Discovery stdout can be a JSON array, `{ "models": [...] }`, `{ "data": [...] }`, Kiro CLI list-models JSON, Kiro CLI plain list output, or one model id per line.
+`modelDiscoveryCommand` defaults to `["kiro-cli", "chat", "--list-models", "--format", "json"]`. Set `modelDiscovery` to `"off"` to disable startup discovery and `kiro_refresh_models`; in that mode the plugin uses any stored cache and then the `auto` fallback. Discovery is best-effort and does not start login during OpenCode startup. `/v1/models` also uses only this discovery/cache path: it never invokes the chat transport or login fallback, and returns the cached list or `auto` if discovery fails. Authenticate manually through the connector or let a real chat completion request handle auth failure. A successful connector login also triggers a forced model refresh. Discovery stdout can be a JSON array, `{ "models": [...] }`, `{ "data": [...] }`, Kiro CLI list-models JSON, Kiro CLI plain list output, or one model id per line.
 
 ## Troubleshooting
 

package/dist/fetch-adapter.d.ts

@@ -8,6 +8,11 @@ export interface KiroTransport {
 export interface KiroFetchOptions {
     readonly resolver: ModelResolver;
     readonly transport?: KiroTransport;
+    readonly models?: () => Promise<ReadonlyArray<string | OpenAIModelListItem>>;
 }
 export type FetchAdapter = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface OpenAIModelListItem {
+    readonly id: string;
+    readonly [key: string]: unknown;
+}
 export declare function createKiroFetch(options: KiroFetchOptions): FetchAdapter;

package/dist/fetch-adapter.js

@@ -20,10 +20,38 @@ async function* responseToStream(response, fallbackModelId) {
     for (const toolCall of response.toolCalls ?? [])
         yield toolCall;
 }
+function requestPath(input) {
+    const raw = input instanceof Request ? input.url : input.toString();
+    const pathname = new URL(raw, "http://127.0.0.1").pathname.replace(/\/+$/, "");
+    return pathname || "/";
+}
+function isModelsPath(pathname) {
+    return pathname === "/v1/models" || pathname === "/models";
+}
+function toOpenAIModel(item) {
+    const id = typeof item === "string" ? item : item.id;
+    const extra = typeof item === "string" ? { id } : item;
+    return {
+        ...extra,
+        id,
+        object: "model",
+        created: typeof extra.created === "number" ? extra.created : 0,
+        owned_by: typeof extra.owned_by === "string" ? extra.owned_by : "kiro",
+    };
+}
+async function toOpenAIModelsResponse(models) {
+    const data = models ? (await models()).filter((item) => (typeof item === "string" ? item.trim() : item.id.trim())).map(toOpenAIModel) : [];
+    return Response.json({
+        object: "list",
+        data,
+    });
+}
 export function createKiroFetch(options) {
     const transport = options.transport ?? unsupportedTransport;
     return async (input, init) => {
         try {
+            if (isModelsPath(requestPath(input)))
+                return toOpenAIModelsResponse(options.models);
             const request = await readOpenAIRequest(input, init);
             const kiroRequest = toKiroGenerateRequest(request, options.resolver);
             if (request.stream === true && transport.stream) {

package/dist/model-cache-store.d.ts

@@ -0,0 +1,6 @@
+import type { CachedModelInfo } from "./model-cache.js";
+export declare function loadStoredModelCache(): Promise<{
+    models: CachedModelInfo[];
+    updatedAt?: number;
+}>;
+export declare function saveStoredModelCache(models: ReadonlyArray<CachedModelInfo>, updatedAt?: number): Promise<void>;

package/dist/model-cache-store.js

@@ -0,0 +1,49 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+function cachePath() {
+    if (process.env.OPENCODE_KIRO_MODEL_CACHE)
+        return process.env.OPENCODE_KIRO_MODEL_CACHE;
+    const base = process.env.XDG_CACHE_HOME || join(homedir() || tmpdir(), ".cache");
+    return join(base, "opencode-kiro-plugin", "models.json");
+}
+function modelInfo(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const input = value;
+    if (typeof input.id !== "string" || !input.id.trim())
+        return undefined;
+    const name = typeof input.name === "string" && input.name.trim() ? input.name.trim() : undefined;
+    const contextLimit = typeof input.contextLimit === "number" && Number.isFinite(input.contextLimit) ? input.contextLimit : undefined;
+    const outputLimit = typeof input.outputLimit === "number" && Number.isFinite(input.outputLimit) ? input.outputLimit : undefined;
+    return {
+        id: input.id.trim(),
+        ...(name ? { name } : {}),
+        ...(contextLimit ? { contextLimit } : {}),
+        ...(outputLimit ? { outputLimit } : {}),
+        ...("raw" in input ? { raw: input.raw } : {}),
+    };
+}
+export async function loadStoredModelCache() {
+    try {
+        const parsed = JSON.parse(await readFile(cachePath(), "utf8"));
+        const models = Array.isArray(parsed.models) ? parsed.models.map(modelInfo).filter((item) => Boolean(item)) : [];
+        return {
+            models,
+            ...(typeof parsed.updatedAt === "number" && Number.isFinite(parsed.updatedAt) ? { updatedAt: parsed.updatedAt } : {}),
+        };
+    }
+    catch {
+        return { models: [] };
+    }
+}
+export async function saveStoredModelCache(models, updatedAt = Date.now()) {
+    try {
+        const path = cachePath();
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, JSON.stringify({ updatedAt, models }, null, 2), "utf8");
+    }
+    catch {
+        // Best-effort cache only.
+    }
+}

package/dist/plugin.js

@@ -6,7 +6,8 @@ import { loadOptions } from "./config.js";
 import { createKiroFetch } from "./fetch-adapter.js";
 import { startLocalKiroServer } from "./local-server.js";
 import { ModelCache } from "./model-cache.js";
-import { refreshModelCacheFromCommand } from "./model-discovery.js";
+import { discoverModelsFromCommand } from "./model-discovery.js";
+import { loadStoredModelCache, saveStoredModelCache } from "./model-cache-store.js";
 import { ModelResolver, normalizeModelName } from "./model-resolver.js";
 import { KiroRestTransport } from "./kiro-rest-transport.js";
 const PLACEHOLDER_MODEL_ID = "auto";
@@ -48,6 +49,12 @@ function visibleProviderModels(cache, configuredModels, hiddenModels, disabledMo
         return models;
     return { [PLACEHOLDER_MODEL_ID]: PLACEHOLDER_MODEL };
 }
+function extraModelInfos(models) {
+    return Object.keys(models).map((id) => ({ id: normalizeModelName(id) }));
+}
+function mergeModelInfos(discovered, extraModels) {
+    return [...new Map([...discovered, ...extraModelInfos(extraModels)].map((model) => [model.id, model])).values()];
+}
 function bearerToken(init) {
     const header = new Headers(init?.headers).get("authorization");
     const match = header?.match(/^Bearer\s+(.+)$/i);
@@ -67,13 +74,19 @@ export function effectiveBackend(options, accessToken) {
 }
 function localTransport(options, accessToken) {
     const backend = effectiveBackend(options, accessToken);
+    const login = () => runKiroLoginFlowOnce({
+        login: {
+            ...options.login,
+            useDeviceFlow: true,
+        },
+    });
     if (backend === "acp")
         return new KiroAcpTransport(acpTransportOptions(options));
     if (backend === "cli-chat") {
         return new KiroCliChatTransport({
             trustAllTools: options.trustAllTools,
             ...(options.requestTimeoutMs ? { requestTimeoutMs: options.requestTimeoutMs } : {}),
-            login: () => runKiroLoginFlowOnce({ login: options.login }),
+            login,
         });
     }
     if (backend === "fetch") {
@@ -81,11 +94,11 @@ function localTransport(options, accessToken) {
         if (isKiroDeviceAuthKey(apiKey)) {
             return new KiroRestTransport(fetchTransportOptions(options), {
                 credentialProvider: async () => (await credentialFromKiroDeviceAuthKey(apiKey).catch(() => undefined)) ?? readKiroCliSessionCredential(),
-                login: () => runKiroLoginFlowOnce({ login: options.login }),
+                login,
             });
         }
         return new KiroRestTransport(fetchTransportOptions(options, apiKey === "kiro-plugin-local-transport" ? undefined : apiKey), {
-            login: () => runKiroLoginFlowOnce({ login: options.login }),
+            login,
         });
     }
     return undefined;
@@ -116,8 +129,12 @@ export function createKiroPlugin() {
         let configuredModels = { ...options.extraModels };
         let userModelOverrides;
         const disabledModels = new Set(options.disabledModels.map(normalizeModelName));
-        if (Object.keys(options.extraModels).length > 0) {
-            modelCache.update(Object.keys(options.extraModels).map((id) => ({ id: normalizeModelName(id) })));
+        const stored = await loadStoredModelCache();
+        if (stored.models.length > 0) {
+            modelCache.update(mergeModelInfos(stored.models, options.extraModels), stored.updatedAt);
+        }
+        else if (Object.keys(options.extraModels).length > 0) {
+            modelCache.update(extraModelInfos(options.extraModels));
         }
         let discovery;
         let lastModelDiscoveryAt = 0;
@@ -127,10 +144,13 @@ export function createKiroPlugin() {
                 return [];
             }
             if (!discovery) {
-                discovery = refreshModelCacheFromCommand(modelCache, options.modelDiscoveryCommand[0], options.modelDiscoveryCommand.slice(1))
+                discovery = discoverModelsFromCommand(options.modelDiscoveryCommand[0], options.modelDiscoveryCommand.slice(1))
                     .then((models) => {
-                    if (models.length > 0)
+                    if (models.length > 0) {
                         lastModelDiscoveryAt = Date.now();
+                        modelCache.update(mergeModelInfos(models, options.extraModels), lastModelDiscoveryAt);
+                        void saveStoredModelCache(models, lastModelDiscoveryAt);
+                    }
                     return models;
                 })
                     .catch(() => [])
@@ -138,7 +158,7 @@ export function createKiroPlugin() {
                     discovery = undefined;
                 });
             }
-            return (await discovery);
+            return discovery;
         };
         const resolver = new ModelResolver({
             cache: modelCache,
@@ -154,6 +174,10 @@ export function createKiroPlugin() {
                 const transport = localTransport(options, bearerToken(init));
                 return createKiroFetch({
                     resolver,
+                    models: async () => {
+                        await refreshModels(true).catch(() => []);
+                        return Object.keys(visibleProviderModels(modelCache, configuredModels, options.hiddenModels, disabledModels));
+                    },
                     ...(transport ? { transport } : {}),
                 })(input, init);
             };
@@ -191,6 +215,7 @@ export function createKiroPlugin() {
                 localServer = undefined;
             },
             config: async (config) => {
+                await refreshModels();
                 config.provider ??= {};
                 config.provider[options.providerID] ??= {};
                 const provider = config.provider[options.providerID];

package/docs/kiro-integration-notes.md

@@ -112,9 +112,10 @@ Kiro 모델 목록은 tier, region, release timing에 따라 바뀔 수 있으
 필수 동작:
 
 - startup 시 model discovery를 시도합니다.
-- discovery 결과는 TTL cache에 저장합니다.
-- cache가 stale이면 background refresh를 시도합니다.
-- refresh 실패 시 static preset을 사용 가능 모델처럼 표시하지 않고, 사용자 `extraModels`와 pass-through만 허용합니다.
+- discovery 결과는 TTL cache와 local persistent cache에 저장합니다.
+- refresh 실패 시 마지막 성공 model list cache를 유지합니다.
+- 마지막 성공 cache도 없으면 `auto` placeholder만 표시합니다.
+- static preset을 사용 가능 모델처럼 표시하지 않고, 사용자 `extraModels`와 pass-through만 허용합니다.
 - 사용자가 `hiddenModels`, `modelAliases`, `disabledModels`를 설정할 수 있게 합니다.
 - 알 수 없는 모델은 기본적으로 pass-through합니다.
 - Kiro가 거절한 경우 같은 model family의 후보를 제안합니다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bogyie/opencode-kiro-plugin",
-  "version": "0.3.12",
+  "version": "0.3.15",
   "description": "OpenCode plugin for using Kiro as a provider adapter",
   "type": "module",
   "main": "dist/index.js",