@bogyie/opencode-kiro-plugin 0.1.0

package/dist/errors.js

@@ -0,0 +1,63 @@
+export class KiroPluginError extends Error {
+    code;
+    status;
+    constructor(message, code, status = 500) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "KiroPluginError";
+    }
+}
+export class UnsupportedBackendError extends KiroPluginError {
+    constructor(message = "Kiro fetch transport is not implemented for this backend yet.") {
+        super(message, "UNSUPPORTED_BACKEND", 501);
+        this.name = "UnsupportedBackendError";
+    }
+}
+function textOf(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    return "Unknown Kiro plugin error";
+}
+function nameOf(error) {
+    return error instanceof Error ? error.name : "";
+}
+function statusOf(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const status = error.status;
+    const metadataStatus = error.$metadata?.httpStatusCode;
+    return typeof status === "number" ? status : typeof metadataStatus === "number" ? metadataStatus : undefined;
+}
+export function normalizeError(error) {
+    if (error instanceof KiroPluginError)
+        return error;
+    const message = textOf(error);
+    const lower = `${nameOf(error)} ${message}`.toLowerCase();
+    const status = statusOf(error);
+    if (status === 401 || status === 403 || lower.includes("unauthorized") || lower.includes("not logged in")) {
+        return new KiroPluginError(message, "KIRO_AUTH_ERROR", status ?? 401);
+    }
+    if (status === 429 || lower.includes("rate limit") || lower.includes("quota")) {
+        return new KiroPluginError(message, "KIRO_RATE_LIMIT", 429);
+    }
+    if (status && status >= 500) {
+        return new KiroPluginError(message, "KIRO_UPSTREAM_ERROR", status);
+    }
+    if (lower.includes("network") || lower.includes("timeout") || lower.includes("econn")) {
+        return new KiroPluginError(message, "KIRO_NETWORK_ERROR", 502);
+    }
+    return new KiroPluginError(message, "KIRO_PLUGIN_ERROR");
+}
+export function errorResponse(error) {
+    const known = normalizeError(error);
+    return Response.json({
+        error: {
+            message: known.message,
+            type: known.code,
+            code: known.code,
+        },
+    }, { status: known.status });
+}

package/dist/fetch-adapter.d.ts

@@ -0,0 +1,13 @@
+import { type KiroGenerateRequest } from "./request-adapter.js";
+import { type KiroGenerateResponse, type KiroStreamEvent } from "./response-adapter.js";
+import type { ModelResolver } from "./model-resolver.js";
+export interface KiroTransport {
+    generate(request: KiroGenerateRequest): Promise<KiroGenerateResponse>;
+    stream?(request: KiroGenerateRequest): AsyncIterable<KiroStreamEvent>;
+}
+export interface KiroFetchOptions {
+    readonly resolver: ModelResolver;
+    readonly transport?: KiroTransport;
+}
+export type FetchAdapter = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare function createKiroFetch(options: KiroFetchOptions): FetchAdapter;

package/dist/fetch-adapter.js

@@ -0,0 +1,35 @@
+import { errorResponse, UnsupportedBackendError } from "./errors.js";
+import { readOpenAIRequest, toKiroGenerateRequest } from "./request-adapter.js";
+import { toOpenAIChatResponse, toOpenAIChatStreamResponse } from "./response-adapter.js";
+const unsupportedTransport = {
+    async generate() {
+        throw new UnsupportedBackendError();
+    },
+};
+async function* streamGeneratedResponse(transport, request) {
+    const response = await transport.generate(request);
+    if (response.text)
+        yield { type: "text", text: response.text, modelId: response.modelId ?? request.modelId };
+    for (const toolCall of response.toolCalls ?? [])
+        yield toolCall;
+}
+export function createKiroFetch(options) {
+    const transport = options.transport ?? unsupportedTransport;
+    return async (input, init) => {
+        try {
+            const request = await readOpenAIRequest(input, init);
+            const kiroRequest = toKiroGenerateRequest(request, options.resolver);
+            if (request.stream === true && transport.stream) {
+                return toOpenAIChatStreamResponse(transport.stream(kiroRequest), kiroRequest.modelId);
+            }
+            if (request.stream === true) {
+                return toOpenAIChatStreamResponse(streamGeneratedResponse(transport, kiroRequest), kiroRequest.modelId);
+            }
+            const response = await transport.generate(kiroRequest);
+            return toOpenAIChatResponse(response, kiroRequest.modelId);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export { AcpJsonRpcClient, createAcpStdioClient, decodeJsonRpc, encodeJsonRpc } from "./acp-client.js";
+export type { AcpConnection, AcpNotificationHandler, AcpStdioClientOptions, JsonRpcMessage } from "./acp-client.js";
+export { acpPermissionResponse, KiroAcpTransport } from "./acp-transport.js";
+export type { AcpSessionClient, KiroAcpTransportOptions } from "./acp-transport.js";
+export { createKiroPlugin, KiroPlugin } from "./plugin.js";
+export { detectAuth, redacted, resolveApiKey } from "./auth.js";
+export { cliChatArgs, KiroCliChatTransport, promptForCli } from "./cli-transport.js";
+export { createKiroFetch } from "./fetch-adapter.js";
+export { loadOptions } from "./config.js";
+export { getKiroCliStatus, getKiroCliVersion } from "./kiro-cli.js";
+export { additionalModelRequestFields, CodeWhispererKiroTransport, collectAssistantText, createCodeWhispererClient, streamAssistantText, toGenerateAssistantResponseInput, usageFromMetadataEvent, } from "./kiro-transport.js";
+export { ModelCache } from "./model-cache.js";
+export { discoverModelsFromCommand, parseDiscoveredModels, refreshModelCacheFromCommand } from "./model-discovery.js";
+export { ModelResolutionError, ModelResolver, normalizeModelName } from "./model-resolver.js";
+export { FALLBACK_MODELS } from "./models.js";
+export { toKiroGenerateRequest } from "./request-adapter.js";
+export type { KiroGenerateRequest, KiroModelOptions } from "./request-adapter.js";
+export { toOpenAIChatResponse, toOpenAIChatStreamResponse } from "./response-adapter.js";
+export type { KiroStreamEvent, KiroToolCallChunk } from "./response-adapter.js";
+declare const _default: {
+    id: string;
+    server: import("@opencode-ai/plugin").Plugin;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,20 @@
+import { KiroPlugin } from "./plugin.js";
+export { AcpJsonRpcClient, createAcpStdioClient, decodeJsonRpc, encodeJsonRpc } from "./acp-client.js";
+export { acpPermissionResponse, KiroAcpTransport } from "./acp-transport.js";
+export { createKiroPlugin, KiroPlugin } from "./plugin.js";
+export { detectAuth, redacted, resolveApiKey } from "./auth.js";
+export { cliChatArgs, KiroCliChatTransport, promptForCli } from "./cli-transport.js";
+export { createKiroFetch } from "./fetch-adapter.js";
+export { loadOptions } from "./config.js";
+export { getKiroCliStatus, getKiroCliVersion } from "./kiro-cli.js";
+export { additionalModelRequestFields, CodeWhispererKiroTransport, collectAssistantText, createCodeWhispererClient, streamAssistantText, toGenerateAssistantResponseInput, usageFromMetadataEvent, } from "./kiro-transport.js";
+export { ModelCache } from "./model-cache.js";
+export { discoverModelsFromCommand, parseDiscoveredModels, refreshModelCacheFromCommand } from "./model-discovery.js";
+export { ModelResolutionError, ModelResolver, normalizeModelName } from "./model-resolver.js";
+export { FALLBACK_MODELS } from "./models.js";
+export { toKiroGenerateRequest } from "./request-adapter.js";
+export { toOpenAIChatResponse, toOpenAIChatStreamResponse } from "./response-adapter.js";
+export default {
+    id: "kiro",
+    server: KiroPlugin,
+};

package/dist/kiro-cli.d.ts

@@ -0,0 +1,8 @@
+import type { AuthDiagnostics, CommandRunner } from "./auth.js";
+export interface KiroCliStatus {
+    readonly installed: boolean;
+    readonly version?: string;
+    readonly auth: AuthDiagnostics;
+}
+export declare function getKiroCliVersion(runner?: CommandRunner): Promise<string | undefined>;
+export declare function getKiroCliStatus(env?: NodeJS.ProcessEnv, runner?: CommandRunner): Promise<KiroCliStatus>;

package/dist/kiro-cli.js

@@ -0,0 +1,16 @@
+import { detectAuth, runCommand } from "./auth.js";
+export async function getKiroCliVersion(runner = runCommand) {
+    const result = await runner("kiro-cli", ["--version"]);
+    if (!result.ok)
+        return undefined;
+    return result.stdout.trim() || undefined;
+}
+export async function getKiroCliStatus(env = process.env, runner = runCommand) {
+    const version = await getKiroCliVersion(runner);
+    const auth = await detectAuth(env, runner);
+    return {
+        installed: version !== undefined,
+        auth,
+        ...(version ? { version } : {}),
+    };
+}

package/dist/kiro-transport.d.ts

@@ -0,0 +1,33 @@
+import { type GenerateAssistantResponseCommandInput, type GenerateAssistantResponseCommandOutput, type ChatResponseStream } from "@aws/codewhisperer-streaming-client";
+import type { Command } from "@smithy/smithy-client";
+import type { KiroTransport } from "./fetch-adapter.js";
+import type { KiroGenerateRequest } from "./request-adapter.js";
+import type { KiroGenerateResponse, KiroStreamEvent } from "./response-adapter.js";
+export interface KiroTransportOptions {
+    readonly region: string;
+    readonly accessToken: string;
+    readonly endpoint?: string;
+    readonly profileArn?: string;
+    readonly userAgent?: string;
+    readonly agentMode?: string;
+    readonly maxAttempts?: number;
+    readonly requestTimeoutMs?: number;
+}
+export interface CodeWhispererClientLike {
+    send(command: Command<any, any, any, any, any>): Promise<GenerateAssistantResponseCommandOutput>;
+    destroy?(): void;
+}
+export type CodeWhispererClientFactory = (options: KiroTransportOptions) => CodeWhispererClientLike;
+export declare function additionalModelRequestFields(request: KiroGenerateRequest): Record<string, unknown> | undefined;
+export declare function usageFromMetadataEvent(event: ChatResponseStream): KiroGenerateResponse["usage"] | undefined;
+export declare function createCodeWhispererClient(options: KiroTransportOptions): CodeWhispererClientLike;
+export declare function toGenerateAssistantResponseInput(request: KiroGenerateRequest, options?: Pick<KiroTransportOptions, "profileArn" | "agentMode">): GenerateAssistantResponseCommandInput;
+export declare function collectAssistantText(stream: AsyncIterable<ChatResponseStream> | undefined): Promise<KiroGenerateResponse>;
+export declare function streamAssistantText(stream: AsyncIterable<ChatResponseStream> | undefined): AsyncIterable<KiroStreamEvent>;
+export declare class CodeWhispererKiroTransport implements KiroTransport {
+    #private;
+    constructor(options: KiroTransportOptions, factory?: CodeWhispererClientFactory);
+    generate(request: KiroGenerateRequest): Promise<KiroGenerateResponse>;
+    stream(request: KiroGenerateRequest): AsyncIterable<KiroStreamEvent>;
+    dispose(): void;
+}

package/dist/kiro-transport.js

@@ -0,0 +1,250 @@
+import { CodeWhispererStreamingClient, GenerateAssistantResponseCommand, } from "@aws/codewhisperer-streaming-client";
+import { KiroPluginError } from "./errors.js";
+const DEFAULT_USER_AGENT = "KiroIDE";
+const DEFAULT_AGENT_MODE = "vibe";
+export function additionalModelRequestFields(request) {
+    const fields = {};
+    if (request.modelOptions.temperature !== undefined)
+        fields.temperature = request.modelOptions.temperature;
+    if (request.modelOptions.maxTokens !== undefined)
+        fields.max_tokens = request.modelOptions.maxTokens;
+    if (request.modelOptions.reasoningEffort) {
+        fields.output_config = {
+            effort: request.modelOptions.reasoningEffort,
+        };
+    }
+    return Object.keys(fields).length > 0 ? fields : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+export function usageFromMetadataEvent(event) {
+    const usage = event.metadataEvent?.tokenUsage;
+    if (!usage)
+        return undefined;
+    const uncachedInput = numberValue(usage.uncachedInputTokens) ?? 0;
+    const cacheRead = numberValue(usage.cacheReadInputTokens) ?? 0;
+    const cacheWrite = numberValue(usage.cacheWriteInputTokens) ?? 0;
+    const outputTokens = numberValue(usage.outputTokens);
+    return {
+        inputTokens: uncachedInput + cacheRead + cacheWrite,
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+    };
+}
+export function createCodeWhispererClient(options) {
+    const client = new CodeWhispererStreamingClient({
+        region: options.region,
+        endpoint: options.endpoint ?? `https://q.${options.region}.amazonaws.com`,
+        token: async () => ({ token: options.accessToken }),
+        customUserAgent: [[options.userAgent ?? DEFAULT_USER_AGENT]],
+        maxAttempts: options.maxAttempts ?? 3,
+        retryMode: "standard",
+    });
+    client.middlewareStack.add((next) => async (args) => {
+        args.request.headers["x-amzn-kiro-agent-mode"] = options.agentMode ?? DEFAULT_AGENT_MODE;
+        return next(args);
+    }, { step: "build", name: "addKiroAgentMode" });
+    return client;
+}
+export function toGenerateAssistantResponseInput(request, options = {}) {
+    const content = request.prompt;
+    const modelFields = additionalModelRequestFields(request);
+    return {
+        ...(options.profileArn ? { profileArn: options.profileArn } : {}),
+        agentMode: options.agentMode ?? DEFAULT_AGENT_MODE,
+        ...(modelFields ? { additionalModelRequestFields: modelFields } : {}),
+        conversationState: {
+            chatTriggerType: "MANUAL",
+            history: [
+                ...(request.system
+                    ? [
+                        {
+                            userInputMessage: {
+                                content: request.system,
+                                origin: "AI_EDITOR",
+                            },
+                        },
+                    ]
+                    : []),
+                ...request.history.map((turn) => turn.role === "assistant"
+                    ? {
+                        assistantResponseMessage: {
+                            content: turn.content,
+                        },
+                    }
+                    : {
+                        userInputMessage: {
+                            content: turn.content,
+                            origin: "AI_EDITOR",
+                        },
+                    }),
+            ],
+            currentMessage: {
+                userInputMessage: {
+                    content,
+                    modelId: request.modelId,
+                    origin: "AI_EDITOR",
+                    ...(request.images.length > 0
+                        ? {
+                            images: request.images.map((image) => ({
+                                format: image.format,
+                                source: { bytes: image.bytes },
+                            })),
+                        }
+                        : {}),
+                    ...(request.documents.length > 0
+                        ? {
+                            documents: request.documents.map((document) => ({
+                                name: document.name,
+                                format: document.format,
+                                source: { bytes: document.bytes },
+                            })),
+                        }
+                        : {}),
+                    userInputMessageContext: request.tools.length > 0 || request.toolResults.length > 0
+                        ? {
+                            ...(request.tools.length > 0
+                                ? {
+                                    tools: request.tools.map((item) => ({
+                                        toolSpecification: {
+                                            name: item.name,
+                                            ...(item.description ? { description: item.description } : {}),
+                                            inputSchema: { json: item.inputSchema },
+                                        },
+                                    })),
+                                }
+                                : {}),
+                            ...(request.toolResults.length > 0
+                                ? {
+                                    toolResults: request.toolResults.map((item) => ({
+                                        toolUseId: item.toolUseId,
+                                        content: [{ text: item.content }],
+                                        status: "SUCCESS",
+                                        ...(item.toolName ? { toolName: item.toolName } : {}),
+                                    })),
+                                }
+                                : {}),
+                        }
+                        : undefined,
+                },
+            },
+        },
+    };
+}
+export async function collectAssistantText(stream) {
+    if (!stream)
+        return { text: "" };
+    let text = "";
+    let modelId;
+    let usage;
+    for await (const event of stream) {
+        if (event.assistantResponseEvent) {
+            text += event.assistantResponseEvent.content ?? "";
+            modelId = event.assistantResponseEvent.modelId ?? modelId;
+        }
+        usage = usageFromMetadataEvent(event) ?? usage;
+        if (event.error) {
+            throw new Error(event.error.message ?? "Kiro stream returned an error event");
+        }
+    }
+    return {
+        text,
+        ...(modelId ? { modelId } : {}),
+        ...(usage ? { usage } : {}),
+    };
+}
+export async function* streamAssistantText(stream) {
+    if (!stream)
+        return;
+    const toolInputs = new Map();
+    for await (const event of stream) {
+        if (event.assistantResponseEvent?.content) {
+            yield {
+                type: "text",
+                text: event.assistantResponseEvent.content,
+                ...(event.assistantResponseEvent.modelId ? { modelId: event.assistantResponseEvent.modelId } : {}),
+            };
+        }
+        if (event.toolUseEvent?.toolUseId && event.toolUseEvent.name) {
+            const id = event.toolUseEvent.toolUseId;
+            const current = toolInputs.get(id) ?? { name: event.toolUseEvent.name, input: "" };
+            current.input += event.toolUseEvent.input ?? "";
+            current.name = event.toolUseEvent.name;
+            toolInputs.set(id, current);
+            if (event.toolUseEvent.stop) {
+                yield {
+                    type: "tool_call",
+                    id,
+                    name: current.name,
+                    arguments: current.input,
+                };
+                toolInputs.delete(id);
+            }
+        }
+        const usage = usageFromMetadataEvent(event);
+        if (usage) {
+            yield {
+                type: "text",
+                text: "",
+                usage,
+            };
+        }
+        if (event.error) {
+            throw new Error(event.error.message ?? "Kiro stream returned an error event");
+        }
+    }
+}
+async function collectChunks(chunks, fallbackModelId) {
+    let text = "";
+    let modelId;
+    let usage;
+    const toolCalls = [];
+    for await (const chunk of chunks) {
+        if (chunk.type === "tool_call") {
+            toolCalls.push(chunk);
+            modelId = chunk.modelId ?? modelId;
+            continue;
+        }
+        text += chunk.text;
+        modelId = chunk.modelId ?? modelId;
+        if (chunk.usage)
+            usage = chunk.usage;
+    }
+    return {
+        text,
+        modelId: modelId ?? fallbackModelId,
+        ...(toolCalls.length > 0 ? { toolCalls } : {}),
+        ...(usage ? { usage } : {}),
+    };
+}
+function withTimeout(promise, timeoutMs, message) {
+    if (!timeoutMs)
+        return promise;
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new KiroPluginError(message, "KIRO_TIMEOUT", 504)), timeoutMs);
+    });
+    return Promise.race([promise, deadline]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+export class CodeWhispererKiroTransport {
+    #options;
+    #client;
+    constructor(options, factory = createCodeWhispererClient) {
+        this.#options = options;
+        this.#client = factory(options);
+    }
+    async generate(request) {
+        return collectChunks(this.stream(request), request.modelId);
+    }
+    async *stream(request) {
+        const input = toGenerateAssistantResponseInput(request, this.#options);
+        const output = await withTimeout(this.#client.send(new GenerateAssistantResponseCommand(input)), this.#options.requestTimeoutMs, "Timed out waiting for Kiro response.");
+        yield* streamAssistantText(output.generateAssistantResponseResponse);
+    }
+    dispose() {
+        this.#client.destroy?.();
+    }
+}

package/dist/model-cache.d.ts

@@ -0,0 +1,19 @@
+export interface CachedModelInfo {
+    readonly id: string;
+    readonly name?: string;
+    readonly contextLimit?: number;
+    readonly outputLimit?: number;
+    readonly raw?: unknown;
+}
+export declare class ModelCache {
+    #private;
+    constructor(ttlSeconds: number);
+    update(models: ReadonlyArray<CachedModelInfo>, now?: number): void;
+    get(id: string): CachedModelInfo | undefined;
+    has(id: string): boolean;
+    all(): CachedModelInfo[];
+    ids(): string[];
+    isEmpty(): boolean;
+    isStale(now?: number): boolean;
+    get updatedAt(): number | undefined;
+}

package/dist/model-cache.js

@@ -0,0 +1,33 @@
+export class ModelCache {
+    #ttlMs;
+    #models = new Map();
+    #updatedAt = 0;
+    constructor(ttlSeconds) {
+        this.#ttlMs = ttlSeconds * 1000;
+    }
+    update(models, now = Date.now()) {
+        this.#models = new Map(models.map((model) => [model.id, model]));
+        this.#updatedAt = now;
+    }
+    get(id) {
+        return this.#models.get(id);
+    }
+    has(id) {
+        return this.#models.has(id);
+    }
+    all() {
+        return [...this.#models.values()];
+    }
+    ids() {
+        return [...this.#models.keys()].sort();
+    }
+    isEmpty() {
+        return this.#models.size === 0;
+    }
+    isStale(now = Date.now()) {
+        return this.#updatedAt === 0 || now - this.#updatedAt > this.#ttlMs;
+    }
+    get updatedAt() {
+        return this.#updatedAt === 0 ? undefined : this.#updatedAt;
+    }
+}

package/dist/model-discovery.d.ts

@@ -0,0 +1,5 @@
+import type { CommandRunner } from "./auth.js";
+import type { CachedModelInfo, ModelCache } from "./model-cache.js";
+export declare function parseDiscoveredModels(raw: string): CachedModelInfo[];
+export declare function discoverModelsFromCommand(command: string, args: ReadonlyArray<string>, runner?: CommandRunner): Promise<CachedModelInfo[]>;
+export declare function refreshModelCacheFromCommand(cache: ModelCache, command: string, args: ReadonlyArray<string>, runner?: CommandRunner): Promise<CachedModelInfo[]>;

package/dist/model-discovery.js

@@ -0,0 +1,76 @@
+import { runCommand } from "./auth.js";
+import { normalizeModelName } from "./model-resolver.js";
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function fromItem(item) {
+    if (typeof item === "string") {
+        const id = normalizeModelName(item);
+        return id ? { id, raw: item } : undefined;
+    }
+    const object = record(item);
+    if (!object)
+        return undefined;
+    const id = stringValue(object.id) ?? stringValue(object.modelId) ?? stringValue(object.model) ?? stringValue(object.name);
+    if (!id)
+        return undefined;
+    const normalized = normalizeModelName(id);
+    if (!normalized)
+        return undefined;
+    const name = stringValue(object.name) ?? stringValue(object.displayName) ?? stringValue(object.label);
+    return {
+        id: normalized,
+        ...(name ? { name } : {}),
+        raw: item,
+    };
+}
+function fromJson(value) {
+    if (Array.isArray(value))
+        return value.map(fromItem).filter((item) => item !== undefined);
+    const object = record(value);
+    if (!object)
+        return [];
+    const items = object.models ?? object.data ?? object.items;
+    return Array.isArray(items) ? fromJson(items) : [];
+}
+function fromLines(raw) {
+    return raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.includes(" ") && !line.includes("\t"))
+        .map(fromItem)
+        .filter((item) => item !== undefined);
+}
+export function parseDiscoveredModels(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        const models = fromJson(parsed);
+        if (models.length > 0)
+            return dedupe(models);
+    }
+    catch {
+        // Fall back to line parsing below.
+    }
+    return dedupe(fromLines(trimmed));
+}
+function dedupe(models) {
+    return [...new Map(models.map((model) => [model.id, model])).values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+export async function discoverModelsFromCommand(command, args, runner = runCommand) {
+    const result = await runner(command, [...args]);
+    if (!result.ok)
+        return [];
+    return parseDiscoveredModels(result.stdout);
+}
+export async function refreshModelCacheFromCommand(cache, command, args, runner = runCommand) {
+    const models = await discoverModelsFromCommand(command, args, runner);
+    if (models.length > 0)
+        cache.update(models);
+    return models;
+}

package/dist/model-resolver.d.ts

@@ -0,0 +1,29 @@
+import { ModelCache } from "./model-cache.js";
+export type ModelResolutionSource = "cache" | "hidden" | "passthrough";
+export interface ModelResolution {
+    readonly internalID: string;
+    readonly source: ModelResolutionSource;
+    readonly original: string;
+    readonly normalized: string;
+    readonly verified: boolean;
+}
+export interface ModelResolverOptions {
+    readonly cache: ModelCache;
+    readonly aliases?: Readonly<Record<string, string>>;
+    readonly hiddenModels?: Readonly<Record<string, string>>;
+    readonly disabledModels?: ReadonlyArray<string>;
+    readonly disablePassThrough?: boolean;
+}
+export declare class ModelResolutionError extends Error {
+    readonly model: string;
+    readonly suggestions: ReadonlyArray<string>;
+    constructor(message: string, model: string, suggestions: ReadonlyArray<string>);
+}
+export declare function normalizeModelName(input: string): string;
+export declare class ModelResolver {
+    #private;
+    constructor(options: ModelResolverOptions);
+    resolve(model: string): ModelResolution;
+    availableModels(): string[];
+    suggestions(model: string): string[];
+}