import { createWriteStream } from "node:fs";

import fs from "node:fs/promises";

import path from "node:path";

import { Readable } from "node:stream";

import { pipeline } from "node:stream/promises";

import type { Command } from "commander";

import { resolveAgentDir, resolveDefaultAgentId } from "../agents/agent-scope.js";

import {

listProfilesForProvider,

loadAuthProfileStoreForRuntime,

} from "../agents/auth-profiles.js";

import { updateAuthProfileStoreWithLock } from "../agents/auth-profiles/store.js";

import { resolveMemorySearchConfig } from "../agents/memory-search.js";

import { findModelInCatalog } from "../agents/model-catalog-lookup.js";

import { loadModelCatalog } from "../agents/model-catalog.js";

import {

completeWithPreparedSimpleCompletionModel,

prepareSimpleCompletionModelForAgent,

} from "../agents/simple-completion-runtime.js";

import { getRuntimeConfig } from "../config/config.js";

import { resolveAgentModelPrimaryValue } from "../config/model-input.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { callGateway, randomIdempotencyKey } from "../gateway/call.js";

import { buildGatewayConnectionDetailsWithResolvers } from "../gateway/connection-details.js";

import { isLoopbackHost } from "../gateway/net.js";

import { ADMIN_SCOPE } from "../gateway/operator-scopes.js";

import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../gateway/protocol/client-info.js";

import { generateImage, listRuntimeImageGenerationProviders } from "../image-generation/runtime.js";

import type {

ImageGenerationBackground,

ImageGenerationOutputFormat,

} from "../image-generation/types.js";

import { buildMediaUnderstandingRegistry } from "../media-understanding/provider-registry.js";

import type { RunMediaUnderstandingFileResult } from "../media-understanding/runtime-types.js";

import {

describeImageFile,

describeImageFileWithModel,

describeVideoFile,

transcribeAudioFile,

} from "../media-understanding/runtime.js";

import { getImageMetadata } from "../media/image-ops.js";

import { detectMime, extensionForMime, normalizeMimeType } from "../media/mime.js";

import { saveMediaBuffer } from "../media/store.js";

import {

createEmbeddingProvider,

registerBuiltInMemoryEmbeddingProviders,

} from "../plugin-sdk/memory-core-bundled-runtime.js";

import {

listMemoryEmbeddingProviders,

registerMemoryEmbeddingProvider,

} from "../plugins/memory-embedding-providers.js";

import { writeRuntimeJson, defaultRuntime, type RuntimeEnv } from "../runtime.js";

import { getProviderEnvVars } from "../secrets/provider-env-vars.js";

import {

normalizeLowercaseStringOrEmpty,

normalizeOptionalString,

normalizeStringifiedOptionalString,

} from "../shared/string-coerce.js";

import { formatDocsLink } from "../terminal/links.js";

import { theme } from "../terminal/theme.js";

import { canonicalizeSpeechProviderId, listSpeechProviders } from "../tts/provider-registry.js";

import {

getTtsProvider,

getTtsPersona,

listTtsPersonas,

listSpeechVoices,

resolveExplicitTtsOverrides,

resolveTtsConfig,

resolveTtsPrefsPath,

setTtsEnabled,

setTtsPersona,

setTtsProvider,

textToSpeech,

} from "../tts/tts.js";

import { generateVideo, listRuntimeVideoGenerationProviders } from "../video-generation/runtime.js";

import type { VideoGenerationResolution } from "../video-generation/types.js";

import {

isWebFetchProviderConfigured,

resolveWebFetchDefinition,

listWebFetchProviders,

} from "../web-fetch/runtime.js";

import {

isWebSearchProviderConfigured,

listWebSearchProviders,

runWebSearch,

} from "../web-search/runtime.js";

import { runCommandWithRuntime } from "./cli-utils.js";

import { removeCommandByName } from "./program/command-tree.js";

import { collectOption } from "./program/helpers.js";

type CapabilityTransport = "local" | "gateway";

const IMAGE_OUTPUT_FORMATS = ["png", "jpeg", "webp"] as const;

const IMAGE_BACKGROUNDS = ["transparent", "opaque", "auto"] as const;

const LOCAL_MODEL_RUN_SYSTEM_PROMPT = "You are a personal assistant running inside OpenClaw.";

type CapabilityMetadata = {

id: string;

description: string;

transports: Array<CapabilityTransport>;

flags: string[];

resultShape: string;

};

type CapabilityEnvelope = {

ok: boolean;

capability: string;

transport: CapabilityTransport;

provider?: string;

model?: string;

attempts: Array<Record<string, unknown>>;

inputs?: Array<Record<string, unknown>>;

outputs: Array<Record<string, unknown>>;

ignoredOverrides?: Array<Record<string, unknown>>;

error?: string;

};

const CAPABILITY_METADATA: CapabilityMetadata[] = [

{

id: "model.run",

description: "Run a one-shot inference turn through the selected model provider.",

transports: ["local", "gateway"],

flags: ["--prompt", "--file", "--model", "--local", "--gateway", "--json"],

resultShape: "normalized payloads plus provider/model attribution",

},

{

id: "model.list",

description: "List known models from the model catalog.",

transports: ["local"],

flags: ["--json"],

resultShape: "catalog entries",

},

{

id: "model.inspect",

description: "Inspect one model catalog entry.",

transports: ["local"],

flags: ["--model", "--json"],

resultShape: "single catalog entry",

},

{

id: "model.providers",

description: "List model providers discovered from the catalog.",

transports: ["local"],

flags: ["--json"],

resultShape: "provider ids with counts and defaults",

},

{

id: "model.auth.login",

description: "Run the existing provider auth login flow.",

transports: ["local"],

flags: ["--provider"],

resultShape: "interactive auth result",

},

{

id: "model.auth.logout",

description: "Remove saved auth profiles for one provider.",

transports: ["local"],

flags: ["--provider", "--json"],

resultShape: "removed profile ids",

},

{

id: "model.auth.status",

description: "Show configured model auth state.",

transports: ["local"],

flags: ["--json"],

resultShape: "model status summary",

},

{

id: "image.generate",

description: "Generate raster images with configured image providers.",

transports: ["local"],

flags: [

"--prompt",

"--model",

"--count",

"--size",

"--aspect-ratio",

"--resolution",

"--output",

"--json",

],

resultShape: "saved image files plus attempts",

},

{

id: "image.edit",

description: "Generate edited images from one or more input files.",

transports: ["local"],

flags: [

"--file",

"--prompt",

"--model",

"--size",

"--aspect-ratio",

"--resolution",

"--output-format",

"--background",

"--openai-background",

"--timeout-ms",

"--output",

"--json",

],

resultShape: "saved image files plus attempts",

},

{

id: "image.describe",

description: "Describe one image file through media-understanding providers.",

transports: ["local"],

flags: ["--file", "--prompt", "--model", "--timeout-ms", "--json"],

resultShape: "normalized text output",

},

{

id: "image.describe-many",

description: "Describe multiple image files independently.",

transports: ["local"],

flags: ["--file", "--prompt", "--model", "--timeout-ms", "--json"],

resultShape: "one text output per file",

},

{

id: "image.providers",

description: "List image generation providers.",

transports: ["local"],

flags: ["--json"],

resultShape: "provider ids and defaults",

},

{

id: "audio.transcribe",

description: "Transcribe one audio file.",

transports: ["local"],

flags: ["--file", "--model", "--json"],

resultShape: "normalized text output",

},

{

id: "audio.providers",

description: "List audio transcription providers.",

transports: ["local"],

flags: ["--json"],

resultShape: "provider ids and capabilities",

},

{

id: "tts.convert",

description: "Convert text to speech.",

transports: ["local", "gateway"],

flags: [

"--text",

"--channel",

"--voice",

"--model",

"--output",

"--local",

"--gateway",

"--json",

],

resultShape: "saved audio file plus attempts",

},

{

id: "tts.voices",

description: "List voices for a speech provider.",

transports: ["local"],

flags: ["--provider", "--json"],

resultShape: "voice entries",

},

{

id: "tts.providers",

description: "List speech providers.",

transports: ["local", "gateway"],

flags: ["--local", "--gateway", "--json"],

resultShape: "provider ids, configured state, models, voices",

},

{

id: "tts.personas",

description: "List TTS personas.",

transports: ["local", "gateway"],

flags: ["--local", "--gateway", "--json"],

resultShape: "persona ids, labels, providers, active persona",

},

{

id: "tts.status",

description: "Show gateway-managed TTS state.",

transports: ["gateway"],

flags: ["--gateway", "--json"],

resultShape: "enabled/provider state",

},

{

id: "tts.enable",

description: "Enable TTS in prefs.",

transports: ["local", "gateway"],

flags: ["--local", "--gateway", "--json"],

resultShape: "enabled state",

},

{

id: "tts.disable",

description: "Disable TTS in prefs.",

transports: ["local", "gateway"],

flags: ["--local", "--gateway", "--json"],

resultShape: "enabled state",

},

{

id: "tts.set-provider",

description: "Set the active TTS provider.",

transports: ["local", "gateway"],

flags: ["--provider", "--local", "--gateway", "--json"],

resultShape: "selected provider",

},

{

id: "tts.set-persona",

description: "Set the active TTS persona.",

transports: ["local", "gateway"],

flags: ["--persona", "--off", "--local", "--gateway", "--json"],

resultShape: "selected persona",

},

{

id: "video.generate",

description: "Generate video files with configured video providers.",

transports: ["local"],

flags: [

"--prompt",

"--model",

"--size",

"--aspect-ratio",

"--resolution",

"--duration",

"--audio",

"--watermark",

"--timeout-ms",

"--output",

"--json",

],

resultShape: "saved video files plus attempts",

},

{

id: "video.describe",

description: "Describe one video file through media-understanding providers.",

transports: ["local"],

flags: ["--file", "--model", "--json"],

resultShape: "normalized text output",

},

{

id: "video.providers",

description: "List video generation and description providers.",

transports: ["local"],

flags: ["--json"],

resultShape: "provider ids and defaults",

},

{

id: "web.search",

description: "Run provider-backed web search.",

transports: ["local"],

flags: ["--query", "--provider", "--limit", "--json"],

resultShape: "search provider result",

},

{

id: "web.fetch",

description: "Fetch URL content through configured web fetch providers.",

transports: ["local"],

flags: ["--url", "--provider", "--format", "--json"],

resultShape: "fetch provider result",

},

{

id: "web.providers",

description: "List web search and fetch providers.",

transports: ["local"],

flags: ["--json"],

resultShape: "provider ids grouped by family",

},

{

id: "embedding.create",

description: "Create embeddings through embedding providers.",

transports: ["local"],

flags: ["--text", "--provider", "--model", "--json"],

resultShape: "vectors with provider/model attribution",

},

{

id: "embedding.providers",

description: "List embedding providers.",

transports: ["local"],

flags: ["--json"],

resultShape: "provider ids and default models",

},

];

function findCapabilityMetadata(id: string): CapabilityMetadata | undefined {

return CAPABILITY_METADATA.find((entry) => entry.id === id);

}

function resolveTransport(opts: {

local?: boolean;

gateway?: boolean;

supported: Array<CapabilityTransport>;

defaultTransport: CapabilityTransport;

}): CapabilityTransport {

if (opts.local && opts.gateway) {

throw new Error("Pass only one of --local or --gateway.");

}

if (opts.local) {

if (!opts.supported.includes("local")) {

throw new Error("This command does not support --local.");

}

return "local";

}

if (opts.gateway) {

if (!opts.supported.includes("gateway")) {

throw new Error("This command does not support --gateway.");

}

return "gateway";

}

return opts.defaultTransport;

}

function emitJsonOrText(

runtime: RuntimeEnv,

json: boolean | undefined,

value: unknown,

textFormatter: (value: unknown) => string,

) {

if (json) {

writeRuntimeJson(runtime, value);

return;

}

runtime.log(textFormatter(value));

}

function formatEnvelopeForText(value: unknown): string {

const envelope = value as CapabilityEnvelope;

if (!envelope.ok) {

return `${envelope.capability} failed: ${envelope.error ?? "unknown error"}`;

}

const lines = [

`${envelope.capability} via ${envelope.transport}`,

...(envelope.provider ? [`provider: ${envelope.provider}`] : []),

...(envelope.model ? [`model: ${envelope.model}`] : []),

...(envelope.ignoredOverrides && envelope.ignoredOverrides.length > 0

? [`ignoredOverrides: ${JSON.stringify(envelope.ignoredOverrides)}`]

: []),

`outputs: ${String(envelope.outputs.length)}`,

];

for (const output of envelope.outputs) {

const pathValue = typeof output.path === "string" ? output.path : undefined;

const textValue = typeof output.text === "string" ? output.text : undefined;

if (pathValue) {

lines.push(pathValue);

} else if (textValue) {

lines.push(textValue);

} else {

lines.push(JSON.stringify(output));

}

}

return lines.join("\n");

}

function providerSummaryText(value: unknown): string {

const providers = value as Array<Record<string, unknown>>;

return providers.map((entry) => JSON.stringify(entry)).join("\n");

}

function hasOwnKeys(value: unknown): boolean {

return Boolean(

value && typeof value === "object" && Object.keys(value as Record<string, unknown>).length > 0,

);

}

function resolveSelectedProviderFromModelRef(modelRef: string | undefined): string | undefined {

return resolveModelRefOverride(modelRef).provider;

}

function getAuthProfileIdsForProvider(cfg: OpenClawConfig, providerId: string): string[] {

const agentDir = resolveAgentDir(cfg, resolveDefaultAgentId(cfg));

const store = loadAuthProfileStoreForRuntime(agentDir);

return listProfilesForProvider(store, providerId);

}

function providerHasGenericConfig(params: {

cfg: OpenClawConfig;

providerId: string;

envVars?: string[];

}): boolean {

const modelsProviders = (params.cfg.models?.providers ?? {}) as Record<string, unknown>;

const pluginEntries = (params.cfg.plugins?.entries ?? {}) as Record<string, { config?: unknown }>;

const ttsProviders = (params.cfg.messages?.tts?.providers ?? {}) as Record<string, unknown>;

const envConfigured = (params.envVars ?? []).some((envVar) =>

Boolean(process.env[envVar]?.trim()),

);

return (

getAuthProfileIdsForProvider(params.cfg, params.providerId).length > 0 ||

hasOwnKeys(modelsProviders[params.providerId]) ||

hasOwnKeys(pluginEntries[params.providerId]?.config) ||

hasOwnKeys(ttsProviders[params.providerId]) ||

envConfigured

);

}

async function writeOutputAsset(params: {

buffer: Buffer;

mimeType?: string;

originalFilename?: string;

outputPath?: string;

outputIndex: number;

outputCount: number;

subdir: string;

}) {

if (!params.outputPath) {

const saved = await saveMediaBuffer(

params.buffer,

params.mimeType,

params.subdir,

Number.MAX_SAFE_INTEGER,

params.originalFilename,

);

return { path: saved.path, mimeType: saved.contentType, size: saved.size };

}

const resolvedOutput = path.resolve(params.outputPath);

const parsed = path.parse(resolvedOutput);

const detectedMime =

(await detectMime({

buffer: params.buffer,

headerMime: params.mimeType,

})) ?? params.mimeType;

const requestedMime = normalizeMimeType(await detectMime({ filePath: resolvedOutput }));

const detectedNormalized = normalizeMimeType(detectedMime);

const canonicalDetectedExt = extensionForMime(detectedNormalized);

const fallbackExt = parsed.ext || path.extname(params.originalFilename ?? "") || "";

const ext =

parsed.ext && requestedMime === detectedNormalized

? parsed.ext

: (canonicalDetectedExt ?? fallbackExt);

const filePath =

params.outputCount <= 1

? path.join(parsed.dir, `${parsed.name}${ext}`)

: path.join(parsed.dir, `${parsed.name}-${String(params.outputIndex + 1)}${ext}`);

await fs.mkdir(path.dirname(filePath), { recursive: true });

await fs.writeFile(filePath, params.buffer);

return {

path: filePath,

mimeType: detectedNormalized ?? params.mimeType,

size: params.buffer.byteLength,

};

}

async function readInputFiles(files: string[]): Promise<Array<{ path: string; buffer: Buffer }>> {

return await Promise.all(

files.map(async (filePath) => ({

path: path.resolve(filePath),

buffer: await fs.readFile(path.resolve(filePath)),

})),

);

}

function resolveModelRefOverride(raw: string | undefined): { provider?: string; model?: string } {

const trimmed = raw?.trim();

if (!trimmed) {

return {};

}

const slash = trimmed.indexOf("/");

if (slash <= 0 || slash === trimmed.length - 1) {

return { model: trimmed };

}

return {

provider: trimmed.slice(0, slash),

model: trimmed.slice(slash + 1),

};

}

function shouldCanonicalizeModelRunRef(

model: string | undefined,

ref: { provider?: string; model?: string },

): ref is { provider: string; model: string } {

return Boolean(model && model !== model.toLowerCase() && ref.provider && ref.model);

}

async function canonicalizeModelRunRef(raw: string | undefined, cfg: OpenClawConfig) {

const model = normalizeStringifiedOptionalString(raw);

const ref = resolveModelRefOverride(model);

if (!shouldCanonicalizeModelRunRef(model, ref)) {

return model;

}

const catalog = await loadModelCatalog({ config: cfg });

const entry = findModelInCatalog(catalog, ref.provider, ref.model);

return entry ? `${entry.provider}/${entry.id}` : model;

}

function requireProviderModelOverride(

raw: string | undefined,

): { provider: string; model: string } | undefined {

const resolved = resolveModelRefOverride(raw);

if (!raw?.trim()) {

return undefined;

}

if (!resolved.provider || !resolved.model) {

throw new Error("Model overrides must use the form <provider/model>.");

}

return {

provider: resolved.provider,

model: resolved.model,

};

}

function collectModelRunText(content: Array<{ type: string; text?: string }>): string {

return content

.map((block) => (block.type === "text" && typeof block.text === "string" ? block.text : ""))

.join("")

.trim();

}

function requireModelRunPrompt(value: unknown): string {

if (typeof value !== "string" || normalizeOptionalString(value) === undefined) {

throw new Error("--prompt cannot be empty or whitespace-only.");

}

return value;

}

type ModelRunImageFile = {

path: string;

fileName: string;

mimeType: string;

data: string;

};

async function readModelRunImageFiles(files: string[] | undefined): Promise<ModelRunImageFile[]> {

if (!files || files.length === 0) {

return [];

}

return await Promise.all(

files.map(async (filePath) => {

const resolvedPath = path.resolve(filePath);

const buffer = await fs.readFile(resolvedPath);

const mimeType = normalizeMimeType(

await detectMime({

buffer,

filePath: resolvedPath,

}),

);

if (!mimeType?.startsWith("image/")) {

throw new Error(

`Unsupported --file for model run: ${resolvedPath}. Only image files are supported; use infer audio transcribe for audio files.`,

);

}

return {

path: resolvedPath,

fileName: path.basename(resolvedPath),

mimeType,

data: buffer.toString("base64"),

};

}),

);

}

async function runModelRun(params: {

prompt: string;

files?: string[];

model?: string;

transport: CapabilityTransport;

}) {

const cfg = getRuntimeConfig();

const agentId = resolveDefaultAgentId(cfg);

const imageFiles = await readModelRunImageFiles(params.files);

const messageContent =

imageFiles.length > 0

? [

{ type: "text" as const, text: params.prompt },

...imageFiles.map((image) => ({

type: "image" as const,

data: image.data,

mimeType: image.mimeType,

})),

]

: params.prompt;

const model = await canonicalizeModelRunRef(params.model, cfg);

if (params.transport === "local") {

const prepared = await prepareSimpleCompletionModelForAgent({

cfg,

agentId,

modelRef: model,

allowMissingApiKeyModes: ["aws-sdk"],

skipPiDiscovery: true,

});

if ("error" in prepared) {

throw new Error(prepared.error);

}

if (prepared.selection.provider === "codex") {

throw new Error(

'The codex provider is served by the Codex app-server agent runtime, not the local simple-completion transport. Use an openai/<model> ref with agents.defaults.agentRuntime.id: "codex", run through the gateway, or use /codex commands.',

);

}

const localModelRunSystemPrompt =

prepared.selection.provider === "openai-codex" ||

prepared.model.api === "openai-codex-responses"

? LOCAL_MODEL_RUN_SYSTEM_PROMPT

: undefined;

const result = await completeWithPreparedSimpleCompletionModel({

model: prepared.model,

auth: prepared.auth,

cfg,

context: {

...(localModelRunSystemPrompt ? { systemPrompt: localModelRunSystemPrompt } : {}),

messages: [

{

role: "user",

content: messageContent,

timestamp: Date.now(),

},

],

},

options: {

maxTokens:

typeof prepared.model.maxTokens === "number" && Number.isFinite(prepared.model.maxTokens)

? prepared.model.maxTokens

: undefined,

},

});

const text = collectModelRunText(result.content);

if (!text) {

const providerErrorMessage = (result as { errorMessage?: unknown }).errorMessage;

const detail =

typeof providerErrorMessage === "string" && providerErrorMessage.trim()

? `: ${providerErrorMessage.trim()}`

: "";

throw new Error(

`No text output returned for provider "${prepared.selection.provider}" model "${prepared.selection.modelId}"${detail}.`,

);

}

return {

ok: true,

capability: "model.run",

transport: "local" as const,

provider: prepared.selection.provider,

model: prepared.selection.modelId,

attempts: [],

...(imageFiles.length > 0

? {

inputs: imageFiles.map((image) => ({

path: image.path,

mimeType: image.mimeType,

})),

}

: {}),

outputs: [

{

text,

mediaUrl: null,

},

],

} satisfies CapabilityEnvelope;

}

const { provider, model: modelId } = resolveModelRefOverride(model);

// Provider/model overrides require trusted-operator scope. Use the backend

// shared-secret lane so local gateway smokes do not depend on paired CLI device scopes.

const hasModelOverride = Boolean(provider || modelId);

const response: {

result?: {

payloads?: Array<{ text?: string; mediaUrl?: string | null; mediaUrls?: string[] }>;

meta?: {

agentMeta?: {

provider?: string;

model?: string;

fallbackAttempts?: Array<Record<string, unknown>>;

};

};

};

} = await callGateway({

method: "agent",

params: {

agentId,

message: params.prompt,

attachments:

imageFiles.length > 0

? imageFiles.map((image) => ({

type: "image",

fileName: image.fileName,

mimeType: image.mimeType,

content: image.data,

}))

: undefined,

provider,

model: modelId,

modelRun: true,

promptMode: "none",

cleanupBundleMcpOnRunEnd: true,

idempotencyKey: randomIdempotencyKey(),

},

expectFinal: true,

timeoutMs: 120_000,

clientName: hasModelOverride ? GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT : GATEWAY_CLIENT_NAMES.CLI,

mode: hasModelOverride ? GATEWAY_CLIENT_MODES.BACKEND : GATEWAY_CLIENT_MODES.CLI,

...(hasModelOverride ? { scopes: [ADMIN_SCOPE] } : {}),

});

return {

ok: true,

capability: "model.run",

transport: "gateway" as const,

provider: response?.result?.meta?.agentMeta?.provider,

model: response?.result?.meta?.agentMeta?.model,

attempts: response?.result?.meta?.agentMeta?.fallbackAttempts ?? [],

outputs: (response?.result?.payloads ?? []).map((payload) => ({

text: payload.text,

mediaUrl: payload.mediaUrl,

mediaUrls: payload.mediaUrls,

})),

...(imageFiles.length > 0

? {

inputs: imageFiles.map((image) => ({

path: image.path,

mimeType: image.mimeType,

})),

}

: {}),

} satisfies CapabilityEnvelope;

}

async function buildModelProviders() {

const cfg = getRuntimeConfig();

const catalog = await loadModelCatalog({ config: cfg });

const selectedProvider = resolveSelectedProviderFromModelRef(

resolveAgentModelPrimaryValue(cfg.agents?.defaults?.model),

);

const grouped = new Map<

string,

{

provider: string;

count: number;

defaults: string[];

available: boolean;

configured: boolean;

selected: boolean;

}

>();

for (const entry of catalog) {

const current = grouped.get(entry.provider) ?? {

provider: entry.provider,

count: 0,

defaults: [],

available: true,

configured: providerHasGenericConfig({ cfg, providerId: entry.provider }),

selected: selectedProvider === entry.provider,

};

current.count += 1;

if (current.defaults.length < 3) {

current.defaults.push(entry.id);

}

grouped.set(entry.provider, current);

}

return [...grouped.values()].toSorted((a, b) => a.provider.localeCompare(b.provider));

}

async function runModelAuthStatus() {

const captured: string[] = [];

const { modelsStatusCommand } = await import("../commands/models/list.status-command.js");

await modelsStatusCommand(

{ json: true },

{

log: (...args) => captured.push(args.join(" ")),

error: (message) => {

throw message instanceof Error ? message : new Error(String(message));

},

exit: (code) => {

throw new Error(`exit ${code}`);

},

},

);

const raw = captured.find((line) => line.trim().startsWith("{"));

return raw ? (JSON.parse(raw) as Record<string, unknown>) : {};

}

async function runModelAuthLogout(provider: string) {

const cfg = getRuntimeConfig();

const agentDir = resolveAgentDir(cfg, resolveDefaultAgentId(cfg));

const store = loadAuthProfileStoreForRuntime(agentDir);

const profileIds = listProfilesForProvider(store, provider);

const updated = await updateAuthProfileStoreWithLock({

agentDir,

updater: (nextStore) => {

let changed = false;

for (const profileId of profileIds) {

if (nextStore.profiles[profileId]) {

delete nextStore.profiles[profileId];

changed = true;

}

if (nextStore.usageStats?.[profileId]) {

delete nextStore.usageStats[profileId];

changed = true;

}

}

if (nextStore.order?.[provider]) {

delete nextStore.order[provider];

changed = true;

}

if (nextStore.lastGood?.[provider]) {

delete nextStore.lastGood[provider];

changed = true;

}

return changed;

},

});

if (!updated) {

throw new Error(`Failed to remove saved auth profiles for provider ${provider}.`);

}

return {

provider,

removedProfiles: profileIds,

};

}

async function runImageGenerate(params: {

capability: "image.generate" | "image.edit";

prompt: string;

model?: string;

count?: number;

size?: string;

aspectRatio?: string;

resolution?: "1K" | "2K" | "4K";

outputFormat?: ImageGenerationOutputFormat;

background?: ImageGenerationBackground;

openaiBackground?: ImageGenerationBackground;

file?: string[];

output?: string;

timeoutMs?: number;

}) {

const cfg = getRuntimeConfig();

const agentDir = resolveAgentDir(cfg, resolveDefaultAgentId(cfg));

const inputImages =

params.file && params.file.length > 0

? await Promise.all(

(await readInputFiles(params.file)).map(async (entry) => ({

buffer: entry.buffer,

fileName: path.basename(entry.path),

mimeType:

(await detectMime({ buffer: entry.buffer, filePath: entry.path })) ?? "image/png",

})),

)

: undefined;

const result = await generateImage({

cfg,

agentDir,

prompt: params.prompt,

modelOverride: params.model,

count: params.count,

size: params.size,

aspectRatio: params.aspectRatio,

resolution: params.resolution,

outputFormat: params.outputFormat,

background: params.background,

providerOptions: params.openaiBackground

? { openai: { background: params.openaiBackground } }

: undefined,

timeoutMs: params.timeoutMs,

inputImages,

});

const outputs = await Promise.all(

result.images.map(async (image, index) => {

const written = await writeOutputAsset({

buffer: image.buffer,

mimeType: image.mimeType,

originalFilename: image.fileName,

outputPath: params.output,

outputIndex: index,

outputCount: result.images.length,

subdir: "generated",

});

const metadata = await getImageMetadata(image.buffer).catch(() => undefined);

return {

...written,

width: metadata?.width,

height: metadata?.height,

revisedPrompt: image.revisedPrompt,

};

}),

);

return {

ok: true,

capability: params.capability,

transport: "local" as const,

provider: result.provider,

model: result.model,

attempts: result.attempts,

outputs,

ignoredOverrides: result.ignoredOverrides,

} satisfies CapabilityEnvelope;

}

async function runImageDescribe(params: {

capability: "image.describe" | "image.describe-many";

files: string[];

model?: string;

prompt?: string;

timeoutMs?: number;

}) {

const cfg = getRuntimeConfig();

const agentDir = resolveAgentDir(cfg, resolveDefaultAgentId(cfg));

const activeModel = requireProviderModelOverride(params.model);

const prompt = normalizeOptionalString(params.prompt);

const outputs = await Promise.all(

params.files.map(async (filePath) => {

const resolvedPath = path.resolve(filePath);

const result = activeModel

? await describeImageFileWithModel({

filePath: resolvedPath,

cfg,

agentDir,

provider: activeModel.provider,

model: activeModel.model,

prompt: prompt ?? "Describe the image.",