@bogyie/opencode-kiro-plugin 0.1.0

package/dist/model-resolver.js

@@ -0,0 +1,79 @@
+export class ModelResolutionError extends Error {
+    model;
+    suggestions;
+    constructor(message, model, suggestions) {
+        super(message);
+        this.model = model;
+        this.suggestions = suggestions;
+        this.name = "ModelResolutionError";
+    }
+}
+export function normalizeModelName(input) {
+    let name = input.trim();
+    if (!name)
+        return name;
+    name = name.replace(/\[\d+[mk]\]$/i, "").toLowerCase();
+    const inverted = /^claude-(\d+)\.(\d+)-(haiku|sonnet|opus)-.+$/.exec(name);
+    if (inverted)
+        return `claude-${inverted[3]}-${inverted[1]}.${inverted[2]}`;
+    name = name.replace(/-(thinking|low|medium|high|max)$/, "");
+    const standardMinor = /^(claude-(?:haiku|sonnet|opus)-\d+)-(\d{1,2})(?:-(?:\d{8}|latest|\d+))?$/.exec(name);
+    if (standardMinor)
+        return `${standardMinor[1]}.${standardMinor[2]}`;
+    const standardMajor = /^(claude-(?:haiku|sonnet|opus)-\d+)(?:-\d{8})?$/.exec(name);
+    if (standardMajor)
+        return standardMajor[1] ?? name;
+    const legacy = /^claude-(\d+)-(\d+)-(haiku|sonnet|opus)(?:-(?:\d{8}|latest|\d+))?$/.exec(name);
+    if (legacy)
+        return `claude-${legacy[1]}.${legacy[2]}-${legacy[3]}`;
+    const dotWithDate = /^(claude-(?:(?:haiku|sonnet|opus)-\d+\.\d+|\d+\.\d+-(?:haiku|sonnet|opus)))-\d{8}$/.exec(name);
+    if (dotWithDate)
+        return dotWithDate[1] ?? name;
+    return name;
+}
+function familyOf(model) {
+    return /(haiku|sonnet|opus)/i.exec(model)?.[1]?.toLowerCase();
+}
+export class ModelResolver {
+    #cache;
+    #aliases;
+    #hiddenModels;
+    #disabledModels;
+    #disablePassThrough;
+    constructor(options) {
+        this.#cache = options.cache;
+        this.#aliases = options.aliases ?? {};
+        this.#hiddenModels = options.hiddenModels ?? {};
+        this.#disabledModels = new Set((options.disabledModels ?? []).map(normalizeModelName));
+        this.#disablePassThrough = options.disablePassThrough === true;
+    }
+    resolve(model) {
+        const aliased = this.#aliases[model] ?? this.#aliases[normalizeModelName(model)] ?? model;
+        const normalized = normalizeModelName(aliased);
+        if (this.#disabledModels.has(normalized)) {
+            throw new ModelResolutionError(`Model is disabled: ${model}`, model, this.suggestions(model));
+        }
+        if (this.#cache.has(normalized)) {
+            return { internalID: normalized, source: "cache", original: model, normalized, verified: true };
+        }
+        const hidden = this.#hiddenModels[normalized];
+        if (hidden) {
+            return { internalID: hidden, source: "hidden", original: model, normalized, verified: true };
+        }
+        if (this.#disablePassThrough) {
+            throw new ModelResolutionError(`Unsupported model: ${model}`, model, this.suggestions(model));
+        }
+        return { internalID: normalized, source: "passthrough", original: model, normalized, verified: false };
+    }
+    availableModels() {
+        return [...new Set([...this.#cache.ids(), ...Object.keys(this.#hiddenModels), ...Object.keys(this.#aliases)])].sort();
+    }
+    suggestions(model) {
+        const family = familyOf(model);
+        const available = this.availableModels();
+        if (!family)
+            return available;
+        const matching = available.filter((item) => familyOf(item) === family);
+        return matching.length > 0 ? matching : available;
+    }
+}

package/dist/models.d.ts

@@ -0,0 +1,14 @@
+export interface ProviderModelConfig {
+    readonly name?: string;
+    readonly limit?: {
+        readonly context: number;
+        readonly output: number;
+    };
+    readonly modalities?: {
+        readonly input: ReadonlyArray<"text" | "image" | "pdf">;
+        readonly output: ReadonlyArray<"text">;
+    };
+    readonly tool_call?: boolean;
+    readonly variants?: Readonly<Record<string, Record<string, unknown>>>;
+}
+export declare const FALLBACK_MODELS: Readonly<Record<string, ProviderModelConfig>>;

package/dist/models.js

@@ -0,0 +1,70 @@
+const TEXT_IMAGE_PDF = { input: ["text", "image", "pdf"], output: ["text"] };
+const TEXT_ONLY = { input: ["text"], output: ["text"] };
+export const FALLBACK_MODELS = {
+    auto: {
+        name: "Kiro Auto",
+        limit: { context: 200_000, output: 64_000 },
+        modalities: TEXT_IMAGE_PDF,
+        tool_call: true,
+    },
+    "claude-sonnet-4": {
+        name: "Claude Sonnet 4",
+        limit: { context: 200_000, output: 64_000 },
+        modalities: TEXT_IMAGE_PDF,
+        tool_call: true,
+    },
+    "claude-sonnet-4-5": {
+        name: "Claude Sonnet 4.5",
+        limit: { context: 200_000, output: 64_000 },
+        modalities: TEXT_IMAGE_PDF,
+        tool_call: true,
+    },
+    "claude-sonnet-4-6": {
+        name: "Claude Sonnet 4.6",
+        limit: { context: 1_000_000, output: 64_000 },
+        modalities: TEXT_IMAGE_PDF,
+        tool_call: true,
+    },
+    "claude-opus-4-8": {
+        name: "Claude Opus 4.8",
+        limit: { context: 1_000_000, output: 64_000 },
+        modalities: TEXT_IMAGE_PDF,
+        tool_call: true,
+    },
+    "claude-haiku-4-5": {
+        name: "Claude Haiku 4.5",
+        limit: { context: 200_000, output: 64_000 },
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tool_call: true,
+    },
+    "deepseek-3.2": {
+        name: "DeepSeek 3.2",
+        limit: { context: 128_000, output: 64_000 },
+        modalities: TEXT_ONLY,
+        tool_call: true,
+    },
+    "glm-5": {
+        name: "GLM-5",
+        limit: { context: 200_000, output: 64_000 },
+        modalities: TEXT_ONLY,
+        tool_call: true,
+    },
+    "minimax-m2.5": {
+        name: "MiniMax M2.5",
+        limit: { context: 200_000, output: 64_000 },
+        modalities: TEXT_ONLY,
+        tool_call: true,
+    },
+    "minimax-m2.1": {
+        name: "MiniMax M2.1",
+        limit: { context: 200_000, output: 64_000 },
+        modalities: TEXT_ONLY,
+        tool_call: true,
+    },
+    "qwen3-coder-next": {
+        name: "Qwen3 Coder Next",
+        limit: { context: 256_000, output: 64_000 },
+        modalities: TEXT_ONLY,
+        tool_call: true,
+    },
+};

package/dist/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import type { KiroAcpTransportOptions } from "./acp-transport.js";
+import type { KiroPluginOptions } from "./config.js";
+import type { KiroTransportOptions } from "./kiro-transport.js";
+export declare function acpTransportOptions(options: Pick<KiroPluginOptions, "requestTimeoutMs" | "trustAllTools">): KiroAcpTransportOptions;
+export declare function fetchTransportOptions(options: Pick<KiroPluginOptions, "region" | "endpoint" | "profileArn" | "userAgent" | "agentMode" | "maxAttempts" | "requestTimeoutMs">, accessToken: string): KiroTransportOptions;
+export declare function createKiroPlugin(): Plugin;
+export declare const KiroPlugin: Plugin;

package/dist/plugin.js

@@ -0,0 +1,188 @@
+import { tool } from "@opencode-ai/plugin";
+import { KiroAcpTransport } from "./acp-transport.js";
+import { detectAuth, resolveApiKey } from "./auth.js";
+import { KiroCliChatTransport } from "./cli-transport.js";
+import { loadOptions } from "./config.js";
+import { createKiroFetch } from "./fetch-adapter.js";
+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";
+import { FALLBACK_MODELS } from "./models.js";
+function mergeModels(extraModels, existing) {
+    return {
+        ...FALLBACK_MODELS,
+        ...extraModels,
+        ...(existing ?? {}),
+    };
+}
+function discoveredProviderModels(cache) {
+    return Object.fromEntries(cache.all().map((model) => [
+        model.id,
+        {
+            name: model.name ?? model.id,
+        },
+    ]));
+}
+export function acpTransportOptions(options) {
+    return {
+        trustAllTools: options.trustAllTools,
+        ...(options.requestTimeoutMs ? { promptTimeoutMs: options.requestTimeoutMs } : {}),
+    };
+}
+export function fetchTransportOptions(options, accessToken) {
+    return {
+        region: options.region,
+        accessToken,
+        maxAttempts: options.maxAttempts,
+        ...(options.endpoint ? { endpoint: options.endpoint } : {}),
+        ...(options.profileArn ? { profileArn: options.profileArn } : {}),
+        ...(options.userAgent ? { userAgent: options.userAgent } : {}),
+        ...(options.agentMode ? { agentMode: options.agentMode } : {}),
+        ...(options.requestTimeoutMs ? { requestTimeoutMs: options.requestTimeoutMs } : {}),
+    };
+}
+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);
+        modelCache.update([...Object.keys(FALLBACK_MODELS), ...Object.keys(options.extraModels)].map((id) => ({ id: normalizeModelName(id) })));
+        let discovery;
+        let discoveryAttempted = false;
+        const discoverIfStale = async () => {
+            if (options.modelDiscovery === "off" ||
+                options.modelDiscoveryCommand.length === 0 ||
+                (discoveryAttempted && !modelCache.isStale())) {
+                return;
+            }
+            discoveryAttempted = true;
+            discovery ??= refreshModelCacheFromCommand(modelCache, options.modelDiscoveryCommand[0], options.modelDiscoveryCommand.slice(1))
+                .catch(() => undefined)
+                .then(() => {
+                discovery = undefined;
+            });
+            await discovery;
+        };
+        const resolver = new ModelResolver({
+            cache: modelCache,
+            aliases: options.modelAliases,
+            hiddenModels: options.hiddenModels,
+            disabledModels: options.disabledModels,
+            disablePassThrough: options.disableModelPassThrough,
+        });
+        return {
+            config: async (config) => {
+                config.provider ??= {};
+                config.provider[options.providerID] ??= {};
+                const provider = config.provider[options.providerID];
+                provider.name ??= "Kiro";
+                provider.npm = "@ai-sdk/openai-compatible";
+                provider.api ??= baseURL;
+                provider.options ??= {};
+                provider.models = mergeModels(options.extraModels, provider.models);
+            },
+            auth: {
+                provider: options.providerID,
+                methods: [
+                    {
+                        type: "api",
+                        label: "Kiro API key",
+                        prompts: [
+                            {
+                                type: "text",
+                                key: "apiKey",
+                                message: "Enter KIRO_API_KEY",
+                                placeholder: "ksk_...",
+                            },
+                        ],
+                        authorize: async (inputs) => {
+                            const key = inputs?.apiKey;
+                            if (!key)
+                                return { type: "failed" };
+                            return { type: "success", key };
+                        },
+                    },
+                ],
+                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;
+                    return {
+                        apiKey,
+                        baseURL,
+                        fetch: createKiroFetch({
+                            resolver,
+                            ...(transport ? { transport } : {}),
+                        }),
+                    };
+                },
+            },
+            tool: {
+                kiro_status: tool({
+                    description: "Show Kiro plugin backend, auth, region, and model fallback status.",
+                    args: {},
+                    execute: async () => {
+                        const auth = await detectAuth();
+                        return {
+                            title: "Kiro status",
+                            output: [
+                                `provider: ${options.providerID}`,
+                                `backend: ${options.backend}`,
+                                `region: ${auth.region}`,
+                                `auth: ${auth.method}`,
+                                `authenticated: ${auth.authenticated ? "yes" : "no"}`,
+                                `models: ${Object.keys(FALLBACK_MODELS).length} fallback presets`,
+                                auth.message,
+                            ].join("\n"),
+                            metadata: {
+                                providerID: options.providerID,
+                                backend: options.backend,
+                                region: auth.region,
+                                authMethod: auth.method,
+                                authenticated: auth.authenticated,
+                            },
+                        };
+                    },
+                }),
+            },
+            provider: {
+                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,
+                            },
+                        },
+                    ]));
+                },
+            },
+        };
+    };
+}
+export const KiroPlugin = createKiroPlugin();

package/dist/request-adapter.d.ts

@@ -0,0 +1,93 @@
+import type { ModelResolver } from "./model-resolver.js";
+export interface OpenAIChatMessage {
+    readonly role: "system" | "user" | "assistant" | "tool";
+    readonly content?: string | ReadonlyArray<OpenAIContentPart>;
+    readonly tool_call_id?: string;
+    readonly tool_calls?: ReadonlyArray<OpenAIMessageToolCall>;
+    readonly name?: string;
+}
+export type OpenAIContentPart = {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+};
+export interface OpenAIMessageToolCall {
+    readonly id?: string;
+    readonly type?: "function";
+    readonly function?: {
+        readonly name?: string;
+        readonly arguments?: string;
+    };
+}
+export interface OpenAIChatRequest {
+    readonly model: string;
+    readonly messages: ReadonlyArray<OpenAIChatMessage>;
+    readonly stream?: boolean;
+    readonly tools?: ReadonlyArray<OpenAITool>;
+    readonly temperature?: number;
+    readonly max_tokens?: number;
+    readonly max_completion_tokens?: number;
+    readonly reasoning_effort?: string;
+    readonly reasoning?: {
+        readonly effort?: string;
+    };
+    readonly thinking?: {
+        readonly effort?: string;
+    };
+}
+export interface OpenAITool {
+    readonly type: "function";
+    readonly function: {
+        readonly name: string;
+        readonly description?: string;
+        readonly parameters?: unknown;
+    };
+}
+export interface KiroGenerateRequest {
+    readonly modelId: string;
+    readonly prompt: string;
+    readonly system?: string;
+    readonly history: ReadonlyArray<KiroConversationTurn>;
+    readonly tools: ReadonlyArray<KiroToolSpec>;
+    readonly toolResults: ReadonlyArray<KiroToolResult>;
+    readonly images: ReadonlyArray<KiroImageBlock>;
+    readonly documents: ReadonlyArray<KiroDocumentBlock>;
+    readonly modelOptions: KiroModelOptions;
+    readonly stream: boolean;
+    readonly metadata: {
+        readonly originalModel: string;
+        readonly normalizedModel: string;
+        readonly modelSource: string;
+        readonly hasTools: boolean;
+    };
+}
+export interface KiroModelOptions {
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly reasoningEffort?: string;
+}
+export interface KiroImageBlock {
+    readonly format: "png" | "jpeg" | "gif" | "webp";
+    readonly bytes: Uint8Array;
+}
+export interface KiroDocumentBlock {
+    readonly name: string;
+    readonly format: "pdf" | "txt" | "md" | "csv" | "html" | "doc" | "docx" | "xls" | "xlsx";
+    readonly bytes: Uint8Array;
+}
+export interface KiroConversationTurn {
+    readonly role: "user" | "assistant" | "tool";
+    readonly content: string;
+}
+export interface KiroToolSpec {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: unknown;
+}
+export interface KiroToolResult {
+    readonly toolUseId: string;
+    readonly content: string;
+    readonly toolName?: string;
+}
+export declare function readOpenAIRequest(input: RequestInfo | URL, init?: RequestInit): Promise<OpenAIChatRequest>;
+export declare function toKiroGenerateRequest(request: OpenAIChatRequest, resolver: ModelResolver): KiroGenerateRequest;

package/dist/request-adapter.js

@@ -0,0 +1,221 @@
+function textFromContent(content) {
+    if (content === undefined)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return content
+        .map((part) => {
+        if (part.type === "text" && typeof part.text === "string")
+            return part.text;
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function dataUrlBytes(dataUrl) {
+    const match = /^data:([^;,]+);base64,(.+)$/i.exec(dataUrl);
+    if (!match?.[1] || !match[2])
+        return undefined;
+    return {
+        mime: match[1].toLowerCase(),
+        bytes: Uint8Array.from(Buffer.from(match[2], "base64")),
+    };
+}
+function imageFormat(mime) {
+    if (mime === "image/png")
+        return "png";
+    if (mime === "image/jpeg" || mime === "image/jpg")
+        return "jpeg";
+    if (mime === "image/gif")
+        return "gif";
+    if (mime === "image/webp")
+        return "webp";
+    return undefined;
+}
+function documentFormat(mime) {
+    if (mime === "application/pdf")
+        return "pdf";
+    if (mime === "text/plain")
+        return "txt";
+    if (mime === "text/markdown")
+        return "md";
+    if (mime === "text/csv")
+        return "csv";
+    if (mime === "text/html")
+        return "html";
+    return undefined;
+}
+function partUrl(part) {
+    if (part.type === "image_url") {
+        const image = part.image_url;
+        return typeof image?.url === "string" ? image.url : undefined;
+    }
+    if (part.type === "input_image") {
+        if (typeof part.image_url === "string")
+            return part.image_url;
+        const image = part.image_url;
+        return typeof image?.url === "string" ? image.url : undefined;
+    }
+    if (part.type === "file" || part.type === "input_file") {
+        const file = part.file;
+        if (typeof file?.file_data === "string")
+            return file.file_data;
+        if (typeof part.file_data === "string")
+            return part.file_data;
+    }
+    return undefined;
+}
+function partFilename(part, fallback) {
+    const file = part.file;
+    if (typeof file?.filename === "string" && file.filename)
+        return file.filename;
+    if (typeof part.filename === "string" && part.filename)
+        return part.filename;
+    return fallback;
+}
+function mediaFromContent(content) {
+    if (!Array.isArray(content))
+        return { images: [], documents: [] };
+    const images = [];
+    const documents = [];
+    for (const [index, part] of content.entries()) {
+        const url = partUrl(part);
+        if (!url)
+            continue;
+        const decoded = dataUrlBytes(url);
+        if (!decoded)
+            continue;
+        const imgFormat = imageFormat(decoded.mime);
+        if (imgFormat) {
+            images.push({ format: imgFormat, bytes: decoded.bytes });
+            continue;
+        }
+        const docFormat = documentFormat(decoded.mime);
+        if (docFormat) {
+            documents.push({
+                name: partFilename(part, `attachment-${index + 1}.${docFormat}`),
+                format: docFormat,
+                bytes: decoded.bytes,
+            });
+        }
+    }
+    return { images, documents };
+}
+function toolSpecs(tools) {
+    return (tools ?? []).map((tool) => ({
+        name: tool.function.name,
+        ...(tool.function.description ? { description: tool.function.description } : {}),
+        inputSchema: tool.function.parameters ?? { type: "object", properties: {} },
+    }));
+}
+function requestedToolCallIds(messages) {
+    const ids = new Set();
+    for (const message of messages) {
+        if (message.role !== "assistant")
+            continue;
+        for (const toolCall of message.tool_calls ?? []) {
+            if (toolCall.id)
+                ids.add(toolCall.id);
+        }
+    }
+    return ids;
+}
+function toolNameById(messages) {
+    const names = new Map();
+    for (const message of messages) {
+        if (message.role !== "assistant")
+            continue;
+        for (const toolCall of message.tool_calls ?? []) {
+            if (toolCall.id && toolCall.function?.name)
+                names.set(toolCall.id, toolCall.function.name);
+        }
+    }
+    return names;
+}
+function toolResults(messages) {
+    const requested = requestedToolCallIds(messages);
+    const names = toolNameById(messages);
+    const results = new Map();
+    for (const message of messages) {
+        if (message.role !== "tool" || !message.tool_call_id)
+            continue;
+        if (requested.size > 0 && !requested.has(message.tool_call_id))
+            continue;
+        const toolName = message.name ?? names.get(message.tool_call_id);
+        results.set(message.tool_call_id, {
+            toolUseId: message.tool_call_id,
+            content: textFromContent(message.content),
+            ...(toolName ? { toolName } : {}),
+        });
+    }
+    return [...results.values()];
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function positiveInteger(value) {
+    const number = finiteNumber(value);
+    if (number === undefined || number < 1)
+        return undefined;
+    return Math.floor(number);
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function modelOptions(request) {
+    const temperature = finiteNumber(request.temperature);
+    const maxTokens = positiveInteger(request.max_completion_tokens) ?? positiveInteger(request.max_tokens);
+    const reasoningEffort = nonEmptyString(request.reasoning_effort) ?? nonEmptyString(request.reasoning?.effort) ?? nonEmptyString(request.thinking?.effort);
+    return {
+        ...(temperature !== undefined ? { temperature } : {}),
+        ...(maxTokens !== undefined ? { maxTokens } : {}),
+        ...(reasoningEffort ? { reasoningEffort } : {}),
+    };
+}
+export async function readOpenAIRequest(input, init) {
+    if (init?.body) {
+        const raw = typeof init.body === "string" ? init.body : new TextDecoder().decode(init.body);
+        return JSON.parse(raw);
+    }
+    if (input instanceof Request) {
+        return (await input.clone().json());
+    }
+    throw new Error("Missing OpenAI-compatible request body");
+}
+export function toKiroGenerateRequest(request, resolver) {
+    const resolved = resolver.resolve(request.model);
+    const system = request.messages
+        .filter((message) => message.role === "system")
+        .map((message) => textFromContent(message.content))
+        .filter(Boolean)
+        .join("\n\n");
+    const turns = request.messages
+        .filter((message) => message.role !== "system")
+        .map((message) => {
+        const content = textFromContent(message.content);
+        return content ? { role: message.role, content } : undefined;
+    })
+        .filter((item) => item !== undefined);
+    const current = turns.at(-1);
+    const history = turns.slice(0, -1);
+    const currentMessage = request.messages.filter((message) => message.role !== "system").at(-1);
+    const media = mediaFromContent(currentMessage?.content);
+    return {
+        modelId: resolved.internalID,
+        prompt: current?.content ?? "",
+        history,
+        tools: toolSpecs(request.tools),
+        toolResults: toolResults(request.messages),
+        images: media.images,
+        documents: media.documents,
+        modelOptions: modelOptions(request),
+        ...(system ? { system } : {}),
+        stream: request.stream === true,
+        metadata: {
+            originalModel: request.model,
+            normalizedModel: resolved.normalized,
+            modelSource: resolved.source,
+            hasTools: Boolean(request.tools?.length),
+        },
+    };
+}