@bogyie/opencode-kiro-plugin 0.2.4 → 0.2.6

package/dist/plugin.js

@@ -9,12 +9,6 @@ import { ModelCache } from "./model-cache.js";
 import { refreshModelCacheFromCommand } from "./model-discovery.js";
 import { ModelResolver, normalizeModelName } from "./model-resolver.js";
 import { CodeWhispererKiroTransport } from "./kiro-transport.js";
-function mergeModels(extraModels, existing) {
-    return {
-        ...extraModels,
-        ...(existing ?? {}),
-    };
-}
 function discoveredProviderModels(cache) {
     return Object.fromEntries(cache.all().map((model) => [
         model.id,
@@ -31,6 +25,50 @@ function discoveredProviderModels(cache) {
         },
     ]));
 }
+function modelRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => Boolean(entry[0]) && Boolean(entry[1]) && typeof entry[1] === "object" && !Array.isArray(entry[1])));
+}
+function visibleProviderModels(cache, configuredModels, hiddenModels, disabledModels) {
+    const discovered = discoveredProviderModels(cache);
+    const modelIDs = new Set([...Object.keys(discovered), ...Object.keys(configuredModels), ...Object.keys(hiddenModels)]);
+    return Object.fromEntries([...modelIDs]
+        .filter((id) => !disabledModels.has(normalizeModelName(id)))
+        .map((id) => [
+        id,
+        {
+            ...(discovered[id] ?? {}),
+            ...(configuredModels[id] ?? {}),
+        },
+    ]));
+}
+function bearerToken(init) {
+    const header = new Headers(init?.headers).get("authorization");
+    const match = header?.match(/^Bearer\s+(.+)$/i);
+    return match?.[1] || undefined;
+}
+function localTransport(options, accessToken) {
+    if (options.backend === "acp")
+        return new KiroAcpTransport(acpTransportOptions(options));
+    if (options.backend === "cli-chat") {
+        return new KiroCliChatTransport({
+            trustAllTools: options.trustAllTools,
+            ...(options.requestTimeoutMs ? { requestTimeoutMs: options.requestTimeoutMs } : {}),
+        });
+    }
+    const apiKey = accessToken || process.env.KIRO_API_KEY;
+    if (apiKey && apiKey !== "kiro-plugin-local-transport") {
+        return new CodeWhispererKiroTransport(fetchTransportOptions(options, apiKey));
+    }
+    if (options.backend === "auto") {
+        return new KiroCliChatTransport({
+            trustAllTools: options.trustAllTools,
+            ...(options.requestTimeoutMs ? { requestTimeoutMs: options.requestTimeoutMs } : {}),
+        });
+    }
+    return undefined;
+}
 export function acpTransportOptions(options) {
     return {
         trustAllTools: options.trustAllTools,
@@ -52,9 +90,11 @@ export function fetchTransportOptions(options, accessToken) {
 export function createKiroPlugin() {
     return async (_input, rawOptions) => {
         const options = loadOptions(rawOptions);
-        const baseURL = options.endpoint ?? `https://q.${options.region}.amazonaws.com`;
         const modelCache = new ModelCache(options.modelCacheTtlSeconds);
         let localServer;
+        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) })));
         }
@@ -81,20 +121,40 @@ export function createKiroPlugin() {
             disabledModels: options.disabledModels,
             disablePassThrough: options.disableModelPassThrough,
         });
+        const ensureLocalServer = async () => {
+            if (localServer)
+                return localServer;
+            const localFetch = async (input, init) => {
+                const transport = localTransport(options, bearerToken(init));
+                return createKiroFetch({
+                    resolver,
+                    ...(transport ? { transport } : {}),
+                })(input, init);
+            };
+            localServer = await startLocalKiroServer(localFetch);
+            return localServer;
+        };
         return {
             dispose: async () => {
                 await localServer?.close();
                 localServer = undefined;
             },
             config: async (config) => {
+                await discoverIfStale();
                 config.provider ??= {};
                 config.provider[options.providerID] ??= {};
                 const provider = config.provider[options.providerID];
+                const server = await ensureLocalServer();
+                userModelOverrides ??= modelRecord(provider.models);
+                configuredModels = {
+                    ...options.extraModels,
+                    ...userModelOverrides,
+                };
                 provider.name ??= "Kiro";
                 provider.npm = "@ai-sdk/openai-compatible";
-                provider.api ??= baseURL;
+                provider.api = server.baseURL;
                 provider.options ??= {};
-                provider.models = mergeModels(options.extraModels, provider.models);
+                provider.models = visibleProviderModels(modelCache, configuredModels, options.hiddenModels, disabledModels);
             },
             auth: {
                 provider: options.providerID,
@@ -121,29 +181,10 @@ export function createKiroPlugin() {
                 loader: async (auth) => {
                     await discoverIfStale();
                     const apiKey = await resolveApiKey(auth);
-                    const transport = options.backend === "acp"
-                        ? new KiroAcpTransport(acpTransportOptions(options))
-                        : options.backend === "cli-chat"
-                            ? new KiroCliChatTransport({
-                                trustAllTools: options.trustAllTools,
-                                ...(options.requestTimeoutMs ? { requestTimeoutMs: options.requestTimeoutMs } : {}),
-                            })
-                            : apiKey
-                                ? new CodeWhispererKiroTransport(fetchTransportOptions(options, apiKey))
-                                : options.backend === "auto"
-                                    ? new KiroCliChatTransport({
-                                        trustAllTools: options.trustAllTools,
-                                        ...(options.requestTimeoutMs ? { requestTimeoutMs: options.requestTimeoutMs } : {}),
-                                    })
-                                    : undefined;
-                    const localFetch = createKiroFetch({
-                        resolver,
-                        ...(transport ? { transport } : {}),
-                    });
-                    localServer ??= await startLocalKiroServer(localFetch);
+                    const server = await ensureLocalServer();
                     return {
                         apiKey: apiKey || "kiro-plugin-local-transport",
-                        baseURL: localServer.baseURL,
+                        baseURL: server.baseURL,
                     };
                 },
             },
@@ -180,22 +221,28 @@ export function createKiroPlugin() {
                 id: options.providerID,
                 models: async (provider) => {
                     await discoverIfStale();
-                    const models = {
-                        ...discoveredProviderModels(modelCache),
-                        ...(provider.models ?? {}),
-                    };
-                    return Object.fromEntries(Object.entries(models).map(([id, model]) => [
-                        id,
-                        {
-                            ...model,
-                            api: {
-                                ...(model.api ?? {}),
-                                id,
-                                npm: "@ai-sdk/openai-compatible",
-                                url: baseURL,
+                    const existing = modelRecord(provider.models);
+                    const visibleModels = visibleProviderModels(modelCache, configuredModels, options.hiddenModels, disabledModels);
+                    const server = await ensureLocalServer();
+                    return Object.fromEntries(Object.keys(visibleModels)
+                        .map((id) => {
+                        const model = {
+                            ...(visibleModels[id] ?? {}),
+                            ...(existing[id] ?? {}),
+                        };
+                        return [
+                            id,
+                            {
+                                ...model,
+                                api: {
+                                    ...(model.api ?? {}),
+                                    id,
+                                    npm: "@ai-sdk/openai-compatible",
+                                    url: server.baseURL,
+                                },
                             },
-                        },
-                    ]));
+                        ];
+                    }));
                 },
             },
         };

package/package.json

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