@uniai-test-1/cli 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,3690 @@
+#!/usr/bin/env node
+
+// src/commands/init.ts
+import { fileURLToPath } from "node:url";
+
+// src/lib/pat.ts
+import * as readline from "node:readline";
+import { Writable } from "node:stream";
+
+// src/lib/messages.ts
+var MSG = {
+  // PAT
+  patMissingNonTty: "No PAT provided. Pass --token <PAT>, set the UNIAI_TOKEN env var, or run in an interactive terminal.",
+  patHowTo: "Generate a PAT in the UniAI web console (log in, then Personal Center -> Security tab -> Personal Access Tokens -> Generate).",
+  patInvalidFormat: 'Invalid token format: a UniAI PAT must start with "uap_".',
+  patPrompt: "Paste your UniAI PAT (starts with uap_): ",
+  // node / env
+  nodeUnavailable: (p) => `Could not locate a usable Node.js executable (process.execPath = "${p}").`,
+  // config
+  configWriteFailed: (p) => `Failed to write config at "${p}"; restored the previous version from backup.`,
+  // bundle
+  bundleSourceMissing: (p) => `Bundled MCP server not found in the package at "${p}". The @uniai/cli build may be incomplete.`,
+  bundleCopyFailed: (p) => `Failed to copy the MCP server bundle to "${p}".`,
+  // results
+  initDone: "UniAI MCP server installed. Restart Codex CLI to start using the tools.",
+  uninstallDone: "UniAI MCP server removed. Your other Codex configuration was left untouched.",
+  notInstalled: "UniAI MCP server is not installed.",
+  // runtime failures (direct commands)
+  noTokenForDirect: "No UniAI token. Run `uniai auth login --token <PAT>`, set UNIAI_TOKEN, or pass --token <PAT>.",
+  authFailed: "Authentication failed \u2014 your PAT may be invalid or expired. Generate a new one in the UniAI web console, then run `uniai auth login --token <PAT>`.",
+  accessForbidden: "Access forbidden \u2014 your PAT may be missing a required scope for this command (e.g. `read:credits` for `uniai usage`). Review or recreate the token with the needed scopes in the UniAI web console.",
+  insufficientCredits: "Out of credits \u2014 top up in the UniAI web console, then retry.",
+  networkUnreachable: "Cannot reach the UniAI API. Check your network, or pass --api-base <url> for a custom/on-prem endpoint.",
+  requestTimeout: "The request timed out \u2014 the service may be busy. Try again in a moment.",
+  diskPermission: "Permission denied writing to disk \u2014 check the target file/directory permissions."
+};
+function humanizeError(raw) {
+  const s = raw.toLowerCase();
+  if (/(?<![\w-])403(?![\w-])|forbidden/.test(s)) return MSG.accessForbidden;
+  if (/(?<![\w-])401(?![\w-])|unauthorized|invalid token|invalid .*pat/.test(s)) return MSG.authFailed;
+  if (/(?<![\w-])(402|40201)(?![\w-])|insufficient|not enough credit|余额/.test(s)) return MSG.insufficientCredits;
+  if (/econnrefused|enotfound|eai_again|getaddrinfo|fetch failed|network|socket hang up/.test(s))
+    return MSG.networkUnreachable;
+  if (/timed out|timeout|aborted|operation was aborted/.test(s)) return MSG.requestTimeout;
+  if (/eacces|permission denied|eperm/.test(s)) return MSG.diskPermission;
+  return raw;
+}
+
+// src/lib/pat.ts
+var PAT_PREFIX = "uap_";
+var PAT_FORMAT = /^uap_[A-Za-z0-9_-]{24,}$/;
+function validatePatFormat(token) {
+  const t = token.trim();
+  if (t.length === 0) return { ok: false, reason: "empty" };
+  if (!t.startsWith(PAT_PREFIX)) return { ok: false, reason: "missing-prefix" };
+  if (!PAT_FORMAT.test(t)) return { ok: false, reason: "bad-format" };
+  return { ok: true };
+}
+async function resolvePat(opts) {
+  const fromFlag = opts.tokenFlag?.trim();
+  if (fromFlag) return ensureValid(fromFlag);
+  const fromEnv = opts.envToken?.trim();
+  if (fromEnv) return ensureValid(fromEnv);
+  if (!opts.isTty) throw new Error(MSG.patMissingNonTty);
+  const entered = (await opts.promptHidden()).trim();
+  return ensureValid(entered);
+}
+function ensureValid(token) {
+  if (!validatePatFormat(token).ok) throw new Error(MSG.patInvalidFormat);
+  return token;
+}
+function promptHiddenStdin(query) {
+  return new Promise((resolve2, reject) => {
+    let queryShown = false;
+    const muted = new Writable({
+      write(chunk, _enc, cb) {
+        if (!queryShown && chunk.toString().includes(query)) {
+          process.stdout.write(query);
+          queryShown = true;
+        }
+        cb();
+      }
+    });
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: muted,
+      terminal: true
+    });
+    rl.on("error", reject);
+    rl.question(query, (answer) => {
+      rl.close();
+      process.stdout.write("\n");
+      resolve2(answer);
+    });
+  });
+}
+
+// src/lib/paths.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function codexHome() {
+  const override = process.env.CODEX_HOME?.trim();
+  return override && override.length > 0 ? override : join(homedir(), ".codex");
+}
+function codexConfigPath() {
+  return join(codexHome(), "config.toml");
+}
+function uniaiHome() {
+  return join(homedir(), ".uniai");
+}
+function uniaiBundlePath() {
+  return join(uniaiHome(), "mcp-server.bundle.mjs");
+}
+function uniaiConfigPath() {
+  return join(uniaiHome(), "config.json");
+}
+function agentsSkillsDir() {
+  const override = process.env.AGENTS_SKILLS_DIR?.trim();
+  return override && override.length > 0 ? override : join(homedir(), ".agents", "skills");
+}
+function projectSkillsDir(cwd = process.cwd()) {
+  return join(cwd, ".agents", "skills");
+}
+function resolveSkillsDir(global) {
+  return global ? agentsSkillsDir() : projectSkillsDir();
+}
+
+// ../codex-shared/src/codex-config.ts
+function tomlEscape(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function tomlInlineStringArray(items) {
+  return `[${items.map((s) => `"${tomlEscape(s)}"`).join(", ")}]`;
+}
+function tomlInlineTable(record) {
+  const keys = Object.keys(record).sort();
+  if (keys.length === 0) return "{}";
+  const pairs = keys.map((k) => `${k} = "${tomlEscape(record[k])}"`);
+  return `{ ${pairs.join(", ")} }`;
+}
+function isSectionHeaderLine(line) {
+  return /^\s*\[/.test(line);
+}
+function splitTopLevelBlocks(text) {
+  const blocks = [];
+  let current = null;
+  let floating = [];
+  const isCommentOrBlank = (l) => l.trim().length === 0 || l.trim().startsWith("#");
+  for (const line of text.split("\n")) {
+    if (isSectionHeaderLine(line)) {
+      if (current) blocks.push(current);
+      current = { header: line.trim(), lines: [...floating, line] };
+      floating = [];
+    } else if (isCommentOrBlank(line)) {
+      floating.push(line);
+    } else {
+      if (current === null) {
+        current = { header: null, lines: [...floating, line] };
+      } else {
+        current.lines.push(...floating, line);
+      }
+      floating = [];
+    }
+  }
+  if (current) {
+    current.lines.push(...floating);
+    blocks.push(current);
+  } else if (floating.some((l) => l.trim().length > 0)) {
+    blocks.push({ header: null, lines: floating });
+  }
+  return blocks;
+}
+function extractNativeSections(existing, isManaged, markerLines) {
+  const kept = [];
+  for (const block of splitTopLevelBlocks(existing)) {
+    if (block.header !== null && isManaged(block.header)) {
+      continue;
+    }
+    const cleaned = block.lines.filter((l) => !markerLines.has(l.trim()));
+    let start = 0;
+    let end = cleaned.length;
+    while (start < end && cleaned[start].trim().length === 0) start++;
+    while (end > start && cleaned[end - 1].trim().length === 0) end--;
+    if (end > start) {
+      kept.push(cleaned.slice(start, end).join("\n"));
+    }
+  }
+  return kept.join("\n\n");
+}
+function mergeManagedConfigToml(existing, managedBlock, isManaged, markerLines) {
+  const native = existing ? extractNativeSections(existing, isManaged, markerLines) : "";
+  const managed = managedBlock.replace(/\s+$/, "");
+  if (!managed && !native) return "";
+  if (!managed) return `${native}
+`;
+  if (!native) return `${managed}
+`;
+  return `${managed}
+
+${native}
+`;
+}
+
+// src/lib/config-merge.ts
+var UNIAI_CLI_MARKER = "# === @uniai/cli managed MCP server \u2014 do not edit by hand ===";
+var MANAGED_MARKER_LINES = /* @__PURE__ */ new Set([UNIAI_CLI_MARKER]);
+function isManagedUniaiSection(headerLine) {
+  return headerLine.trim() === "[mcp_servers.uniai]";
+}
+function mergeManagedConfigToml2(existing, managedBlock) {
+  return mergeManagedConfigToml(
+    existing,
+    managedBlock,
+    isManagedUniaiSection,
+    MANAGED_MARKER_LINES
+  );
+}
+function buildUniaiBlock(opts) {
+  const envInline = tomlInlineTable({
+    UNIAI_API_BASE: opts.uniaiApiBase,
+    UNIAI_TOKEN: opts.uniaiToken
+  });
+  return [
+    UNIAI_CLI_MARKER,
+    "[mcp_servers.uniai]",
+    `command = "${tomlEscape(opts.nodeAbsPath)}"`,
+    `args = ${tomlInlineStringArray([opts.bundleAbsPath])}`,
+    `env = ${envInline}`,
+    "enabled = true",
+    "startup_timeout_sec = 30",
+    "tool_timeout_sec = 300"
+  ].join("\n");
+}
+
+// src/lib/install.ts
+import {
+  existsSync,
+  mkdirSync,
+  copyFileSync,
+  readFileSync,
+  writeFileSync,
+  rmSync,
+  renameSync
+} from "node:fs";
+import { dirname } from "node:path";
+function readConfigOrNull(configPath) {
+  try {
+    return readFileSync(configPath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function installBundle(srcBundle, destBundle) {
+  if (!existsSync(srcBundle)) {
+    throw new Error(`bundle-source-missing:${srcBundle}`);
+  }
+  mkdirSync(dirname(destBundle), { recursive: true });
+  copyFileSync(srcBundle, destBundle);
+}
+function backupConfig(configPath) {
+  if (!existsSync(configPath)) return null;
+  const bak = `${configPath}.bak`;
+  copyFileSync(configPath, bak);
+  return bak;
+}
+function writeConfigAtomic(configPath, content, bakPath) {
+  const tmp = `${configPath}.tmp`;
+  mkdirSync(dirname(configPath), { recursive: true });
+  try {
+    writeFileSync(tmp, content, { mode: 420 });
+    renameSync(tmp, configPath);
+  } catch (err) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    if (bakPath && existsSync(bakPath)) {
+      try {
+        copyFileSync(bakPath, configPath);
+      } catch {
+      }
+    }
+    throw err;
+  }
+}
+function removeBundle(destBundle) {
+  if (existsSync(destBundle)) rmSync(destBundle, { force: true });
+  try {
+    rmSync(dirname(destBundle), { recursive: false });
+  } catch {
+  }
+}
+function nodeAvailable() {
+  return typeof process.execPath === "string" && existsSync(process.execPath);
+}
+function collectStatus(configPath, bundlePath) {
+  const cfg = readConfigOrNull(configPath);
+  const apiBaseMatch = cfg?.match(/UNIAI_API_BASE\s*=\s*"([^"]*)"/);
+  return {
+    configPath,
+    configExists: cfg !== null,
+    uniaiSectionPresent: cfg !== null && cfg.includes("[mcp_servers.uniai]"),
+    apiBase: apiBaseMatch?.[1] ?? null,
+    bundlePath,
+    bundleExists: existsSync(bundlePath),
+    nodePath: process.execPath,
+    nodeOk: nodeAvailable()
+  };
+}
+
+// src/lib/config.ts
+import { readFile, writeFile, mkdir, rm } from "node:fs/promises";
+var DEFAULT_API_BASE = "https://www.uniai.ai/api/v1";
+var DEFAULT_SKILL_REMOTE = "Clion-a/uniai-skills";
+async function readConfig() {
+  try {
+    const raw = await readFile(uniaiConfigPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(patch) {
+  const current = await readConfig();
+  const next = { ...current, ...patch };
+  await mkdir(uniaiHome(), { recursive: true, mode: 448 });
+  await writeFile(uniaiConfigPath(), JSON.stringify(next, null, 2) + "\n", { mode: 384 });
+}
+function maskToken(t) {
+  return t.length <= 14 ? "***" : `${t.slice(0, 8)}\u2026${t.slice(-4)}`;
+}
+async function clearConfig() {
+  await rm(uniaiConfigPath(), { force: true });
+}
+async function unsetConfigKeys(keys) {
+  const current = await readConfig();
+  for (const k of keys) delete current[k];
+  if (Object.keys(current).length === 0) {
+    await clearConfig();
+    return;
+  }
+  await mkdir(uniaiHome(), { recursive: true, mode: 448 });
+  await writeFile(uniaiConfigPath(), JSON.stringify(current, null, 2) + "\n", { mode: 384 });
+}
+var str = (v) => typeof v === "string" && v.trim().length > 0 ? v.trim() : void 0;
+async function resolveEnv(flags) {
+  const cfg = await readConfig();
+  const token = str(flags.token) ?? str(process.env.UNIAI_TOKEN) ?? cfg.token;
+  if (!token) {
+    throw new Error(MSG.noTokenForDirect);
+  }
+  const baseUrl = (str(flags["api-base"]) ?? str(process.env.UNIAI_API_BASE) ?? cfg.apiBase ?? DEFAULT_API_BASE).replace(/\/+$/, "");
+  return { baseUrl, token };
+}
+
+// src/commands/init.ts
+function bundledServerPath() {
+  return fileURLToPath(new URL("./mcp-server.bundle.mjs", import.meta.url));
+}
+async function runInit(flags) {
+  if (!nodeAvailable()) {
+    console.error(MSG.nodeUnavailable(process.execPath));
+    return 1;
+  }
+  let token;
+  try {
+    token = await resolvePat({
+      tokenFlag: flags.token ?? null,
+      envToken: process.env.UNIAI_TOKEN,
+      isTty: Boolean(process.stdin.isTTY),
+      promptHidden: () => promptHiddenStdin(MSG.patPrompt)
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    console.error(MSG.patHowTo);
+    return 1;
+  }
+  const apiBase = (flags.apiBase ?? "").trim() || DEFAULT_API_BASE;
+  const bundleSrc = bundledServerPath();
+  const bundleDest = uniaiBundlePath();
+  try {
+    installBundle(bundleSrc, bundleDest);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    if (errMsg.startsWith("bundle-source-missing:")) {
+      console.error(MSG.bundleSourceMissing(bundleSrc));
+    } else {
+      console.error(MSG.bundleCopyFailed(bundleDest));
+    }
+    return 1;
+  }
+  const configPath = codexConfigPath();
+  const existing = readConfigOrNull(configPath);
+  const block = buildUniaiBlock({
+    uniaiApiBase: apiBase,
+    uniaiToken: token,
+    bundleAbsPath: bundleDest,
+    nodeAbsPath: process.execPath
+  });
+  const merged = mergeManagedConfigToml2(existing, block);
+  const bak = backupConfig(configPath);
+  try {
+    writeConfigAtomic(configPath, merged, bak);
+  } catch {
+    console.error(MSG.configWriteFailed(configPath));
+    return 1;
+  }
+  const after = readConfigOrNull(configPath);
+  if (after === null || !after.includes("[mcp_servers.uniai]")) {
+    console.error(MSG.configWriteFailed(configPath));
+    return 1;
+  }
+  console.log(MSG.initDone);
+  console.log(`  config : ${configPath}`);
+  console.log(`  bundle : ${bundleDest}`);
+  console.log(`  api    : ${apiBase}`);
+  return 0;
+}
+
+// src/commands/uninstall.ts
+async function runUninstall() {
+  const configPath = codexConfigPath();
+  const existing = readConfigOrNull(configPath);
+  if (existing !== null && existing.includes("[mcp_servers.uniai]")) {
+    const merged = mergeManagedConfigToml2(existing, "");
+    const bak = backupConfig(configPath);
+    try {
+      writeConfigAtomic(configPath, merged, bak);
+    } catch {
+      console.error(MSG.configWriteFailed(configPath));
+      return 1;
+    }
+  }
+  removeBundle(uniaiBundlePath());
+  console.log(MSG.uninstallDone);
+  console.log(`  config : ${configPath}`);
+  return 0;
+}
+
+// src/commands/status.ts
+function tokenReadiness() {
+  const env = process.env.UNIAI_TOKEN?.trim();
+  if (env && env.length > 0) return "ready (from env UNIAI_TOKEN)";
+  return "not set in env (config-embedded token used at runtime if installed)";
+}
+async function runStatus() {
+  const s = collectStatus(codexConfigPath(), uniaiBundlePath());
+  console.log("UniAI CLI status");
+  console.log(`  config.toml   : ${s.configPath}  [${s.configExists ? "present" : "not found"}]`);
+  console.log(`  uniai section : ${s.uniaiSectionPresent ? "installed" : "not installed"}`);
+  console.log(`  bundle        : ${s.bundlePath}  [${s.bundleExists ? "present" : "missing"}]`);
+  console.log(`  node          : ${s.nodePath}  (${process.version})`);
+  const apiBaseLine = s.apiBase ? `${s.apiBase} (from config)` : `${DEFAULT_API_BASE} (default; override per-install via --api-base)`;
+  console.log(`  api-base      : ${apiBaseLine}`);
+  console.log(`  token         : ${tokenReadiness()}`);
+  if (!s.uniaiSectionPresent) {
+    console.log("");
+    console.log(MSG.notInstalled + " Run `uniai init` to install.");
+  }
+  return 0;
+}
+
+// src/commands/update.ts
+import { spawn } from "node:child_process";
+
+// src/lib/version.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+// src/commands/update.ts
+var PKG = "@uniai/cli";
+var REGISTRY_URL = `https://registry.npmjs.org/${PKG}/latest`;
+function cmpVersion(a, b) {
+  const pa = a.split("-")[0].split(".").map(Number);
+  const pb = b.split("-")[0].split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+async function fetchLatest() {
+  const res = await fetch(REGISTRY_URL, { headers: { accept: "application/json" } });
+  if (!res.ok) throw new Error(`npm registry returned HTTP ${res.status}`);
+  const body = await res.json();
+  if (!body.version) throw new Error("npm registry response missing version field");
+  return body.version;
+}
+function npmInstallLatest() {
+  return new Promise((resolve2) => {
+    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    const child = spawn(npm, ["install", "-g", `${PKG}@latest`], { stdio: "inherit" });
+    child.on("error", () => resolve2(1));
+    child.on("close", (code) => resolve2(code ?? 1));
+  });
+}
+async function runUpdate(_rest, flags) {
+  const asJson = flags.json === true || flags.json === "true";
+  const checkOnly = flags.check === true;
+  let latest;
+  try {
+    latest = await fetchLatest();
+  } catch (err) {
+    const m = `Could not check for updates: ${err instanceof Error ? err.message : String(err)}`;
+    if (asJson) process.stdout.write(JSON.stringify({ ok: false, error: m }) + "\n");
+    else process.stderr.write(m + "\n");
+    return 1;
+  }
+  const updateAvailable = cmpVersion(latest, VERSION) > 0;
+  if (!updateAvailable) {
+    if (asJson) {
+      process.stdout.write(JSON.stringify({ ok: true, current: VERSION, latest, updateAvailable: false, updated: false }) + "\n");
+    } else {
+      process.stdout.write(`@uniai/cli is up to date (${VERSION}).
+`);
+    }
+    return 0;
+  }
+  if (checkOnly) {
+    if (asJson) {
+      process.stdout.write(JSON.stringify({ ok: true, current: VERSION, latest, updateAvailable: true, updated: false }) + "\n");
+    } else {
+      process.stdout.write(`A newer @uniai/cli is available: ${VERSION} -> ${latest}. Run \`uniai update\` (or \`npm i -g ${PKG}@latest\`).
+`);
+    }
+    return 0;
+  }
+  if (!asJson) process.stderr.write(`Updating @uniai/cli ${VERSION} -> ${latest} ...
+`);
+  const code = await npmInstallLatest();
+  if (asJson) {
+    process.stdout.write(JSON.stringify({ ok: code === 0, current: VERSION, latest, updateAvailable: true, updated: code === 0 }) + "\n");
+  } else if (code === 0) {
+    process.stdout.write(`Updated to ${latest}.
+`);
+  } else {
+    process.stderr.write(`Update failed (npm exited ${code}). Try \`npm i -g ${PKG}@latest\` manually.
+`);
+  }
+  return code === 0 ? 0 : 1;
+}
+
+// ../uniai-core/src/lib/uniai-client.ts
+var POLL_MAX_MS = 27e4;
+function isTransientNetworkError(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.cause?.code;
+  if (typeof code === "string" && [
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EPIPE",
+    "UND_ERR_SOCKET",
+    "UND_ERR_CONNECT_TIMEOUT"
+  ].includes(code)) {
+    return true;
+  }
+  return err.name === "TypeError" && /fetch failed/i.test(err.message);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function callUniAI(env, method, path, body, opts) {
+  const timeoutMs = opts?.timeoutMs ?? 3e4;
+  const maxAttempts = Math.max(1, opts?.attempts ?? 3);
+  let url = `${env.baseUrl}${path}`;
+  if (opts?.query) {
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(opts.query)) {
+      if (v !== void 0 && v !== null) params.set(k, String(v));
+    }
+    const qs = params.toString();
+    if (qs) url += (url.includes("?") ? "&" : "?") + qs;
+  }
+  let lastErr;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+      res = await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${env.token}`,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 && method !== "GET" ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`UniAI ${method} ${path} timed out after ${timeoutMs}ms`);
+      }
+      lastErr = err;
+      if (isTransientNetworkError(err) && attempt < maxAttempts) {
+        await sleep(attempt * 400);
+        continue;
+      }
+      throw err;
+    }
+    clearTimeout(timer);
+    if (!res.ok) {
+      let bodyText = "";
+      try {
+        bodyText = (await res.text()).slice(0, 200);
+      } catch {
+        bodyText = "<failed to read body>";
+      }
+      throw new Error(`UniAI ${method} ${path} -> HTTP ${res.status}: ${bodyText}`);
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  }
+  throw lastErr instanceof Error ? lastErr : new Error(`UniAI ${method} ${path} failed`);
+}
+var PollTimeoutError = class extends Error {
+  lastSnapshot;
+  constructor(path, maxMs, lastSnapshot) {
+    super(
+      `UniAI poll ${path} timed out after ${maxMs}ms; last snapshot: ${lastSnapshot ? JSON.stringify(lastSnapshot).slice(0, 200) : "<none>"}`
+    );
+    this.name = "PollTimeoutError";
+    this.lastSnapshot = lastSnapshot;
+  }
+};
+async function pollTask(env, path, opts) {
+  const deadline = Date.now() + opts.maxMs;
+  let lastSnapshot;
+  while (Date.now() < deadline) {
+    try {
+      const snap = await callUniAI(env, "GET", path, void 0, {
+        // 单次 GET 用更短超时, 避免把整体 budget 耗在一次卡住的请求上
+        timeoutMs: Math.min(15e3, deadline - Date.now() + 1e3)
+      });
+      lastSnapshot = snap;
+      const verdict = opts.isTerminal(snap);
+      if (verdict === "done") return { status: "done", snapshot: snap };
+      if (verdict === "failed") return { status: "failed", snapshot: snap };
+    } catch (err) {
+      console.error(
+        `[uniai-mcp] poll ${path} transient error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    await new Promise((r) => setTimeout(r, opts.intervalMs));
+  }
+  throw new PollTimeoutError(path, opts.maxMs, lastSnapshot);
+}
+
+// ../uniai-core/src/lib/file-input.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { basename } from "node:path";
+var EXT_CONTENT_TYPE = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  webm: "audio/webm",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4",
+  flac: "audio/flac",
+  aac: "audio/aac"
+};
+function extensionToContentType(filename) {
+  const m = /\.([a-zA-Z0-9]+)$/.exec(filename);
+  const ext = m ? m[1].toLowerCase() : "";
+  return EXT_CONTENT_TYPE[ext] ?? "application/octet-stream";
+}
+var ACCEPTED_UPLOAD_MIMES = {
+  image: ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"],
+  video: ["video/mp4", "video/webm", "video/quicktime"],
+  audio: ["audio/mpeg", "audio/wav", "audio/ogg", "audio/webm", "audio/aac", "audio/mp4", "audio/x-m4a"]
+};
+var UPLOAD_EXT_CONTENT_TYPE = {
+  image: { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp", gif: "image/gif", svg: "image/svg+xml" },
+  video: { mp4: "video/mp4", m4v: "video/mp4", mov: "video/quicktime", qt: "video/quicktime", webm: "video/webm" },
+  audio: { mp3: "audio/mpeg", wav: "audio/wav", ogg: "audio/ogg", webm: "audio/webm", m4a: "audio/mp4", aac: "audio/aac" }
+};
+var UPLOAD_FALLBACK_MIME = {
+  image: "image/png",
+  video: "video/mp4",
+  audio: "audio/mpeg"
+};
+function resolveUploadContentType(filename, currentContentType, kind) {
+  if (ACCEPTED_UPLOAD_MIMES[kind].includes(currentContentType)) return currentContentType;
+  const m = /\.([a-zA-Z0-9]+)$/.exec(filename);
+  const ext = m ? m[1].toLowerCase() : "";
+  return UPLOAD_EXT_CONTENT_TYPE[kind][ext] ?? UPLOAD_FALLBACK_MIME[kind];
+}
+function classifyFileInput(input) {
+  const s = input.trim();
+  if (/^data:/i.test(s)) return "base64";
+  if (/^https?:\/\//i.test(s)) return "url";
+  return "path";
+}
+function parseDataUrl(dataUrl) {
+  const m = /^data:([^;,]+)?(;base64)?,(.*)$/is.exec(dataUrl.trim());
+  if (!m) throw new Error("invalid data URL");
+  const contentType = m[1] || "application/octet-stream";
+  const isBase64 = !!m[2];
+  const data = m[3] ?? "";
+  const buffer = isBase64 ? Buffer.from(data, "base64") : Buffer.from(decodeURIComponent(data), "utf-8");
+  if (buffer.length === 0) throw new Error("data URL has empty payload");
+  return { buffer, contentType };
+}
+function extFromContentType(contentType) {
+  for (const [ext, ct] of Object.entries(EXT_CONTENT_TYPE)) {
+    if (ct === contentType) return ext;
+  }
+  return "bin";
+}
+async function resolveFileInput(input) {
+  const kind = classifyFileInput(input);
+  if (kind === "base64") {
+    const { buffer: buffer2, contentType } = parseDataUrl(input);
+    return { buffer: buffer2, filename: `upload.${extFromContentType(contentType)}`, contentType };
+  }
+  if (kind === "url") {
+    const res = await fetch(input.trim());
+    if (!res.ok) {
+      throw new Error(`failed to download ${input}: HTTP ${res.status}`);
+    }
+    const arrayBuf = await res.arrayBuffer();
+    const buffer2 = Buffer.from(arrayBuf);
+    let filename2 = "download";
+    try {
+      filename2 = basename(new URL(input.trim()).pathname) || "download";
+    } catch {
+    }
+    const headerType = res.headers.get("content-type")?.split(";")[0]?.trim();
+    const contentType = headerType || extensionToContentType(filename2);
+    return { buffer: buffer2, filename: filename2, contentType };
+  }
+  const buffer = await readFile2(input);
+  const filename = basename(input);
+  return { buffer, filename, contentType: extensionToContentType(filename) };
+}
+async function postMultipart(env, path, fileField, file, extra, opts) {
+  const timeoutMs = opts?.timeoutMs ?? 6e4;
+  const url = `${env.baseUrl}${path}`;
+  const form = new FormData();
+  const blob = new Blob([file.buffer], { type: file.contentType });
+  form.append(fileField, blob, file.filename);
+  if (extra) {
+    for (const [k, v] of Object.entries(extra)) {
+      if (v !== void 0) form.append(k, v);
+    }
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${env.token}`,
+        // 不设 Content-Type，让 fetch 按 FormData 自动带 multipart boundary
+        Accept: "application/json"
+      },
+      body: form,
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      let bodyText = "";
+      try {
+        bodyText = (await res.text()).slice(0, 200);
+      } catch {
+        bodyText = "<failed to read body>";
+      }
+      throw new Error(`UniAI POST ${path} -> HTTP ${res.status}: ${bodyText}`);
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new Error(`UniAI POST ${path} timed out after ${timeoutMs}ms`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ../uniai-core/src/lib/ensure-image-url.ts
+var UPLOAD_ENDPOINT = {
+  image: "/storage/upload/image",
+  // 50MB，JPEG/PNG/GIF/WebP/SVG，内部 auto-compress
+  video: "/storage/upload/video",
+  // 100MB，MP4/WebM/MOV
+  audio: "/storage/upload/audio"
+  // 50MB，MP3/WAV/OGG/M4A/FLAC/AAC（Seedance omni 参考音频走这条）
+};
+async function ensureMediaUrl(env, input, kind) {
+  const trimmed = input.trim();
+  if (trimmed === "") {
+    throw new Error(`${kind} input is empty (expected a file path, http(s) URL, or data URL)`);
+  }
+  const inputKind = classifyFileInput(trimmed);
+  if (inputKind === "url") {
+    return trimmed;
+  }
+  let file;
+  try {
+    file = await resolveFileInput(trimmed);
+  } catch (err) {
+    const msg2 = err instanceof Error ? err.message : String(err);
+    if (inputKind === "path" && /ENOENT|no such file|not found/i.test(msg2)) {
+      throw new Error(
+        `Reference ${kind} file not found or not readable: "${trimmed}". Do NOT download a remote or generated ${kind} to a local file and then pass that path \u2014 pass the ${kind} URL directly instead (e.g. the URL returned by generate_image/generate_video). If it is a file the user uploaded, use the exact absolute path printed in the upload message, unchanged.`
+      );
+    }
+    throw err;
+  }
+  file.contentType = resolveUploadContentType(file.filename, file.contentType, kind);
+  const res = await postMultipart(env, UPLOAD_ENDPOINT[kind], "file", file);
+  const url = res.url;
+  if (typeof url !== "string" || url.trim() === "") {
+    throw new Error(`${kind} upload succeeded but no URL was returned`);
+  }
+  return url;
+}
+async function ensureImageUrl(env, input) {
+  return ensureMediaUrl(env, input, "image");
+}
+function isStableSignedR2Url(url) {
+  return /[?&]X-Amz-(Signature|Credential)=/i.test(url);
+}
+async function stabilizeMediaUrl(env, input, kind) {
+  const trimmed = input.trim();
+  if (trimmed === "" || classifyFileInput(trimmed) !== "url") return input;
+  if (isStableSignedR2Url(trimmed)) return trimmed;
+  try {
+    const file = await resolveFileInput(trimmed);
+    file.contentType = resolveUploadContentType(file.filename, file.contentType, kind);
+    const res = await postMultipart(env, UPLOAD_ENDPOINT[kind], "file", file);
+    const url = res.url;
+    return typeof url === "string" && url.trim() !== "" ? url.trim() : trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+
+// ../uniai-core/src/lib/model-catalog.ts
+function asArray(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (raw && typeof raw === "object") {
+    const o = raw;
+    if (Array.isArray(o.models)) return o.models;
+    if (Array.isArray(o.data)) return o.data;
+    if (Array.isArray(o.items)) return o.items;
+  }
+  return [];
+}
+async function fetchImageModels(env) {
+  try {
+    const raw = await callUniAI(env, "GET", "/art/models", void 0, {
+      timeoutMs: 1e4
+    });
+    return asArray(raw).filter(
+      (m) => m && typeof m.modelId === "string" && m.modelId.trim() !== ""
+    );
+  } catch (err) {
+    console.error(
+      `[uniai-mcp] fetchImageModels failed (degrading to defaults): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return [];
+  }
+}
+async function fetchVideoModels(env) {
+  try {
+    const raw = await callUniAI(env, "GET", "/video-agent-v2/models", void 0, {
+      timeoutMs: 1e4
+    });
+    return asArray(raw).filter(
+      (m) => m && typeof m.id === "string" && m.id.trim() !== ""
+    );
+  } catch (err) {
+    console.error(
+      `[uniai-mcp] fetchVideoModels failed (degrading to defaults): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return [];
+  }
+}
+
+// ../uniai-core/src/lib/generation-confirm.ts
+function makeStep(key, message, field) {
+  return {
+    key,
+    message,
+    schema: { type: "object", properties: { [key]: field }, required: [key] }
+  };
+}
+function enumField(title, options, def, labels) {
+  const base = labels ? { type: "string", title, oneOf: options.map((v, i) => ({ const: v, title: labels[i] ?? v })) } : { type: "string", title, enum: options };
+  return def !== void 0 ? { ...base, default: def } : base;
+}
+function pickEnum(wanted, allowed, preferred) {
+  const list2 = allowed && allowed.length > 0 ? allowed : void 0;
+  if (wanted && (!list2 || list2.includes(wanted))) return wanted;
+  if (!list2) return preferred;
+  return list2.includes(preferred) ? preferred : list2[0];
+}
+function clampInt(v, min, max, dflt) {
+  const n = typeof v === "number" && Number.isFinite(v) ? Math.round(v) : dflt;
+  return Math.min(max, Math.max(min, n));
+}
+function modelLabel(name, credits) {
+  return typeof credits === "number" && credits > 0 ? `${name} (~${credits} credits)` : name;
+}
+function clampToModelEnum(value, allowed, preferred) {
+  if (value === void 0) return void 0;
+  if (!allowed || allowed.length === 0) return value;
+  if (allowed.includes(value)) return value;
+  return preferred && allowed.includes(preferred) ? preferred : allowed[0];
+}
+function snapDurationToModel(value, model) {
+  const min = model?.minDuration ?? 2;
+  const max = model?.maxDuration ?? 15;
+  let d = Math.min(max, Math.max(min, Math.round(value)));
+  const steps = model?.durationSteps;
+  if (steps && steps.length > 0) {
+    d = steps.reduce((best, s) => Math.abs(s - d) < Math.abs(best - d) ? s : best, steps[0]);
+  }
+  return d;
+}
+function recommendImageModel(models, args, pinnedModel) {
+  if (models.length === 0) return null;
+  const byId = (id) => id ? models.find((m) => m.modelId === id) : void 0;
+  return byId(args.model) ?? byId(pinnedModel) ?? byId("gpt-image-2") ?? models[0];
+}
+function imageParamsFor(model, args) {
+  const ars = model.supportedAspectRatios ?? ["1:1", "16:9", "9:16", "4:3", "3:4"];
+  const ress = model.supportedResolutions ?? ["1K", "2K", "4K"];
+  const quals = model.supportedQualities ?? [];
+  const maxCount = model.maxCount ?? 4;
+  const aspectRatio = pickEnum(args.aspectRatio, ars, "1:1");
+  const resolution = ress.length > 0 ? pickEnum(args.resolution, ress, "1K") : void 0;
+  const quality = quals.length > 0 ? pickEnum(args.quality, quals, "low") : void 0;
+  const count = clampInt(args.count, 1, maxCount, 1);
+  const defaults = {
+    aspectRatio,
+    count,
+    ...resolution !== void 0 ? { resolution } : {},
+    ...quality !== void 0 ? { quality } : {}
+  };
+  const steps = [];
+  if (ars.length >= 2) {
+    steps.push(makeStep("aspectRatio", `\u9009\u62E9\u753B\u9762\u6BD4\u4F8B\uFF08\u63A8\u8350\uFF1A${aspectRatio}\uFF09`, enumField("Aspect ratio", ars, aspectRatio)));
+  }
+  if (ress.length >= 2 && resolution !== void 0) {
+    steps.push(makeStep("resolution", `\u9009\u62E9\u5206\u8FA8\u7387\uFF08\u66F4\u9AD8\u66F4\u8D39\u79EF\u5206\uFF0C\u63A8\u8350\uFF1A${resolution}\uFF09`, enumField("Resolution", ress, resolution)));
+  }
+  if (quals.length >= 2 && quality !== void 0) {
+    steps.push(makeStep("quality", `\u9009\u62E9\u753B\u8D28\uFF08\u66F4\u9AD8\u753B\u8D28\u66F4\u8D39\u79EF\u5206\uFF0C\u63A8\u8350\uFF1A${quality}\uFF09`, enumField("Quality", quals, quality)));
+  }
+  if (maxCount > 1) {
+    steps.push(
+      makeStep("count", `\u9009\u62E9\u751F\u6210\u5F20\u6570\uFF081-${maxCount}\uFF0C\u6BCF\u591A\u4E00\u5F20\u66F4\u8D39\u79EF\u5206\uFF0C\u63A8\u8350\uFF1A${count}\uFF09`, {
+        type: "integer",
+        title: "Count",
+        minimum: 1,
+        maximum: maxCount,
+        default: count
+      })
+    );
+  }
+  return { steps, defaults };
+}
+function planImageConfirmation(models, args, opts) {
+  const pinned = opts?.pinnedModel && models.some((m) => m.modelId === opts.pinnedModel) ? opts.pinnedModel : void 0;
+  const rec = recommendImageModel(models, args, pinned);
+  if (!rec) return null;
+  const refNote = args.referenceImageCount && args.referenceImageCount > 0 ? `\uFF08\u542B ${args.referenceImageCount} \u5F20\u53C2\u8003\u56FE\uFF09` : "";
+  const recLabel = modelLabel(rec.displayName || rec.modelId, rec.estimatedCredits);
+  const labelOf = (id) => {
+    const m = models.find((x) => x.modelId === id);
+    return m ? modelLabel(m.displayName || m.modelId, m.estimatedCredits) : id;
+  };
+  const modelStepFor = (preselect, message) => makeStep(
+    "model",
+    message,
+    enumField(
+      "Model",
+      models.map((m) => m.modelId),
+      preselect,
+      models.map((m) => modelLabel(m.displayName || m.modelId, m.estimatedCredits))
+    )
+  );
+  const requested = typeof args.model === "string" ? models.find((m) => m.modelId === args.model)?.modelId : void 0;
+  let modelStep;
+  let fixedModelId;
+  if (opts?.enforceModelConfirm) {
+    if (requested && pinned && requested === pinned) {
+      modelStep = null;
+      fixedModelId = pinned;
+    } else if (!requested && pinned) {
+      modelStep = null;
+      fixedModelId = pinned;
+    } else if (requested && pinned && requested !== pinned) {
+      modelStep = modelStepFor(
+        requested,
+        `\u786E\u8BA4\u66F4\u6362\u56FE\u7247\u751F\u6210\u6A21\u578B${refNote}\uFF08\u4F60\u6B64\u524D\u786E\u8BA4\u7684\u662F\u300C${labelOf(pinned)}\u300D\uFF0C\u672C\u6B21\u8BF7\u6C42\u6362\u6210\u300C${labelOf(requested)}\u300D\uFF0C\u786E\u8BA4\u6216\u6539\u56DE\uFF09`
+      );
+      fixedModelId = void 0;
+    } else {
+      modelStep = modelStepFor(requested ?? rec.modelId, `\u786E\u8BA4\u56FE\u7247\u751F\u6210\u6A21\u578B${refNote}\uFF08\u63A8\u8350\uFF1A${recLabel}\uFF09`);
+      fixedModelId = void 0;
+    }
+  } else {
+    modelStep = requested ? null : modelStepFor(rec.modelId, `\u786E\u8BA4\u56FE\u7247\u751F\u6210\u6A21\u578B${refNote}\uFF08\u63A8\u8350\uFF1A${recLabel}\uFF09`);
+    fixedModelId = requested;
+  }
+  const buildParams = (modelId) => {
+    const m = models.find((x) => x.modelId === modelId) ?? rec;
+    return imageParamsFor(m, args);
+  };
+  const recommended = {
+    model: rec.modelId,
+    ...imageParamsFor(rec, args).defaults
+  };
+  return { modelStep, fixedModelId, buildParams, recommended };
+}
+var MODE_FOR_VIDEO_TYPE = {
+  text2video: "text",
+  image2video: "first_frame",
+  start_end_frame: "first_frame",
+  reference_to_video: "reference",
+  video_to_video: "video_edit",
+  video_continuation: "video_continuation"
+};
+function videoModelSupportsType(model, type) {
+  if (type === "text2video") return true;
+  const inputs = model.inputs;
+  if (!inputs || typeof inputs !== "object" || Object.keys(inputs).length === 0) {
+    return true;
+  }
+  if (type === "start_end_frame") {
+    const ffSlots = inputs["first_frame"]?.slots ?? [];
+    return ffSlots.some((s) => s.role === "last_frame");
+  }
+  const mode = MODE_FOR_VIDEO_TYPE[type] ?? type;
+  if (inputs[mode]) return true;
+  if (type === "video_to_video" && inputs["video_reference"]) return true;
+  return false;
+}
+function slotCapacityForType(slots, type) {
+  let total = 0;
+  const seenGroups = /* @__PURE__ */ new Set();
+  for (const s of slots) {
+    if (s.type !== type) continue;
+    if (s.groupKey) {
+      if (seenGroups.has(s.groupKey)) continue;
+      seenGroups.add(s.groupKey);
+      total += Number(s.groupMax ?? s.max ?? 0);
+    } else {
+      total += Number(s.max ?? 0);
+    }
+  }
+  return total;
+}
+function videoModelCanAcceptContent(model, type, content) {
+  if (!videoModelSupportsType(model, type)) return false;
+  const { image, video, audio } = content;
+  if (image + video + audio === 0) return true;
+  const mode = MODE_FOR_VIDEO_TYPE[type] ?? type;
+  const slots = model.inputs?.[mode]?.slots ?? [];
+  if (slots.length === 0) return true;
+  if (image > 0 && slotCapacityForType(slots, "image") < image) return false;
+  if (video > 0 && slotCapacityForType(slots, "video") < video) return false;
+  if (audio > 0 && slotCapacityForType(slots, "audio") < audio) return false;
+  return true;
+}
+function recommendVideo(models, type, args, pinnedModel, content) {
+  if (models.length === 0) return null;
+  const counts = content ?? { image: 0, video: 0, audio: 0 };
+  const usable = models.filter((m) => videoModelCanAcceptContent(m, type, counts));
+  const pool = usable.length > 0 ? usable : models;
+  const byId = (id) => id ? pool.find((m) => m.id === id) : void 0;
+  const rec = byId(args.model) ?? byId(pinnedModel) ?? pool.find((m) => m.isDefault) ?? pool[0];
+  const aspectRatio = pickEnum(args.aspectRatio, rec?.supportedAspectRatios, "16:9");
+  const wantDuration = typeof args.duration === "number" && Number.isFinite(args.duration) ? args.duration : 5;
+  const duration = snapDurationToModel(wantDuration, rec);
+  const resolution = rec?.supportedResolutions && rec.supportedResolutions.length > 0 ? pickEnum(args.resolution, rec.supportedResolutions, rec.defaultResolution ?? "720p") : void 0;
+  return {
+    recommendedModelId: rec?.id,
+    usableModels: pool,
+    aspectRatio,
+    duration,
+    resolution,
+    model: rec
+  };
+}
+function videoParamsFor(model, args, type) {
+  const ars = model?.supportedAspectRatios ?? [];
+  const ress = model?.supportedResolutions ?? [];
+  const durSteps = model?.durationSteps ?? [];
+  const min = model?.minDuration ?? 2;
+  const max = model?.maxDuration ?? 15;
+  const aspectRatio = pickEnum(args.aspectRatio, ars, "16:9");
+  const wantDuration = typeof args.duration === "number" && Number.isFinite(args.duration) ? args.duration : 5;
+  const duration = snapDurationToModel(wantDuration, model);
+  const resolution = ress.length > 0 ? pickEnum(args.resolution, ress, model?.defaultResolution ?? "720p") : void 0;
+  const audioApplicable = model?.supportsAudio === true && type !== "video_to_video";
+  const defaults = {
+    aspectRatio,
+    duration,
+    // 数字；若离散 step 被选中会被字符串覆盖，工具侧统一 Number() 还原
+    ...resolution !== void 0 ? { resolution } : {},
+    ...audioApplicable ? { audio: "on" } : {}
+  };
+  const steps = [];
+  if (ars.length >= 2) {
+    steps.push(makeStep("aspectRatio", `\u9009\u62E9\u753B\u9762\u6BD4\u4F8B\uFF08\u63A8\u8350\uFF1A${aspectRatio}\uFF09`, enumField("Aspect ratio", ars, aspectRatio)));
+  }
+  if (durSteps.length >= 2) {
+    steps.push(
+      makeStep(
+        "duration",
+        `\u9009\u62E9\u65F6\u957F\uFF08\u63A8\u8350\uFF1A${duration}s\uFF09`,
+        enumField("Duration", durSteps.map(String), String(duration), durSteps.map((s) => `${s}s`))
+      )
+    );
+  } else if (max > min) {
+    steps.push(
+      makeStep("duration", `\u9009\u62E9\u65F6\u957F\u79D2\u6570\uFF08${min}-${max}\uFF0C\u8D8A\u957F\u8D8A\u8D39\u79EF\u5206\uFF0C\u63A8\u8350\uFF1A${duration}\uFF09`, {
+        type: "integer",
+        title: "Duration (seconds)",
+        minimum: min,
+        maximum: max,
+        default: duration
+      })
+    );
+  }
+  if (ress.length >= 2 && resolution !== void 0) {
+    steps.push(makeStep("resolution", `\u9009\u62E9\u5206\u8FA8\u7387\uFF08\u66F4\u9AD8\u66F4\u8D39\u79EF\u5206\uFF0C\u63A8\u8350\uFF1A${resolution}\uFF09`, enumField("Resolution", ress, resolution)));
+  }
+  if (audioApplicable) {
+    steps.push(
+      makeStep("audio", `\u662F\u5426\u751F\u6210\u58F0\u97F3\uFF08\u6709\u58F0\u66F4\u8D39\u79EF\u5206\uFF0C\u63A8\u8350\uFF1A\u6709\u58F0\uFF09`, enumField("Audio", ["on", "off"], "on", ["\u6709\u58F0\uFF08\u80CC\u666F\u97F3/\u97F3\u6548\uFF09", "\u9759\u97F3"]))
+    );
+  }
+  return { steps, defaults };
+}
+function planVideoConfirmation(models, type, args, opts) {
+  const content = opts?.content;
+  const usable = models.filter(
+    (m) => videoModelCanAcceptContent(m, type, content ?? { image: 0, video: 0, audio: 0 })
+  );
+  const pinned = opts?.pinnedModel && (usable.length > 0 ? usable : models).some((m) => m.id === opts.pinnedModel) ? opts.pinnedModel : void 0;
+  const rec = recommendVideo(models, type, args, pinned, content);
+  if (!rec) return null;
+  const vLabel = (m) => modelLabel(m.nameZh || m.name || m.id);
+  const recLabel = rec.model ? vLabel(rec.model) : "\u5E73\u53F0\u9ED8\u8BA4";
+  const labelOf = (id) => {
+    const m = rec.usableModels.find((x) => x.id === id);
+    return m ? vLabel(m) : id;
+  };
+  const platformPick = rec.usableModels.find((m) => m.isDefault)?.id ?? rec.usableModels[0]?.id;
+  const modelStepFor = (preselect, message) => makeStep(
+    "model",
+    message,
+    enumField(
+      "Model",
+      rec.usableModels.map((m) => m.id),
+      preselect,
+      rec.usableModels.map(vLabel)
+    )
+  );
+  const requested = typeof args.model === "string" ? rec.usableModels.find((m) => m.id === args.model)?.id : void 0;
+  let modelStep;
+  let fixedModelId;
+  if (opts?.enforceModelConfirm) {
+    if (requested && pinned && requested === pinned) {
+      modelStep = null;
+      fixedModelId = pinned;
+    } else if (!requested && pinned) {
+      if (type === "text2video") {
+        modelStep = null;
+        fixedModelId = pinned;
+      } else {
+        modelStep = modelStepFor(
+          platformPick ?? pinned,
+          `\u786E\u8BA4\u89C6\u9891\u751F\u6210\u6A21\u578B\uFF08\u6A21\u5F0F ${type}\uFF0C\u5DF2\u4E0A\u4F20\u7D20\u6750\uFF1B\u63A8\u8350\u300C${labelOf(platformPick ?? pinned)}\u300D\uFF0C\u53EF\u6539\u9009\uFF09`
+        );
+        fixedModelId = void 0;
+      }
+    } else if (requested && pinned && requested !== pinned) {
+      modelStep = modelStepFor(
+        requested,
+        `\u786E\u8BA4\u66F4\u6362\u89C6\u9891\u751F\u6210\u6A21\u578B\uFF08\u6A21\u5F0F ${type}\uFF1B\u4F60\u6B64\u524D\u786E\u8BA4\u7684\u662F\u300C${labelOf(pinned)}\u300D\uFF0C\u672C\u6B21\u8BF7\u6C42\u6362\u6210\u300C${labelOf(requested)}\u300D\uFF0C\u786E\u8BA4\u6216\u6539\u56DE\uFF09`
+      );
+      fixedModelId = void 0;
+    } else {
+      modelStep = modelStepFor(requested ?? rec.recommendedModelId, `\u786E\u8BA4\u89C6\u9891\u751F\u6210\u6A21\u578B\uFF08\u6A21\u5F0F ${type}\uFF0C\u63A8\u8350\uFF1A${recLabel}\uFF09`);
+      fixedModelId = void 0;
+    }
+  } else {
+    modelStep = requested ? null : modelStepFor(rec.recommendedModelId, `\u786E\u8BA4\u89C6\u9891\u751F\u6210\u6A21\u578B\uFF08\u6A21\u5F0F ${type}\uFF0C\u63A8\u8350\uFF1A${recLabel}\uFF09`);
+    fixedModelId = requested;
+  }
+  const buildParams = (modelId) => {
+    const m = rec.usableModels.find((x) => x.id === modelId) ?? rec.model;
+    return videoParamsFor(m, args, type);
+  };
+  const recommended = {
+    ...rec.recommendedModelId ? { model: rec.recommendedModelId } : {},
+    ...videoParamsFor(rec.model, args, type).defaults
+  };
+  return { modelStep, fixedModelId, buildParams, recommended };
+}
+function sanitizeContent(content, schema) {
+  if (!content) return {};
+  const out = {};
+  for (const key of Object.keys(schema.properties)) {
+    const v = content[key];
+    if (v === void 0 || v === null || v === "") continue;
+    const propType = schema.properties[key]?.type;
+    if ((propType === "integer" || propType === "number") && typeof v !== "number") continue;
+    if (propType === "string" && typeof v !== "string") continue;
+    out[key] = v;
+  }
+  return out;
+}
+async function elicitStep(elicit, step) {
+  try {
+    return await elicit({ message: step.message, requestedSchema: step.schema });
+  } catch {
+    return null;
+  }
+}
+async function resolveConfirmation(plan, opts) {
+  const { elicit } = opts;
+  if (opts.unattended) {
+    return { status: "proceed", values: plan.recommended, confirmed: false };
+  }
+  const unavailable = (values2, confirmed) => opts.requireConfirm ? { status: "cancelled" } : { status: "proceed", values: values2, confirmed };
+  if (!elicit) {
+    return unavailable(plan.recommended, false);
+  }
+  const recModel = typeof plan.recommended.model === "string" ? plan.recommended.model : "";
+  let chosenModelId;
+  if (plan.modelStep) {
+    const modelRes = await elicitStep(elicit, plan.modelStep);
+    if (modelRes === null) {
+      return unavailable(plan.recommended, false);
+    }
+    if (modelRes.action !== "accept") {
+      return { status: "cancelled" };
+    }
+    const clean = sanitizeContent(modelRes.content, plan.modelStep.schema);
+    chosenModelId = typeof clean.model === "string" && clean.model || plan.fixedModelId || recModel;
+  } else {
+    chosenModelId = plan.fixedModelId || recModel;
+  }
+  const { steps, defaults } = plan.buildParams(chosenModelId);
+  const values = { ...defaults };
+  if (chosenModelId) values.model = chosenModelId;
+  for (const step of steps) {
+    const res = await elicitStep(elicit, step);
+    if (res === null) {
+      return unavailable(values, true);
+    }
+    if (res.action !== "accept") {
+      return { status: "cancelled" };
+    }
+    const clean = sanitizeContent(res.content, step.schema);
+    if (clean[step.key] !== void 0) values[step.key] = clean[step.key];
+  }
+  return { status: "proceed", values, confirmed: plan.modelStep !== null || steps.length > 0 };
+}
+function cancelledResult(mediaKind, adjustable) {
+  return {
+    content: [
+      {
+        type: "text",
+        // 文案刻意不写「然后重试」——那会诱导 agent 立刻重发(重弹确认,用户体验=拒绝后一直弹)。
+        // 取消是用户的明确决定:停手、问用户、等其改了请求或明确要求重试再说,不要自动重发。
+        text: `${mediaKind} generation was cancelled by the user at the confirmation step. Nothing was generated and no credits were charged. Do NOT re-issue this generation on your own. Ask the user how they want to adjust the request (${adjustable}) and wait for their reply; only generate again if they change the request or explicitly tell you to retry.`
+      }
+    ]
+  };
+}
+
+// ../uniai-core/src/tools/types.ts
+var AGENT_GENERATION_SOURCE = "codex";
+function toMcpError(err, prefix) {
+  const msg2 = err instanceof Error ? err.message : String(err);
+  return {
+    isError: true,
+    content: [{ type: "text", text: `${prefix}: ${msg2}` }]
+  };
+}
+
+// ../uniai-core/src/tools/generate-image.ts
+var STYLE_MAP = {
+  auto: "auto",
+  photography: "<photography>",
+  portrait: "<portrait>",
+  anime: "<anime>",
+  oil_painting: "<oil painting>",
+  watercolor: "<watercolor>",
+  sketch: "<sketch>",
+  cartoon: "<cartoon>",
+  flat: "<flat illustration>"
+};
+function mapImageStyle(friendly) {
+  return STYLE_MAP[friendly.trim().toLowerCase()];
+}
+var generateImageTool = {
+  name: "generate_image",
+  description: "Generate an image from a text prompt using UniAI image models \u2014 optionally guided by reference images (image-to-image: variation, style or character consistency). Use when the user asks for an image, picture, illustration, photo, or any visual creation from a description, or wants a new image based on an existing/uploaded one. The image model is chosen by the platform automatically. Returns a URL to the generated image (not inline image bytes; fetch via curl if you need the file).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      prompt: {
+        type: "string",
+        description: "Image description in natural language. Required."
+      },
+      model: {
+        type: "string",
+        description: 'Optional UniAI image model id. Defaults to "gpt-image-2" (strong typography + precise semantics). Leave unset unless the user names a different model.'
+      },
+      aspectRatio: {
+        type: "string",
+        description: `Aspect ratio. gpt-image-2 supports "1:1" (default), "16:9", "9:16", "4:3", "3:4", "21:9", "3:1". Defaults to "1:1". Supported ratios are per-model; the confirmation popup offers the selected model's ratios.`,
+        default: "1:1"
+      },
+      resolution: {
+        type: "string",
+        description: 'Output resolution \u2014 PER-MODEL. gpt-image-2 is 1K only; nano-banana supports "1K"/"2K"/"4K" (and nano-banana-2 also "0.5K"). Leave unset to use the model default; the confirmation popup offers the selected model\'s supported resolutions. (Models with quality tiers like gpt-image-2 use `quality` instead of resolution.)'
+      },
+      quality: {
+        type: "string",
+        description: 'Render quality for gpt-image-2: "low" (default \u2014 fast, cheapest), "medium", or "high". Cost rises steeply (high \u2248 20\xD7 low). Use "low" for drafts/iterations, "medium" for normal final assets, and "high" only for dense text/typography, identity-sensitive work, or when the user explicitly asks for top quality.',
+        enum: ["low", "medium", "high"],
+        default: "low"
+      },
+      count: {
+        type: "number",
+        description: "How many images to generate, 1-4 (default 1). Only use >1 when the user explicitly wants multiple options \u2014 each extra image costs additional credits.",
+        minimum: 1,
+        maximum: 4,
+        default: 1
+      },
+      negativePrompt: {
+        type: "string",
+        description: 'What to AVOID in the image (e.g. "blurry, low quality, extra fingers, watermark, text"). Optional.'
+      },
+      style: {
+        type: "string",
+        description: 'Preset visual style. Default "auto" (let the model decide). Use only when the user wants a specific look; otherwise describe the style in the prompt instead.',
+        enum: ["auto", "photography", "portrait", "anime", "oil_painting", "watercolor", "sketch", "cartoon", "flat"]
+      },
+      seed: {
+        type: "number",
+        description: "Random seed for reproducible results \u2014 reuse the same seed + prompt to regenerate the same image (e.g. to tweak a prompt while keeping composition). Optional."
+      },
+      referenceImages: {
+        type: "array",
+        items: { type: "string" },
+        description: "Image-to-image reference(s): each a local file path, an http(s) URL, or a base64 data URL. Guides generation toward the reference (variation, style or character consistency). For images the user uploaded, pass their local file paths \u2014 the tool uploads them for you; never invent a URL. Optional; up to 5 (gpt-image-2). Each reference adds credits."
+      },
+      resumeTaskId: {
+        type: "string",
+        description: 'Resume an existing image task by its task id (the one returned in a "still generating" message) instead of starting a new one. When set, ALL other parameters are ignored \u2014 the tool only continues polling that task and returns its result once ready. It does NOT create a new image and does NOT charge extra credits. Leave unset for a normal new generation.'
+      }
+    },
+    required: ["prompt"]
+  },
+  handler: async (args, env, ctx) => {
+    try {
+      const resumeId = typeof args.resumeTaskId === "string" && args.resumeTaskId.trim() !== "" ? args.resumeTaskId.trim() : void 0;
+      if (resumeId) {
+        return await pollImageTask(env, resumeId, void 0, false);
+      }
+      const prompt = args.prompt;
+      if (typeof prompt !== "string" || prompt.trim() === "") {
+        return toMcpError(
+          new Error("prompt must be a non-empty string"),
+          "Image generation failed"
+        );
+      }
+      if (prompt.length > 1e3) {
+        return toMcpError(
+          new Error(
+            `prompt is ${prompt.length} characters; the limit is 1000. Make it more concise (merge details into fewer, denser sentences) and retry.`
+          ),
+          "Image generation failed"
+        );
+      }
+      const imageModels = await fetchImageModels(env);
+      const refCount = Array.isArray(args.referenceImages) ? args.referenceImages.filter((x) => typeof x === "string" && x.trim() !== "").length : 0;
+      const memory = ctx?.confirmMemory;
+      let confirmed = {};
+      if (imageModels.length > 0) {
+        const plan = planImageConfirmation(
+          imageModels,
+          {
+            model: typeof args.model === "string" ? args.model : void 0,
+            aspectRatio: typeof args.aspectRatio === "string" ? args.aspectRatio : void 0,
+            quality: typeof args.quality === "string" ? args.quality : void 0,
+            resolution: typeof args.resolution === "string" ? args.resolution : void 0,
+            count: typeof args.count === "number" ? args.count : void 0,
+            referenceImageCount: refCount
+          },
+          memory ? { pinnedModel: memory.lastModel.image, enforceModelConfirm: true } : void 0
+        );
+        if (plan) {
+          const outcome = await resolveConfirmation(plan, {
+            unattended: env.unattended,
+            elicit: ctx?.elicit,
+            // 交互态收敛掉原生审批后(env.confirmRequired)，本表单是唯一花费闸 → 机制失败时 fail-closed 取消。
+            requireConfirm: env.confirmRequired
+          });
+          if (outcome.status === "cancelled") {
+            return cancelledResult("Image", "model / aspect ratio / quality / count");
+          }
+          confirmed = outcome.values;
+          if (memory && outcome.confirmed && typeof outcome.values.model === "string") {
+            memory.lastModel.image = outcome.values.model;
+          }
+        }
+      }
+      const a = { ...args, ...confirmed };
+      const chosenModel = typeof a.model === "string" ? imageModels.find((m) => m.modelId === a.model) : void 0;
+      const aspectRatio = clampToModelEnum(
+        typeof a.aspectRatio === "string" && a.aspectRatio.trim() !== "" ? a.aspectRatio : "1:1",
+        chosenModel?.supportedAspectRatios
+      ) ?? "1:1";
+      const body = { prompt, aspectRatio };
+      body.source = AGENT_GENERATION_SOURCE;
+      body.model = typeof a.model === "string" && a.model.trim() !== "" ? a.model : "gpt-image-2";
+      {
+        const q = typeof a.quality === "string" ? a.quality.trim().toLowerCase() : "";
+        const supportsQuality = !chosenModel || (chosenModel.supportedQualities?.length ?? 0) > 0;
+        if (supportsQuality) body.quality = q === "medium" || q === "high" ? q : "low";
+      }
+      if (typeof a.negativePrompt === "string" && a.negativePrompt.trim() !== "") {
+        if (a.negativePrompt.length > 1e3) {
+          return toMcpError(
+            new Error(`negativePrompt is ${a.negativePrompt.length} characters; the limit is 1000. Shorten it and retry.`),
+            "Image generation failed"
+          );
+        }
+        body.negativePrompt = a.negativePrompt;
+      }
+      if (typeof a.count === "number" && Number.isFinite(a.count)) {
+        const maxCount = chosenModel?.maxCount ?? 4;
+        body.count = Math.min(maxCount, Math.max(1, Math.round(a.count)));
+      }
+      if (typeof a.resolution === "string" && a.resolution.trim() !== "") {
+        const clampedRes = clampToModelEnum(a.resolution, chosenModel?.supportedResolutions, "1K");
+        if (clampedRes) body.resolution = clampedRes;
+      }
+      if (typeof a.style === "string" && a.style.trim() !== "") {
+        const mapped = mapImageStyle(a.style);
+        if (mapped) body.style = mapped;
+      }
+      if (typeof a.seed === "number" && Number.isFinite(a.seed)) {
+        body.seed = Math.round(a.seed);
+      }
+      if (Array.isArray(a.referenceImages) && a.referenceImages.length > 0) {
+        const cap = chosenModel?.maxReferenceImages && chosenModel.maxReferenceImages > 0 ? chosenModel.maxReferenceImages : 5;
+        const inputs = a.referenceImages.filter((x) => typeof x === "string" && x.trim() !== "").slice(0, cap);
+        if (inputs.length > 0) {
+          body.referenceImageUrls = await Promise.all(
+            inputs.map((i) => ensureImageUrl(env, i))
+          );
+        }
+      }
+      const created = await callUniAI(
+        env,
+        "POST",
+        "/image/generate",
+        body
+      );
+      if (created.status === "completed" && created.images?.length) {
+        return successResult(await stabilizeImages(env, created.images), created.model);
+      }
+      if (created.status === "failed") {
+        return toMcpError(
+          new Error(created.error || "unknown upstream error"),
+          "Image generation failed"
+        );
+      }
+      return await pollImageTask(env, created.taskId, created.model);
+    } catch (err) {
+      return toMcpError(err, "Image generation failed");
+    }
+  }
+};
+async function pollImageTask(env, taskId, modelHint, stabilize = true) {
+  let polled;
+  try {
+    polled = await pollTask(
+      env,
+      `/image/task/${encodeURIComponent(taskId)}`,
+      {
+        maxMs: POLL_MAX_MS,
+        intervalMs: 5e3,
+        isTerminal: (snap) => {
+          const s = snap?.status;
+          if (s === "completed") return "done";
+          if (s === "failed") return "failed";
+          return "continue";
+        }
+      }
+    );
+  } catch (err) {
+    if (err instanceof PollTimeoutError) {
+      return stillProcessingResult(taskId);
+    }
+    throw err;
+  }
+  if (polled.status === "failed") {
+    return toMcpError(
+      new Error(polled.snapshot.error || "task failed"),
+      "Image generation failed"
+    );
+  }
+  const urls = polled.snapshot.images ?? [];
+  if (urls.length === 0) {
+    return toMcpError(
+      new Error("task completed but no images returned"),
+      "Image generation failed"
+    );
+  }
+  return successResult(
+    stabilize ? await stabilizeImages(env, urls) : urls,
+    polled.snapshot.model ?? modelHint
+  );
+}
+async function stabilizeImages(env, urls) {
+  return Promise.all(urls.map((u) => stabilizeMediaUrl(env, u, "image")));
+}
+function stillProcessingResult(taskId) {
+  const lines = [
+    "The image is still being generated \u2014 this is NORMAL for high-quality or image-to-image (reference) requests, which can take several minutes. The task did NOT fail; it keeps running on the server.",
+    `Task id: ${taskId}`,
+    `To get the result, call generate_image again with ONLY { "resumeTaskId": "${taskId}" }. This resumes polling the SAME task \u2014 it does NOT start a new generation and does NOT charge extra credits. Repeat until it returns image URLs.`
+  ];
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function successResult(urls, model) {
+  const lines = [
+    `Image generated successfully${model ? ` (model: ${model})` : ""}.`,
+    `URLs:`,
+    ...urls.map((u, i) => `  ${i + 1}. ${u}`)
+  ];
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+
+// ../uniai-core/src/tools/edit-image.ts
+var editImageTool = {
+  name: "edit_image",
+  description: "Remove the background from an image, producing a transparent (or solid-color) cutout of the main subject. Use when the user asks to remove a background, cut out a subject, isolate an object, or make a transparent PNG from an existing image. Accepts a local file path, an http(s) URL, or a base64 data URL, and returns a URL to the processed image.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      imageUrl: {
+        type: "string",
+        description: "Source image \u2014 a local file path, an http(s) URL (e.g. a generate_image output), or a base64 data URL. For an image the user uploaded, pass its local file path; do not invent a URL. Required."
+      },
+      outputFormat: {
+        type: "string",
+        description: 'Output image format. "png" (default, supports transparency), "jpg", or "webp".',
+        enum: ["png", "jpg", "webp"],
+        default: "png"
+      },
+      edgeType: {
+        type: "string",
+        description: 'Edge handling. "sharp" (default, crisp edges) or "feather" (soft edges).',
+        enum: ["sharp", "feather"],
+        default: "sharp"
+      },
+      resumeTaskId: {
+        type: "string",
+        description: 'Resume an existing background-removal task by its task id (the one returned in a "still processing" message) instead of starting a new one. When set, ALL other parameters are ignored \u2014 the tool only continues polling that task and returns its result once ready. It does NOT reprocess the image and does NOT charge extra credits. Leave unset for a normal new edit.'
+      }
+    },
+    required: ["imageUrl"]
+  },
+  handler: async (args, env) => {
+    try {
+      const resumeId = typeof args.resumeTaskId === "string" && args.resumeTaskId.trim() !== "" ? args.resumeTaskId.trim() : void 0;
+      if (resumeId) {
+        return await pollBgRemovalTask(env, resumeId);
+      }
+      const imageUrl = args.imageUrl;
+      if (typeof imageUrl !== "string" || imageUrl.trim() === "") {
+        return toMcpError(
+          new Error("imageUrl must be a non-empty string (file path, URL, or data URL)"),
+          "Image edit failed"
+        );
+      }
+      const body = { imageUrl: await ensureImageUrl(env, imageUrl) };
+      if (typeof args.outputFormat === "string") {
+        body.outputFormat = args.outputFormat;
+      }
+      if (typeof args.edgeType === "string") {
+        body.edgeType = args.edgeType;
+      }
+      const created = await callUniAI(
+        env,
+        "POST",
+        "/image/remove-background",
+        body
+      );
+      if (created.status === "completed" && created.result?.imageUrl) {
+        return successResult2(created.result.imageUrl);
+      }
+      if (created.status === "failed") {
+        return toMcpError(
+          new Error(created.error || "unknown upstream error"),
+          "Image edit failed"
+        );
+      }
+      return await pollBgRemovalTask(env, created.taskId);
+    } catch (err) {
+      return toMcpError(err, "Image edit failed");
+    }
+  }
+};
+async function pollBgRemovalTask(env, taskId) {
+  let polled;
+  try {
+    polled = await pollTask(
+      env,
+      `/image/processing/task/${encodeURIComponent(taskId)}`,
+      {
+        maxMs: POLL_MAX_MS,
+        intervalMs: 5e3,
+        isTerminal: (snap) => {
+          const s = snap?.status;
+          if (s === "completed") return "done";
+          if (s === "failed") return "failed";
+          return "continue";
+        }
+      }
+    );
+  } catch (err) {
+    if (err instanceof PollTimeoutError) {
+      return stillProcessingResult2(taskId);
+    }
+    throw err;
+  }
+  if (polled.status === "failed") {
+    return toMcpError(
+      new Error(polled.snapshot.error || "task failed"),
+      "Image edit failed"
+    );
+  }
+  const url = polled.snapshot.result?.imageUrl;
+  if (!url) {
+    return toMcpError(
+      new Error("task completed but no result.imageUrl returned"),
+      "Image edit failed"
+    );
+  }
+  return successResult2(url);
+}
+function stillProcessingResult2(taskId) {
+  const lines = [
+    "Background removal is still processing \u2014 the task did NOT fail; it keeps running on the server.",
+    `Task id: ${taskId}`,
+    `To get the result, call edit_image again with ONLY { "resumeTaskId": "${taskId}" }. This resumes polling the SAME task \u2014 it does NOT reprocess the image and does NOT charge extra credits. Repeat until it returns a URL.`
+  ];
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function successResult2(imageUrl) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Background removed successfully.
+URL: ${imageUrl}`
+      }
+    ]
+  };
+}
+
+// src/lib/output.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+function extractUrl(text) {
+  const m = /https?:\/\/[^\s)\]]+/.exec(text);
+  if (!m) return null;
+  return m[0].replace(/[.,;:)\]}'"]+$/, "");
+}
+async function emit(opts) {
+  const { text, isError, asJson, download } = opts;
+  if (download) {
+    const url = extractUrl(text);
+    if (!url) {
+      throw new Error(
+        "No URL found in the result, nothing to download. (Use this command without --download to see the text output.)"
+      );
+    }
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`Failed to download ${url}: HTTP ${res.status}`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    await writeFile2(download, buf);
+    process.stderr.write(`Downloaded ${buf.length} bytes to ${download}
+`);
+  }
+  if (asJson) {
+    const url = extractUrl(text);
+    const payload = {
+      ok: !isError,
+      text
+    };
+    if (url) payload.url = url;
+    process.stdout.write(JSON.stringify(payload) + "\n");
+    return;
+  }
+  process.stdout.write(text + (text.endsWith("\n") ? "" : "\n"));
+}
+
+// src/lib/run-tool.ts
+async function runTool(tool, args, flags) {
+  const asJson = flags.json === true || flags.json === "true";
+  const download = typeof flags.download === "string" ? flags.download : null;
+  try {
+    const env = await resolveEnv(flags);
+    const result = await tool.handler(args, env);
+    const content = Array.isArray(result.content) ? result.content : [];
+    const text = content.map(
+      (c) => c && typeof c === "object" && typeof c.text === "string" ? c.text : ""
+    ).filter((s) => s.length > 0).join("\n");
+    if (result.isError) return fail(text, asJson);
+    await emit({ text, asJson, download });
+    return 0;
+  } catch (err) {
+    return fail(err instanceof Error ? err.message : String(err), asJson);
+  }
+}
+function fail(rawMsg, asJson) {
+  if (asJson) {
+    process.stdout.write(JSON.stringify({ ok: false, error: rawMsg }) + "\n");
+  } else {
+    process.stderr.write(humanizeError(rawMsg) + "\n");
+  }
+  return 1;
+}
+
+// src/commands/image.ts
+var num = (v) => typeof v === "string" && v.trim() !== "" && !Number.isNaN(Number(v)) ? Number(v) : void 0;
+function sizeToAspectRatio(size) {
+  return { "1024x1024": "1:1", "1280x720": "16:9", "720x1280": "9:16" }[size.trim()];
+}
+async function runImage(rest, flags) {
+  const verb = rest[0];
+  const asJson = flags.json === true || flags.json === "true";
+  if (verb === "generate") {
+    const prompt = rest.slice(1).join(" ").trim();
+    if (!prompt) {
+      console.error(
+        'usage: uniai image generate "<prompt>" [--model <id>] [--aspect-ratio 1:1|16:9|9:16|4:3|3:4|21:9|3:1] [--count <n>] [--quality low|medium|high] [--resolution 1K|2K|4K] [--negative-prompt <text>] [--seed <n>] [--reference <path|url>[,...]] [--download <file>] [--json]'
+      );
+      console.error(
+        "note: --reference does image-to-image (local file path / URL / data URL; local files are uploaded for you, up to 5). Run `uniai image models` to list models. Anything you do not pass uses the platform-recommended default."
+      );
+      return 2;
+    }
+    const refRaw = typeof flags.reference === "string" ? flags.reference : typeof flags.image === "string" ? flags.image : void 0;
+    const referenceImages = refRaw ? refRaw.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+    const aspectRatio = typeof flags["aspect-ratio"] === "string" ? flags["aspect-ratio"] : typeof flags.size === "string" ? sizeToAspectRatio(flags.size) : void 0;
+    return runTool(
+      generateImageTool,
+      {
+        prompt,
+        model: flags.model,
+        ...aspectRatio ? { aspectRatio } : {},
+        ...typeof flags.quality === "string" ? { quality: flags.quality } : {},
+        ...typeof flags.resolution === "string" ? { resolution: flags.resolution } : {},
+        ...num(flags.count) !== void 0 ? { count: num(flags.count) } : {},
+        ...typeof flags["negative-prompt"] === "string" ? { negativePrompt: flags["negative-prompt"] } : {},
+        ...typeof flags.style === "string" ? { style: flags.style } : {},
+        ...num(flags.seed) !== void 0 ? { seed: num(flags.seed) } : {},
+        ...referenceImages && referenceImages.length > 0 ? { referenceImages } : {}
+      },
+      flags
+    );
+  }
+  if (verb === "models") {
+    try {
+      const env = await resolveEnv(flags);
+      const models = await fetchImageModels(env);
+      if (asJson) {
+        process.stdout.write(JSON.stringify({ ok: true, models }) + "\n");
+        return 0;
+      }
+      if (models.length === 0) {
+        process.stderr.write(
+          "No image models returned (the catalog may be temporarily unavailable; the platform recommends one automatically when you generate).\n"
+        );
+        return 0;
+      }
+      for (const m of models) {
+        const bits = [
+          m.supportedAspectRatios?.length ? `ratios:${m.supportedAspectRatios.join("/")}` : "",
+          m.supportedQualities?.length ? `quality:${m.supportedQualities.join("/")}` : "",
+          m.maxCount ? `max:${m.maxCount}` : "",
+          m.maxReferenceImages ? `refs:${m.maxReferenceImages}` : ""
+        ].filter(Boolean).join("  ");
+        process.stdout.write(`${m.modelId}	${m.displayName}${bits ? "	" + bits : ""}
+`);
+      }
+      return 0;
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err), asJson);
+    }
+  }
+  if (verb === "edit") {
+    const imageUrl = typeof flags.image === "string" ? flags.image : void 0;
+    if (!imageUrl) {
+      console.error("usage: uniai image edit --image <url> [--output-format png|jpg|webp] [--edge-type sharp|feather] [--download <file>]");
+      console.error('note: --image must be a URL (e.g. a URL returned by `uniai image generate`); local-file upload is not supported yet. For "change clothing / new pose from my photo", use `image generate --reference` instead.');
+      return 2;
+    }
+    return runTool(
+      editImageTool,
+      { imageUrl, outputFormat: flags["output-format"], edgeType: flags["edge-type"] },
+      flags
+    );
+  }
+  console.error("usage: uniai image generate|edit|models ...");
+  return 2;
+}
+
+// ../uniai-core/src/tools/generate-video.ts
+var PROMPT_MAX = 5e3;
+var NEGATIVE_PROMPT_MAX = 500;
+var VIDEO_TYPES = [
+  "text2video",
+  "image2video",
+  "start_end_frame",
+  "reference_to_video",
+  "video_to_video",
+  "video_continuation"
+];
+function asStr(v) {
+  return typeof v === "string" && v.trim() !== "" ? v : void 0;
+}
+function asStrArray(v, max) {
+  return Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.trim() !== "").slice(0, max) : [];
+}
+function deriveVideoType(args) {
+  const refCount = asStrArray(args.referenceImages, 9).length + asStrArray(args.referenceVideos, 3).length + asStrArray(args.referenceAudios, 3).length;
+  if (asStr(args.continuationVideo)) return "video_continuation";
+  if (asStr(args.sourceVideo)) return "video_to_video";
+  if (refCount > 0) return "reference_to_video";
+  if (asStr(args.firstFrame) && asStr(args.lastFrame)) return "start_end_frame";
+  if (asStr(args.firstFrame)) return "image2video";
+  return "text2video";
+}
+function contentCountsFor(type, args) {
+  switch (type) {
+    case "reference_to_video":
+      return {
+        image: asStrArray(args.referenceImages, 9).length,
+        video: asStrArray(args.referenceVideos, 3).length,
+        audio: asStrArray(args.referenceAudios, 3).length
+      };
+    case "image2video":
+      return { image: asStr(args.firstFrame) ? 1 : 0, video: 0, audio: 0 };
+    case "start_end_frame":
+      return { image: (asStr(args.firstFrame) ? 1 : 0) + (asStr(args.lastFrame) ? 1 : 0), video: 0, audio: 0 };
+    case "video_to_video":
+      return { image: 0, video: asStr(args.sourceVideo) ? 1 : 0, audio: 0 };
+    case "video_continuation":
+      return { image: 0, video: asStr(args.continuationVideo) ? 1 : 0, audio: 0 };
+    default:
+      return { image: 0, video: 0, audio: 0 };
+  }
+}
+var generateVideoTool = {
+  name: "generate_video",
+  description: "Generate a short video clip with UniAI video models. The generation mode is AUTO-DERIVED from the media you attach \u2014 just put the user's uploaded material on the right field and the tool figures out the rest: firstFrame (animate an image), firstFrame+lastFrame (interpolate first\u2192last), referenceImages / referenceVideos / referenceAudios (omni reference \u2014 guide the video with reference images, clips, and/or audio; e.g. Seedance 2.0), sourceVideo (edit/restyle a clip), continuationVideo (extend a clip), or none (text-to-video). Media inputs accept a local file path, an http(s) URL, or a base64 data URL \u2014 for files the user uploaded, pass their local paths. The tool narrows the selectable models to those that can actually consume what you attached (e.g. image+video+audio reference \u2192 only omni models like Seedance 2.0) and defaults to the platform-recommended one. Returns a URL to the generated video. IMPORTANT: video generation is slow and frequently takes longer than a single call can wait \u2014 when it does, this tool returns a task id and you MUST call it again with resumeTaskId=<that id> to keep waiting (this resumes the SAME job; it does not re-generate or re-charge). Resuming is the normal happy path for video, not an error.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      prompt: {
+        type: "string",
+        description: "Scene / motion description in natural language. Required."
+      },
+      type: {
+        type: "string",
+        description: "Optional hint only \u2014 the actual mode is AUTO-DERIVED from the media you provide, so usually you do not set this. Just attach the user's uploaded material to the right field and the tool picks the mode + the models that can handle it: firstFrame \u2192 image2video; firstFrame+lastFrame \u2192 start_end_frame; any of referenceImages/referenceVideos/referenceAudios \u2192 reference_to_video (omni); sourceVideo \u2192 video_to_video; continuationVideo \u2192 video_continuation; nothing \u2192 text2video.",
+        enum: [...VIDEO_TYPES],
+        default: "text2video"
+      },
+      model: {
+        type: "string",
+        description: "Optional UniAI video model id. Leave empty to use the platform default (recommended; currently Seedance 2.0, which supports all modes). Only set if you know a valid model id."
+      },
+      aspectRatio: {
+        type: "string",
+        description: 'Video aspect ratio. "16:9" (default), "9:16", "1:1", "4:3", "3:4", "3:2", "2:3", "21:9", or "adaptive" (match the input image/video).',
+        enum: ["21:9", "16:9", "4:3", "3:2", "1:1", "2:3", "3:4", "9:16", "adaptive"],
+        default: "16:9"
+      },
+      duration: {
+        type: "number",
+        description: "Video duration in seconds, 2-15 (default 5). Longer videos cost more credits; not all models support every length.",
+        minimum: 2,
+        maximum: 15,
+        default: 5
+      },
+      resolution: {
+        type: "string",
+        description: `Output resolution \u2014 PER-MODEL: "480p" (cheapest, e.g. Seedance 2.0), "720p" (default) or "1080p" (full HD, most expensive). Supported tiers vary by model; the tool clamps to the selected model's supported resolutions (a value the model does not support falls back to its default). When omitted, sends "720p".`,
+        enum: ["480p", "720p", "1080p"],
+        default: "720p"
+      },
+      negativePrompt: {
+        type: "string",
+        description: "What to avoid in the video. Optional (only some models support it; ignored otherwise)."
+      },
+      seed: {
+        type: "number",
+        description: "Random seed for reproducible results. Optional."
+      },
+      firstFrame: {
+        type: "string",
+        description: 'First-frame image for "image2video" / "start_end_frame": a local file path, an http(s) URL, or a base64 data URL. For an uploaded image, pass its local path; never invent a URL.'
+      },
+      lastFrame: {
+        type: "string",
+        description: 'Last-frame image for "start_end_frame": a local file path, an http(s) URL, or a base64 data URL.'
+      },
+      referenceImages: {
+        type: "array",
+        items: { type: "string" },
+        description: "Reference images for reference-to-video (style / subject / character guidance); each a local file path, an http(s) URL, or a base64 data URL. Up to 9."
+      },
+      referenceVideos: {
+        type: "array",
+        items: { type: "string" },
+        description: "Reference videos for reference-to-video (omni reference, e.g. Seedance 2.0 \u2014 use a clip as cinematic/subject reference); each a local file path, an http(s) URL, or a base64 data URL. Up to 3. Only omni models accept these; the tool narrows the model list to those that can."
+      },
+      referenceAudios: {
+        type: "array",
+        items: { type: "string" },
+        description: "Reference audios for reference-to-video (omni reference, e.g. Seedance 2.0 \u2014 drive the generated video with this audio); each a local file path, an http(s) URL, or a base64 data URL (mp3 / wav, up to ~15s each). Up to 3. Only omni models accept these; the tool narrows the model list to those that can."
+      },
+      sourceVideo: {
+        type: "string",
+        description: 'Source video for "video_to_video" (the clip to edit/restyle): a local file path, an http(s) URL, or a base64 data URL.'
+      },
+      v2vEndpoint: {
+        type: "string",
+        description: 'For "video_to_video" only: "edit" (default \u2014 modify the source, keep its length) or "reference" (generate a new scene using the source as cinematic reference). Model-specific (Kling).',
+        enum: ["edit", "reference"]
+      },
+      continuationVideo: {
+        type: "string",
+        description: 'Video to extend for "video_continuation": a local file path, an http(s) URL, or a base64 data URL. The new clip continues from this video.'
+      },
+      resumeTaskId: {
+        type: "string",
+        description: 'Resume an existing video task by its task id (the one returned in a "still processing" message) instead of starting a new one. When set, ALL other parameters are ignored \u2014 the tool only continues polling that task and returns its result once ready. It does NOT start a new render and does NOT charge extra credits. This is the normal way to keep waiting for a long video; leave unset for a new generation.'
+      }
+    },
+    required: ["prompt"]
+  },
+  handler: async (args, env, ctx) => {
+    try {
+      const resumeId = asStr(args.resumeTaskId);
+      if (resumeId) {
+        return await pollVideoTask(env, resumeId);
+      }
+      const prompt = args.prompt;
+      if (typeof prompt !== "string" || prompt.trim() === "") {
+        return toMcpError(new Error("prompt must be a non-empty string"), "Video generation failed");
+      }
+      if (prompt.length > PROMPT_MAX) {
+        return toMcpError(
+          new Error(`prompt is ${prompt.length} characters; the limit is ${PROMPT_MAX}. Shorten it and retry.`),
+          "Video generation failed"
+        );
+      }
+      const negativePrompt = asStr(args.negativePrompt);
+      if (negativePrompt && negativePrompt.length > NEGATIVE_PROMPT_MAX) {
+        return toMcpError(
+          new Error(`negativePrompt is ${negativePrompt.length} characters; the limit is ${NEGATIVE_PROMPT_MAX}. Shorten it and retry.`),
+          "Video generation failed"
+        );
+      }
+      const type = deriveVideoType(args);
+      const content = contentCountsFor(type, args);
+      const videoModels = await fetchVideoModels(env);
+      const memory = ctx?.confirmMemory;
+      let confirmed = {};
+      if (videoModels.length > 0) {
+        const plan = planVideoConfirmation(
+          videoModels,
+          type,
+          {
+            model: asStr(args.model),
+            aspectRatio: asStr(args.aspectRatio),
+            duration: typeof args.duration === "number" ? args.duration : void 0,
+            resolution: asStr(args.resolution)
+          },
+          memory ? { pinnedModel: memory.lastModel.video, enforceModelConfirm: true, content } : { content }
+        );
+        if (plan) {
+          const outcome = await resolveConfirmation(plan, {
+            unattended: env.unattended,
+            elicit: ctx?.elicit,
+            // 交互态收敛掉原生审批后(env.confirmRequired)，本表单是唯一花费闸 → 机制失败时 fail-closed 取消。
+            requireConfirm: env.confirmRequired
+          });
+          if (outcome.status === "cancelled") {
+            return cancelledResult("Video", "model / aspect ratio / duration / resolution");
+          }
+          confirmed = outcome.values;
+          if (memory && outcome.confirmed && typeof outcome.values.model === "string") {
+            memory.lastModel.video = outcome.values.model;
+          }
+        }
+      }
+      const a = { ...args, ...confirmed };
+      const modelArg = asStr(a.model);
+      const chosenVideoModel = modelArg ? videoModels.find((m) => m.id === modelArg) : void 0;
+      const aspectRatio = clampToModelEnum(asStr(a.aspectRatio) ?? "16:9", chosenVideoModel?.supportedAspectRatios) ?? "16:9";
+      const durNum = Number(a.duration);
+      const duration = snapDurationToModel(Number.isFinite(durNum) ? durNum : 5, chosenVideoModel);
+      const body = { type, prompt, aspectRatio, duration };
+      body.source = AGENT_GENERATION_SOURCE;
+      if (modelArg) body.model = modelArg;
+      body.resolution = clampToModelEnum(
+        asStr(a.resolution) ?? "720p",
+        chosenVideoModel?.supportedResolutions,
+        chosenVideoModel?.defaultResolution ?? "720p"
+      ) ?? "720p";
+      if (negativePrompt) body.negativePrompt = negativePrompt;
+      if (typeof a.seed === "number" && Number.isFinite(a.seed)) body.seed = Math.round(a.seed);
+      if (chosenVideoModel?.supportsAudio === true && type !== "video_to_video") {
+        body.generateAudio = a.audio !== "off";
+      }
+      const fail2 = (msg2) => toMcpError(new Error(msg2), "Video generation failed");
+      if (type === "image2video") {
+        const f = asStr(args.firstFrame);
+        if (!f) return fail2("firstFrame is required for image2video (image file path, URL, or data URL)");
+        body.startFrameUrl = await ensureMediaUrl(env, f, "image");
+      } else if (type === "start_end_frame") {
+        const f = asStr(args.firstFrame);
+        const l = asStr(args.lastFrame);
+        if (!f || !l) return fail2("start_end_frame requires both firstFrame and lastFrame (image file path, URL, or data URL)");
+        const [su, eu] = await Promise.all([
+          ensureMediaUrl(env, f, "image"),
+          ensureMediaUrl(env, l, "image")
+        ]);
+        body.startFrameUrl = su;
+        body.endFrameUrl = eu;
+      } else if (type === "reference_to_video") {
+        const refImgs = asStrArray(args.referenceImages, 9);
+        const refVids = asStrArray(args.referenceVideos, 3);
+        const refAuds = asStrArray(args.referenceAudios, 3);
+        if (refImgs.length + refVids.length + refAuds.length === 0) {
+          return fail2("reference_to_video requires at least one reference image, video, or audio (file path, http(s) URL, or data URL)");
+        }
+        const [imgUrls, vidUrls, audUrls] = await Promise.all([
+          Promise.all(refImgs.map((r) => ensureMediaUrl(env, r, "image"))),
+          Promise.all(refVids.map((r) => ensureMediaUrl(env, r, "video"))),
+          Promise.all(refAuds.map((r) => ensureMediaUrl(env, r, "audio")))
+        ]);
+        if (imgUrls.length > 0) body.elements = imgUrls.map((u) => ({ frontal_image_url: u }));
+        if (vidUrls.length > 0) body.referenceVideoUrls = vidUrls;
+        if (audUrls.length > 0) body.referenceAudioUrls = audUrls;
+      } else if (type === "video_to_video") {
+        const v = asStr(args.sourceVideo);
+        if (!v) return fail2("video_to_video requires sourceVideo (video file path, URL, or data URL)");
+        body.referenceVideoUrl = await ensureMediaUrl(env, v, "video");
+        if (args.v2vEndpoint === "reference") {
+          body.type = "video_reference_to_video";
+        }
+      } else if (type === "video_continuation") {
+        const v = asStr(args.continuationVideo);
+        if (!v) return fail2("video_continuation requires continuationVideo (video file path, URL, or data URL)");
+        body.referenceVideoUrls = [await ensureMediaUrl(env, v, "video")];
+      }
+      let created;
+      try {
+        created = await callUniAI(
+          env,
+          "POST",
+          "/video-agent-v2/generate",
+          body
+        );
+      } catch (err) {
+        const msg2 = err instanceof Error ? err.message : String(err);
+        if (msg2.includes("\u7D20\u6750\u5BA1\u6838")) {
+          return await handleVideoComplianceGate(env, body, modelArg);
+        }
+        throw err;
+      }
+      if (created.status === "completed" && created.videoUrl) {
+        return successResult3(created.videoUrl, created.coverUrl, modelArg);
+      }
+      if (created.status === "failed") {
+        return toMcpError(
+          new Error(created.error || "unknown upstream error"),
+          "Video generation failed"
+        );
+      }
+      return await pollVideoTask(env, created.taskId, modelArg);
+    } catch (err) {
+      return toMcpError(err, "Video generation failed");
+    }
+  }
+};
+async function pollVideoTask(env, taskId, modelHint, maxMs = POLL_MAX_MS) {
+  let polled;
+  try {
+    polled = await pollTask(
+      env,
+      `/video-agent-v2/task/${encodeURIComponent(taskId)}`,
+      {
+        maxMs,
+        intervalMs: 1e4,
+        isTerminal: (snap) => {
+          const s = snap?.status;
+          if (s === "completed") return "done";
+          if (s === "failed") return "failed";
+          return "continue";
+        }
+      }
+    );
+  } catch (err) {
+    if (err instanceof PollTimeoutError) {
+      return stillProcessingResult3(taskId);
+    }
+    throw err;
+  }
+  if (polled.status === "failed") {
+    return toMcpError(
+      new Error(polled.snapshot.error || "task failed"),
+      "Video generation failed"
+    );
+  }
+  if (!polled.snapshot.videoUrl) {
+    return toMcpError(
+      new Error("task completed but no videoUrl returned"),
+      "Video generation failed"
+    );
+  }
+  return successResult3(polled.snapshot.videoUrl, polled.snapshot.coverUrl, modelHint);
+}
+var COMPLIANCE_SETTLE_MAX_MS = 2e5;
+var COMPLIANCE_RETRY_INTERVAL_MS = 5e3;
+async function stabilizeVideoBodyMedia(env, body) {
+  if (typeof body.startFrameUrl === "string") {
+    body.startFrameUrl = await stabilizeMediaUrl(env, body.startFrameUrl, "image");
+  }
+  if (typeof body.endFrameUrl === "string") {
+    body.endFrameUrl = await stabilizeMediaUrl(env, body.endFrameUrl, "image");
+  }
+  if (typeof body.referenceVideoUrl === "string") {
+    body.referenceVideoUrl = await stabilizeMediaUrl(env, body.referenceVideoUrl, "video");
+  }
+  if (Array.isArray(body.referenceVideoUrls)) {
+    body.referenceVideoUrls = await Promise.all(
+      body.referenceVideoUrls.map((u) => typeof u === "string" ? stabilizeMediaUrl(env, u, "video") : u)
+    );
+  }
+  if (Array.isArray(body.referenceAudioUrls)) {
+    body.referenceAudioUrls = await Promise.all(
+      body.referenceAudioUrls.map((u) => typeof u === "string" ? stabilizeMediaUrl(env, u, "audio") : u)
+    );
+  }
+  if (Array.isArray(body.elements)) {
+    body.elements = await Promise.all(
+      body.elements.map(async (el) => {
+        const e = el;
+        if (e && typeof e.frontal_image_url === "string") {
+          return { ...e, frontal_image_url: await stabilizeMediaUrl(env, e.frontal_image_url, "image") };
+        }
+        return el;
+      })
+    );
+  }
+}
+async function handleVideoComplianceGate(env, body, modelHint) {
+  const rejected = (msg2) => {
+    const m = /（([^）]+)）/.exec(msg2) ?? /\(([^)]+)\)/.exec(msg2);
+    const reason = m?.[1]?.trim();
+    const isDimension = !!reason && /(width|height|too\s*small|too\s*large|must be between|\bpx\b|尺寸|分辨率|像素)/i.test(reason);
+    const tail = isDimension ? "\u8BE5\u53C2\u8003\u56FE\u7684\u5C3A\u5BF8\u4E0D\u5728\u89C6\u9891\u5E73\u53F0\u5141\u8BB8\u8303\u56F4\u5185\uFF08\u901A\u5E38\u9700\u5BBD/\u9AD8\u5728\u7EA6 300\u20136000px \u4E4B\u95F4\uFF09\u3002\u7CFB\u7EDF\u5DF2\u81EA\u52A8\u653E\u5927\u8FC7\u5C0F\u7684\u53C2\u8003\u56FE\uFF0C\u6545\u6B64\u9519\u591A\u534A\u662F\u56FE\u7247\u3010\u8FC7\u5927\u3011\u6216\u6BD4\u4F8B\u8D85\u9650\u3002\u8BF7\u6539\u7528\u4E00\u5F20\u5C3A\u5BF8\u66F4\u5408\u9002\u7684\u53C2\u8003\u56FE\u540E\u91CD\u8BD5\u2014\u2014\u4E0D\u8981\u7528\u6A21\u578B\u91CD\u65B0\u751F\u6210\u6216\u8D85\u5206\u4E00\u5F20\u66F4\u5927\u7684\u56FE\u3002" : "\u8BE5\u7D20\u6750\u65E0\u6CD5\u7528\u4E8E\u751F\u6210\u89C6\u9891\uFF08\u53EF\u80FD\u5185\u5BB9\u4E0D\u5408\u89C4\uFF0C\u6216\u7D20\u6750\u94FE\u63A5\u5BA1\u6838\u670D\u52A1\u65E0\u6CD5\u8BFB\u53D6\uFF09\u3002\u8BF7\u66F4\u6362\u7D20\u6750\u540E\u91CD\u8BD5\u3002";
+    return toMcpError(
+      new Error(`\u7D20\u6750\u5BA1\u6838\u672A\u901A\u8FC7${reason ? `\uFF1A${reason}` : ""}\u3002${tail}`),
+      "Video generation failed"
+    );
+  };
+  await stabilizeVideoBodyMedia(env, body);
+  const reactiveStart = Date.now();
+  while (Date.now() - reactiveStart < COMPLIANCE_SETTLE_MAX_MS) {
+    await new Promise((r) => setTimeout(r, COMPLIANCE_RETRY_INTERVAL_MS));
+    let created;
+    try {
+      created = await callUniAI(env, "POST", "/video-agent-v2/generate", body);
+    } catch (e) {
+      const m = e instanceof Error ? e.message : String(e);
+      if (m.includes("\u7D20\u6750\u5BA1\u6838\u5931\u8D25")) return rejected(m);
+      if (m.includes("\u7D20\u6750\u5BA1\u6838")) continue;
+      return toMcpError(e, "Video generation failed");
+    }
+    if (created.status === "completed" && created.videoUrl) {
+      return successResult3(created.videoUrl, created.coverUrl, modelHint);
+    }
+    if (created.status === "failed") {
+      return toMcpError(new Error(created.error || "unknown upstream error"), "Video generation failed");
+    }
+    const remaining = Math.max(2e4, POLL_MAX_MS - (Date.now() - reactiveStart));
+    return await pollVideoTask(env, created.taskId, modelHint, remaining);
+  }
+  return stillModeratingResult();
+}
+function stillModeratingResult() {
+  const lines = [
+    "The uploaded reference material is still under platform review (\u7D20\u6750\u5BA1\u6838) \u2014 this is REQUIRED for Seedance 2.0 and usually completes within a few minutes. The task did NOT fail and NO credits were charged; the review keeps running on the server.",
+    "Tell the user their material is being reviewed and that they can ask you to generate the video again shortly. When you retry, use the SAME request (same model + same reference material) \u2014 the review will have progressed and the generation will proceed automatically once it is approved. Do NOT switch to text-only as a workaround."
+  ];
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function stillProcessingResult3(taskId) {
+  const lines = [
+    "The video is still being generated \u2014 this is NORMAL and expected; video rendering routinely takes several minutes (sometimes much longer). The task did NOT fail; it keeps running on the server.",
+    `Task id: ${taskId}`,
+    `To get the result, call generate_video again with ONLY { "resumeTaskId": "${taskId}" }. This resumes polling the SAME task \u2014 it does NOT start a new render and does NOT charge extra credits. Repeat until it returns a video URL.`
+  ];
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function successResult3(videoUrl, coverUrl, model) {
+  const modelNote = model ? ` (model: ${model})` : "";
+  const lines = [`Video generated successfully${modelNote}.`, `URL: ${videoUrl}`];
+  if (coverUrl) lines.push(`Cover: ${coverUrl}`);
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+
+// src/commands/video.ts
+var num2 = (v) => typeof v === "string" && v.trim() !== "" && !Number.isNaN(Number(v)) ? Number(v) : void 0;
+var str2 = (v) => typeof v === "string" && v.trim() !== "" ? v : void 0;
+var list = (v) => {
+  if (typeof v !== "string") return void 0;
+  const arr = v.split(",").map((s) => s.trim()).filter(Boolean);
+  return arr.length > 0 ? arr : void 0;
+};
+async function runVideo(rest, flags) {
+  const verb = rest[0];
+  const asJson = flags.json === true || flags.json === "true";
+  if (verb === "models") {
+    try {
+      const env = await resolveEnv(flags);
+      const models = await fetchVideoModels(env);
+      if (asJson) {
+        process.stdout.write(JSON.stringify({ ok: true, models }) + "\n");
+        return 0;
+      }
+      if (models.length === 0) {
+        process.stderr.write(
+          "No video models returned (the catalog may be temporarily unavailable; the platform recommends one automatically when you generate).\n"
+        );
+        return 0;
+      }
+      for (const m of models) {
+        const dur = m.durationSteps?.length ? `dur:${m.durationSteps.join("/")}s` : m.minDuration || m.maxDuration ? `dur:${m.minDuration ?? "?"}-${m.maxDuration ?? "?"}s` : "";
+        const bits = [
+          m.supportedAspectRatios?.length ? `ratios:${m.supportedAspectRatios.join("/")}` : "",
+          m.supportedResolutions?.length ? `res:${m.supportedResolutions.join("/")}` : "",
+          dur,
+          m.supportsAudio ? "audio" : "",
+          m.maxReferenceImages ? `refs:${m.maxReferenceImages}` : "",
+          m.inputs ? `modes:${Object.keys(m.inputs).join("/")}` : ""
+        ].filter(Boolean).join("  ");
+        process.stdout.write(`${m.id}	${m.name ?? m.id}${bits ? "	" + bits : ""}
+`);
+      }
+      return 0;
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err), asJson);
+    }
+  }
+  if (verb !== "generate") {
+    console.error('usage: uniai video generate "<prompt>" [...]  |  uniai video models');
+    return 2;
+  }
+  const prompt = rest.slice(1).join(" ").trim();
+  if (!prompt) {
+    console.error(
+      'usage: uniai video generate "<prompt>" [--model <id>] [--aspect-ratio 16:9|9:16|1:1|4:3|3:4|21:9|adaptive] [--duration <2-15>] [--resolution 480p|720p|1080p] [--first-frame <path>] [--last-frame <path>] [--reference <path,...>] [--reference-video <path,...>] [--reference-audio <path,...>] [--source-video <path>] [--continuation-video <path>] [--negative-prompt <text>] [--seed <n>] [--download <file>] [--json]'
+    );
+    console.error(
+      "note: the MODE is auto-derived from the media you attach \u2014 --first-frame = animate an image; --first-frame + --last-frame = first\u2192last frame; --reference(/-video/-audio) = reference-to-video (omni); --source-video = edit/restyle a clip; --continuation-video = extend; none = text-to-video. Local files are uploaded for you. A prompt is always required. Run `uniai video models` for the model list."
+    );
+    return 2;
+  }
+  return runTool(
+    generateVideoTool,
+    {
+      prompt,
+      model: flags.model,
+      ...str2(flags["aspect-ratio"]) ? { aspectRatio: flags["aspect-ratio"] } : {},
+      ...num2(flags.duration) !== void 0 ? { duration: num2(flags.duration) } : {},
+      ...str2(flags.resolution) ? { resolution: flags.resolution } : {},
+      ...str2(flags["negative-prompt"]) ? { negativePrompt: flags["negative-prompt"] } : {},
+      ...num2(flags.seed) !== void 0 ? { seed: num2(flags.seed) } : {},
+      ...str2(flags["first-frame"]) ? { firstFrame: flags["first-frame"] } : {},
+      ...str2(flags["last-frame"]) ? { lastFrame: flags["last-frame"] } : {},
+      ...list(flags.reference) ? { referenceImages: list(flags.reference) } : {},
+      ...list(flags["reference-video"]) ? { referenceVideos: list(flags["reference-video"]) } : {},
+      ...list(flags["reference-audio"]) ? { referenceAudios: list(flags["reference-audio"]) } : {},
+      ...str2(flags["source-video"]) ? { sourceVideo: flags["source-video"] } : {},
+      ...str2(flags["continuation-video"]) ? { continuationVideo: flags["continuation-video"] } : {},
+      ...str2(flags["v2v-endpoint"]) ? { v2vEndpoint: flags["v2v-endpoint"] } : {}
+    },
+    flags
+  );
+}
+
+// ../uniai-core/src/tools/text-to-speech.ts
+var textToSpeechTool = {
+  name: "text_to_speech",
+  description: "Convert text into natural-sounding spoken audio (text-to-speech / TTS). Use when the user asks to read text aloud, create a voiceover, generate narration, or turn text into speech. Returns a URL to the generated audio.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description: "The text to synthesize into speech (up to 5000 chars). Required."
+      },
+      voice: {
+        type: "string",
+        description: "Voice id to use. Optional; omit unless you know a valid voice id (a default voice is used otherwise)."
+      },
+      format: {
+        type: "string",
+        description: 'Audio format. "mp3" (default), "wav", "pcm", "opus", "aac", or "flac".',
+        enum: ["mp3", "wav", "pcm", "opus", "aac", "flac"],
+        default: "mp3"
+      },
+      rate: {
+        type: "number",
+        description: "Speaking rate multiplier from 0.5 (slow) to 2.0 (fast). Default 1.0.",
+        minimum: 0.5,
+        maximum: 2,
+        default: 1
+      }
+    },
+    required: ["text"]
+  },
+  handler: async (args, env) => {
+    try {
+      const text = args.text;
+      if (typeof text !== "string" || text.trim() === "") {
+        return toMcpError(
+          new Error("text must be a non-empty string"),
+          "Text-to-speech failed"
+        );
+      }
+      const body = { text };
+      if (typeof args.voice === "string" && args.voice.trim() !== "") {
+        body.voice = args.voice;
+      }
+      if (typeof args.format === "string") {
+        body.format = args.format;
+      }
+      if (typeof args.rate === "number") {
+        body.rate = args.rate;
+      }
+      const created = await callUniAI(env, "POST", "/speech/tts", body);
+      if (created.status === "completed" && created.audioUrl) {
+        return successResult4(created.audioUrl, created.duration);
+      }
+      if (created.status === "failed") {
+        return toMcpError(
+          new Error(created.error || "unknown upstream error"),
+          "Text-to-speech failed"
+        );
+      }
+      const polled = await pollTask(
+        env,
+        `/speech/task/${encodeURIComponent(created.taskId)}`,
+        {
+          maxMs: 6e4,
+          intervalMs: 3e3,
+          isTerminal: (snap) => {
+            const s = snap?.status;
+            if (s === "completed") return "done";
+            if (s === "failed") return "failed";
+            return "continue";
+          }
+        }
+      );
+      if (polled.status === "failed") {
+        return toMcpError(
+          new Error(polled.snapshot.error || "task failed"),
+          "Text-to-speech failed"
+        );
+      }
+      if (!polled.snapshot.audioUrl) {
+        return toMcpError(
+          new Error("task completed but no audioUrl returned"),
+          "Text-to-speech failed"
+        );
+      }
+      return successResult4(polled.snapshot.audioUrl, polled.snapshot.duration);
+    } catch (err) {
+      return toMcpError(err, "Text-to-speech failed");
+    }
+  }
+};
+function successResult4(audioUrl, duration) {
+  const lines = ["Speech synthesized successfully.", `URL: ${audioUrl}`];
+  if (typeof duration === "number") lines.push(`Duration: ${duration}s`);
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+
+// ../uniai-core/src/tools/speech-to-text.ts
+var STT_LANGUAGES = ["auto", "zh", "en", "ja", "ko"];
+var speechToTextTool = {
+  name: "speech_to_text",
+  description: "Transcribe spoken audio into written text (speech-to-text / STT). Use when the user wants to transcribe a recording, voice memo, voice message, or audio file into text. Accepts a local file path, an http(s) URL, or a base64 data URL (MP3/WAV/WebM/OGG/M4A, up to 10MB). Returns the transcript text.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      audio: {
+        type: "string",
+        description: "The audio to transcribe: a local file path, an http(s) URL, or a base64 data URL. MP3/WAV/WebM/OGG/M4A, up to 10MB. Required."
+      },
+      language: {
+        type: "string",
+        description: 'Spoken-language hint. "auto" (default, auto-detect), "zh", "en", "ja", or "ko".',
+        enum: STT_LANGUAGES,
+        default: "auto"
+      }
+    },
+    required: ["audio"]
+  },
+  handler: async (args, env) => {
+    try {
+      const audio = args.audio;
+      if (typeof audio !== "string" || audio.trim() === "") {
+        return toMcpError(
+          new Error("audio must be a non-empty string (file path, URL, or data URL)"),
+          "Speech-to-text failed"
+        );
+      }
+      const extra = {};
+      if (typeof args.language === "string" && STT_LANGUAGES.includes(args.language)) {
+        extra.language = args.language;
+      }
+      const file = await resolveFileInput(audio);
+      const res = await postMultipart(
+        env,
+        "/speech/stt/realtime",
+        "audio",
+        file,
+        extra,
+        { timeoutMs: POLL_MAX_MS }
+      );
+      if (typeof res.text !== "string") {
+        return toMcpError(
+          new Error("speech-to-text returned no text field"),
+          "Speech-to-text failed"
+        );
+      }
+      const text = res.text.trim() === "" ? "(no speech detected in audio)" : res.text;
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      return toMcpError(err, "Speech-to-text failed");
+    }
+  }
+};
+
+// src/commands/speech.ts
+var num3 = (v) => typeof v === "string" && v.trim() !== "" && !Number.isNaN(Number(v)) ? Number(v) : void 0;
+async function runSpeech(rest, flags) {
+  const verb = rest[0];
+  if (verb === "synthesize") {
+    const text = rest.slice(1).join(" ").trim();
+    if (!text) {
+      console.error('usage: uniai speech synthesize "<text>" [--voice <id>] [--format mp3|wav|pcm|opus|aac|flac] [--rate 0.5-2.0] [--download <file>]');
+      return 2;
+    }
+    return runTool(
+      textToSpeechTool,
+      { text, voice: flags.voice, format: flags.format, rate: num3(flags.rate) },
+      flags
+    );
+  }
+  if (verb === "recognize") {
+    const audio = rest[1];
+    if (!audio) {
+      console.error("usage: uniai speech recognize <audio: path|url> [--language auto|zh|en|ja|ko] [--json]");
+      return 2;
+    }
+    return runTool(speechToTextTool, { audio, language: flags.language }, flags);
+  }
+  console.error("usage: uniai speech synthesize|recognize ...");
+  return 2;
+}
+
+// ../uniai-core/src/lib/sse-merge.ts
+function parseSseEvents(buffer) {
+  let delta = "";
+  let done = false;
+  let error;
+  const lastNl = buffer.lastIndexOf("\n");
+  if (lastNl === -1) {
+    return { delta: "", done: false, rest: buffer };
+  }
+  const complete = buffer.slice(0, lastNl);
+  const rest = buffer.slice(lastNl + 1);
+  for (const rawLine of complete.split("\n")) {
+    const line = rawLine.trim();
+    if (line === "" || !line.startsWith("data:")) continue;
+    const payload = line.slice("data:".length).trim();
+    if (payload === "") continue;
+    if (payload === "[DONE]") {
+      done = true;
+      continue;
+    }
+    try {
+      const obj = JSON.parse(payload);
+      if (typeof obj.content === "string") {
+        delta += obj.content;
+      } else if (typeof obj.error === "string") {
+        error = obj.error;
+      } else if (obj.error && typeof obj.error === "object" && typeof obj.error.message === "string") {
+        error = obj.error.message;
+      }
+    } catch {
+    }
+  }
+  return { delta, done, error, rest };
+}
+async function mergeSse(env, path, body, opts) {
+  const timeoutMs = opts?.timeoutMs ?? 12e4;
+  const url = `${env.baseUrl}${path}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${env.token}`,
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      let bodyText = "";
+      try {
+        bodyText = (await res.text()).slice(0, 200);
+      } catch {
+        bodyText = "<failed to read body>";
+      }
+      throw new Error(`UniAI POST ${path} -> HTTP ${res.status}: ${bodyText}`);
+    }
+    if (!res.body) {
+      throw new Error(`UniAI POST ${path}: no SSE response body`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let result = "";
+    while (true) {
+      const { done: streamDone, value } = await reader.read();
+      if (value) {
+        buffer += decoder.decode(value, { stream: true });
+        const parsed = parseSseEvents(buffer);
+        result += parsed.delta;
+        buffer = parsed.rest;
+        if (parsed.error) {
+          throw new Error(parsed.error);
+        }
+        if (parsed.done) {
+          return result;
+        }
+      }
+      if (streamDone) break;
+    }
+    if (buffer.trim() !== "") {
+      const parsed = parseSseEvents(buffer + "\n");
+      result += parsed.delta;
+      if (parsed.error) throw new Error(parsed.error);
+    }
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new Error(`UniAI POST ${path} timed out after ${timeoutMs}ms`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ../uniai-core/src/tools/chat.ts
+var chatTool = {
+  name: "chat",
+  description: "Ask UniAI's configured chat model a question and get a single text answer. Use ONLY when the user explicitly wants a response from the UniAI platform's own chat model (which may use a different model than you), e.g. to compare answers or route to a specifically configured model. For ordinary conversation, answer directly instead of calling this. Returns the model's full reply as text.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "The message or question to send to the UniAI chat model. Required."
+      }
+    },
+    required: ["message"]
+  },
+  handler: async (args, env) => {
+    try {
+      const message = args.message;
+      if (typeof message !== "string" || message.trim() === "") {
+        return toMcpError(
+          new Error("message must be a non-empty string"),
+          "Chat failed"
+        );
+      }
+      const text = await mergeSse(env, "/chat/stream", { message }, { timeoutMs: 12e4 });
+      if (text.trim() === "") {
+        return toMcpError(
+          new Error("chat returned an empty response"),
+          "Chat failed"
+        );
+      }
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      return toMcpError(err, "Chat failed");
+    }
+  }
+};
+
+// src/commands/chat.ts
+async function runChat(rest, flags) {
+  const message = rest.join(" ").trim();
+  if (!message) {
+    console.error('usage: uniai chat "<message>" [--json]');
+    return 2;
+  }
+  return runTool(chatTool, { message }, flags);
+}
+
+// ../uniai-core/src/tools/generate-code.ts
+var CODE_LANGUAGES = [
+  "javascript",
+  "typescript",
+  "python",
+  "java",
+  "cpp",
+  "c",
+  "csharp",
+  "go",
+  "rust",
+  "php",
+  "ruby",
+  "swift",
+  "kotlin",
+  "sql",
+  "html",
+  "css",
+  "shell",
+  "other"
+];
+var generateCodeTool = {
+  name: "generate_code",
+  description: "Generate code in a specific programming language from a natural-language description, using UniAI's configured code model. Use when the user explicitly asks to generate/write a standalone function, script, or snippet in a named language and wants it produced by the platform's code model. Returns the generated code as text.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      description: {
+        type: "string",
+        description: "What the code should do, in natural language. Required."
+      },
+      language: {
+        type: "string",
+        description: "Target programming language. Required.",
+        enum: CODE_LANGUAGES
+      },
+      context: {
+        type: "string",
+        description: "Optional extra context such as existing code, constraints, or environment."
+      },
+      requirements: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional list of specific requirements the code must satisfy."
+      }
+    },
+    required: ["description", "language"]
+  },
+  handler: async (args, env) => {
+    try {
+      const description = args.description;
+      if (typeof description !== "string" || description.trim() === "") {
+        return toMcpError(
+          new Error("description must be a non-empty string"),
+          "Code generation failed"
+        );
+      }
+      const language = args.language;
+      if (typeof language !== "string" || !CODE_LANGUAGES.includes(language)) {
+        return toMcpError(
+          new Error(`language must be one of: ${CODE_LANGUAGES.join(", ")}`),
+          "Code generation failed"
+        );
+      }
+      const body = { description, language };
+      if (typeof args.context === "string" && args.context.trim() !== "") {
+        body.context = args.context;
+      }
+      if (Array.isArray(args.requirements)) {
+        const reqs = args.requirements.filter(
+          (r) => typeof r === "string" && r.trim() !== ""
+        );
+        if (reqs.length > 0) body.requirements = reqs;
+      }
+      const res = await callUniAI(
+        env,
+        "POST",
+        "/code/generate",
+        body,
+        { timeoutMs: POLL_MAX_MS }
+      );
+      if (!res.code) {
+        return toMcpError(
+          new Error("task completed but no code returned"),
+          "Code generation failed"
+        );
+      }
+      return { content: [{ type: "text", text: res.code }] };
+    } catch (err) {
+      return toMcpError(err, "Code generation failed");
+    }
+  }
+};
+
+// src/commands/code.ts
+async function runCode(rest, flags) {
+  const description = rest.join(" ").trim();
+  const language = typeof flags.language === "string" ? flags.language : void 0;
+  if (!description || !language) {
+    console.error('usage: uniai code "<description>" --language <python|typescript|...> [--json]');
+    if (description && !language) console.error("note: --language is required.");
+    return 2;
+  }
+  return runTool(generateCodeTool, { description, language }, flags);
+}
+
+// ../uniai-core/src/tools/web-search.ts
+var webSearchTool = {
+  name: "web_search",
+  description: "Search the web for up-to-date information and return a summary plus a list of result titles, URLs, and snippets. Use when the user asks to look something up, find current/recent information, research a topic, check the latest news, or verify a fact that may have changed. Prefer this over guessing when the answer depends on recent or external data.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query or keywords in natural language (max 200 characters). Required.",
+        maxLength: 200
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (1-20). Default 10.",
+        minimum: 1,
+        maximum: 20,
+        default: 10
+      }
+    },
+    required: ["query"]
+  },
+  handler: async (args, env) => {
+    try {
+      const query = typeof args.query === "string" ? args.query.trim() : "";
+      if (query === "") {
+        return toMcpError(
+          new Error("query must be a non-empty string"),
+          "Web search failed"
+        );
+      }
+      if (query.length > 200) {
+        return toMcpError(
+          new Error(`query is ${query.length} characters; the limit is 200. Use shorter keywords.`),
+          "Web search failed"
+        );
+      }
+      const body = { query };
+      if (typeof args.limit === "number") {
+        body.limit = args.limit;
+      }
+      const res = await callUniAI(env, "POST", "/search/web", body, {
+        timeoutMs: 6e4
+      });
+      const results = res.results ?? [];
+      const summary = res.summary ?? "";
+      if (results.length === 0 && summary === "") {
+        return toMcpError(new Error("no results returned"), "Web search failed");
+      }
+      const lines = [];
+      if (res.simulated) {
+        lines.push(
+          "(Note: live web search was unavailable; the results below are AI-approximated and may be inaccurate.)",
+          ""
+        );
+      }
+      if (summary) {
+        lines.push(summary, "");
+      }
+      results.forEach((r, i) => {
+        lines.push(`${i + 1}. ${r.title}`);
+        lines.push(`   ${r.url}`);
+        if (r.snippet) lines.push(`   ${r.snippet}`);
+      });
+      return { content: [{ type: "text", text: lines.join("\n").trim() }] };
+    } catch (err) {
+      return toMcpError(err, "Web search failed");
+    }
+  }
+};
+
+// src/commands/search.ts
+var num4 = (v) => typeof v === "string" && v.trim() !== "" && !Number.isNaN(Number(v)) ? Number(v) : void 0;
+async function runSearch(rest, flags) {
+  const query = rest.join(" ").trim();
+  if (!query) {
+    console.error('usage: uniai search "<query>" [--limit 1-20] [--json]');
+    return 2;
+  }
+  return runTool(webSearchTool, { query, limit: num4(flags.limit) }, flags);
+}
+
+// ../uniai-core/src/tools/ocr.ts
+var ocrTool = {
+  name: "ocr",
+  description: "Extract text from an image (OCR / optical character recognition). Use when the user wants to read or pull text out of a picture, screenshot, scanned document, receipt, or photo. Accepts a local file path, an http(s) URL, or a base64 data URL (PNG/JPEG/WebP, up to 10MB). Returns the recognized text.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      image: {
+        type: "string",
+        description: "The image to read text from: a local file path, an http(s) URL, or a base64 data URL. PNG/JPEG/WebP, up to 10MB. Required."
+      }
+    },
+    required: ["image"]
+  },
+  handler: async (args, env) => {
+    try {
+      const image = args.image;
+      if (typeof image !== "string" || image.trim() === "") {
+        return toMcpError(
+          new Error("image must be a non-empty string (file path, URL, or data URL)"),
+          "OCR failed"
+        );
+      }
+      const file = await resolveFileInput(image);
+      const res = await postMultipart(env, "/ocr", "image", file);
+      if (typeof res.text !== "string") {
+        return toMcpError(new Error("OCR returned no text field"), "OCR failed");
+      }
+      const text = res.text.trim() === "" ? "(no text detected in image)" : res.text;
+      const lines = [text];
+      if (res.detectedLanguage) {
+        lines.push("", `(detected language: ${res.detectedLanguage})`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    } catch (err) {
+      return toMcpError(err, "OCR failed");
+    }
+  }
+};
+
+// src/commands/ocr.ts
+async function runOcr(rest, flags) {
+  const image = rest[0];
+  if (!image) {
+    console.error("usage: uniai ocr <image: path|url> [--json]");
+    return 2;
+  }
+  return runTool(ocrTool, { image }, flags);
+}
+
+// src/commands/usage.ts
+async function runUsage(_rest, flags) {
+  const asJson = flags.json === true || flags.json === "true";
+  try {
+    const env = await resolveEnv(flags);
+    const { credits } = await callUniAI(env, "GET", "/credits");
+    const text = `Credits available: ${credits.total}  (floor: ${credits.creditFloor})`;
+    if (asJson) {
+      process.stdout.write(
+        JSON.stringify({
+          ok: true,
+          text,
+          credits: { total: credits.total, creditFloor: credits.creditFloor }
+        }) + "\n"
+      );
+    } else {
+      process.stdout.write(text + "\n");
+    }
+    return 0;
+  } catch (err) {
+    return fail(err instanceof Error ? err.message : String(err), asJson);
+  }
+}
+
+// src/commands/config.ts
+var KEY_ALIASES = {
+  token: "token",
+  pat: "token",
+  "api-key": "token",
+  api_key: "token",
+  apikey: "token",
+  apibase: "apiBase",
+  "api-base": "apiBase",
+  api_base: "apiBase",
+  base_url: "apiBase",
+  baseurl: "apiBase"
+};
+var CANONICAL_KEYS = ["token", "apiBase"];
+async function runConfig(rest, flags) {
+  const verb = rest[0];
+  if (verb === "show") {
+    const cfg = await readConfig();
+    const view = {
+      token: cfg.token ? maskToken(cfg.token) : "(unset)",
+      apiBase: cfg.apiBase ?? "(default)"
+    };
+    process.stdout.write(JSON.stringify(view, null, 2) + "\n");
+    return 0;
+  }
+  if (verb === "set") {
+    const key = typeof flags.key === "string" ? flags.key : void 0;
+    const value = typeof flags.value === "string" ? flags.value : void 0;
+    if (!key || value === void 0) {
+      console.error("usage: uniai config set --key <token|apiBase> --value <v>");
+      return 2;
+    }
+    const canonical = KEY_ALIASES[key.toLowerCase()];
+    if (!canonical) {
+      console.error(
+        `unknown config key: ${key}. Allowed: ${CANONICAL_KEYS.join(", ")} (aliases: base_url / api-base / api_base -> apiBase, api_key / pat -> token)`
+      );
+      return 2;
+    }
+    await writeConfig({ [canonical]: value });
+    process.stderr.write(`set ${canonical}
+`);
+    return 0;
+  }
+  if (verb === "reset") {
+    await clearConfig();
+    process.stderr.write("cleared ~/.uniai/config.json\n");
+    return 0;
+  }
+  console.error("usage: uniai config show | set --key <k> --value <v> | reset");
+  return 2;
+}
+
+// src/commands/auth.ts
+async function runAuth(rest, flags) {
+  const verb = rest[0];
+  if (verb === "login") return login(flags);
+  if (verb === "logout") {
+    await unsetConfigKeys(["token"]);
+    process.stderr.write("logged out (removed stored token from ~/.uniai/config.json)\n");
+    return 0;
+  }
+  if (verb === "status") {
+    const cfg = await readConfig();
+    const view = {
+      loggedIn: Boolean(cfg.token),
+      token: cfg.token ? maskToken(cfg.token) : "(unset)",
+      apiBase: cfg.apiBase ?? "(default)"
+    };
+    process.stdout.write(JSON.stringify(view, null, 2) + "\n");
+    return 0;
+  }
+  console.error("usage: uniai auth login --token <PAT> [--api-base <url>] | logout | status");
+  return 2;
+}
+async function login(flags) {
+  const token = typeof flags.token === "string" ? flags.token.trim() : "";
+  if (!token) {
+    console.error("usage: uniai auth login --token <PAT> [--api-base <url>]");
+    console.error("note: token also accepted via UNIAI_TOKEN env.");
+    return 2;
+  }
+  const check = validatePatFormat(token);
+  if (!check.ok) {
+    console.error(`invalid PAT format (${check.reason}). Expected uap_\u2026 personal access token.`);
+    return 1;
+  }
+  const apiBase = typeof flags["api-base"] === "string" ? flags["api-base"] : void 0;
+  await writeConfig(apiBase ? { token, apiBase } : { token });
+  process.stderr.write("saved credentials to ~/.uniai/config.json\n");
+  return 0;
+}
+
+// src/commands/skills.ts
+import { join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/lib/skills-install.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync2,
+  statSync,
+  rmSync as rmSync2,
+  cpSync,
+  symlinkSync,
+  lstatSync,
+  readlinkSync
+} from "node:fs";
+import { execFileSync } from "node:child_process";
+import { tmpdir, homedir as homedir2 } from "node:os";
+import { join as join2, basename as basename2, isAbsolute, resolve } from "node:path";
+var SLUG_REGEX = /^[a-z0-9][a-z0-9-]{0,98}[a-z0-9]$|^[a-z0-9]$/;
+function extractScalar(fm, key) {
+  const m = new RegExp(`^${key}:[ \\t]*(.*)$`, "m").exec(fm);
+  if (!m) return "";
+  return m[1].trim().replace(/^["']|["']$/g, "");
+}
+function parseSkillMeta(skillMd) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd);
+  if (!block) return { name: "", description: "" };
+  return {
+    name: extractScalar(block[1], "name"),
+    description: extractScalar(block[1], "description")
+  };
+}
+function sanitizeSlug(raw) {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100);
+}
+function discoverSkills(root) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const consider = (dir, fallbackName) => {
+    const skillMd = join2(dir, "SKILL.md");
+    if (!existsSync2(skillMd)) return;
+    let meta = { name: "", description: "" };
+    try {
+      meta = parseSkillMeta(readFileSync2(skillMd, "utf8"));
+    } catch {
+    }
+    const slug = sanitizeSlug(meta.name || fallbackName);
+    if (!SLUG_REGEX.test(slug) || seen.has(slug)) return;
+    seen.add(slug);
+    found.push({ dir, slug, name: meta.name || slug, description: meta.description });
+  };
+  consider(root, basename2(root));
+  for (const sub of [".", "skills"]) {
+    const base = sub === "." ? root : join2(root, sub);
+    let entries;
+    try {
+      entries = readdirSync(base);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (name.startsWith(".")) continue;
+      const dir = join2(base, name);
+      try {
+        if (!statSync(dir).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      consider(dir, name);
+    }
+  }
+  return found;
+}
+function toGitUrl(source) {
+  if (/^https?:\/\//.test(source) || source.startsWith("git@")) return source;
+  if (/^[\w.-]+\/[\w.-]+$/.test(source)) return `https://github.com/${source}.git`;
+  return null;
+}
+function resolveSource(source, ref) {
+  const localPath = isAbsolute(source) ? source : resolve(process.cwd(), source);
+  if (existsSync2(localPath) && statSync(localPath).isDirectory()) {
+    return { dir: localPath, cleanup: () => {
+    } };
+  }
+  const url = toGitUrl(source);
+  if (!url) {
+    throw new Error(
+      `Cannot resolve source "${source}" \u2014 not a local directory, "owner/repo", or git URL.`
+    );
+  }
+  const tmp = join2(tmpdir(), `uniai-skills-${Date.now()}-${process.pid}`);
+  const args = ["clone", "--depth", "1"];
+  if (ref) args.push("--branch", ref);
+  args.push(url, tmp);
+  try {
+    execFileSync("git", args, { stdio: ["ignore", "ignore", "pipe"] });
+  } catch (err) {
+    throw new Error(
+      `git clone failed for ${url}. Is git installed and the repo accessible? ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return {
+    dir: tmp,
+    cleanup: () => {
+      try {
+        rmSync2(tmp, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+function installSkill(skill, destRoot, force) {
+  if (!SLUG_REGEX.test(skill.slug)) throw new Error(`unsafe slug rejected: ${skill.slug}`);
+  const dest = join2(destRoot, skill.slug);
+  if (existsSync2(dest)) {
+    if (!force) return "skipped";
+    rmSync2(dest, { recursive: true, force: true });
+  }
+  mkdirSync2(destRoot, { recursive: true });
+  cpSync(skill.dir, dest, { recursive: true });
+  return "installed";
+}
+function listInstalled(destRoot) {
+  let entries;
+  try {
+    entries = readdirSync(destRoot);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries.sort()) {
+    if (name.startsWith(".") || !SLUG_REGEX.test(name)) continue;
+    const skillMd = join2(destRoot, name, "SKILL.md");
+    if (!existsSync2(skillMd)) continue;
+    let meta = { name: "", description: "" };
+    try {
+      meta = parseSkillMeta(readFileSync2(skillMd, "utf8"));
+    } catch {
+    }
+    out.push({ slug: name, name: meta.name || name, description: meta.description });
+  }
+  return out;
+}
+var KNOWN_AGENT_APPS = [
+  { app: "Claude Code", segs: [".claude", "skills"] },
+  { app: "TRAE", segs: [".trae", "skills"] },
+  { app: "TRAE CN", segs: [".trae-cn", "skills"] },
+  { app: "Cursor", segs: [".cursor", "skills"] },
+  { app: "Qwen Code", segs: [".qwen", "skills"] },
+  { app: "Lingma", segs: [".lingma", "skills"] },
+  { app: "CodeBuddy", segs: [".codebuddy", "skills"] },
+  { app: "Qoder", segs: [".qoder", "skills"] },
+  { app: "Qoder CN", segs: [".qoder-cn", "skills"] },
+  { app: "iFlow CLI", segs: [".iflow", "skills"] },
+  { app: "CodeArts Doer", segs: [".codeartsdoer", "skills"] },
+  { app: "Windsurf", segs: [".codeium", "windsurf", "skills"] },
+  { app: "Roo Code", segs: [".roo", "skills"] },
+  { app: "Kilo Code", segs: [".kilocode", "skills"] },
+  { app: "Continue", segs: [".continue", "skills"] },
+  { app: "Augment", segs: [".augment", "skills"] },
+  { app: "Junie", segs: [".junie", "skills"] },
+  { app: "Kiro", segs: [".kiro", "skills"] },
+  { app: "OpenHands", segs: [".openhands", "skills"] },
+  { app: "Factory", segs: [".factory", "skills"] },
+  { app: "Rovo Dev", segs: [".rovodev", "skills"] },
+  { app: "Zencoder", segs: [".zencoder", "skills"] },
+  { app: "Tabnine", segs: [".tabnine", "agent", "skills"] },
+  { app: "Snowflake Cortex", segs: [".snowflake", "cortex", "skills"] },
+  { app: "Devin", segs: [".config", "devin", "skills"] },
+  { app: "Goose", segs: [".config", "goose", "skills"] },
+  { app: "Crush", segs: [".config", "crush", "skills"] },
+  { app: "AiderDesk", segs: [".aider-desk", "skills"] },
+  { app: "AstrBot", segs: [".astrbot", "data", "skills"] },
+  { app: "Autohand Code CLI", segs: [".autohand", "skills"] },
+  { app: "IBM Bob", segs: [".bob", "skills"] },
+  { app: "Forge", segs: [".forge", "skills"] },
+  { app: "Hermes", segs: [".hermes", "skills"] },
+  { app: "CommandCode", segs: [".commandcode", "skills"] },
+  { app: "CodeMaker", segs: [".codemaker", "skills"] },
+  { app: "CodeStudio", segs: [".codestudio", "skills"] },
+  { app: "inference.sh", segs: [".inferencesh", "skills"] },
+  { app: "Jazz", segs: [".jazz", "skills"] },
+  { app: "Kode", segs: [".kode", "skills"] },
+  { app: "MCPJam", segs: [".mcpjam", "skills"] },
+  { app: "Moxby", segs: [".moxby", "skills"] },
+  { app: "Mux", segs: [".mux", "skills"] },
+  { app: "Neovate", segs: [".neovate", "skills"] },
+  { app: "Ona", segs: [".ona", "skills"] },
+  { app: "OpenClaw", segs: [".openclaw", "skills"] },
+  { app: "Pochi", segs: [".pochi", "skills"] },
+  { app: "Reasonix", segs: [".reasonix", "skills"] },
+  { app: "TerraMind", segs: [".terramind", "skills"] },
+  { app: "TinyCloud", segs: [".tinycloud", "skills"] },
+  { app: "Vibe", segs: [".vibe", "skills"] },
+  { app: "Adal", segs: [".adal", "skills"] },
+  { app: "Pi", segs: [".pi", "agent", "skills"] }
+];
+function knownAgentSkillDirs() {
+  const override = process.env.AGENT_SKILL_DIRS?.trim();
+  if (override) {
+    return override.split(":").filter(Boolean).map((d) => ({ app: d, dir: d }));
+  }
+  return KNOWN_AGENT_APPS.map(({ app, segs }) => ({ app, dir: join2(homedir2(), ...segs) }));
+}
+function bridgeToAgentApps(slug, canonicalDir) {
+  if (!SLUG_REGEX.test(slug)) return [];
+  const bridged = [];
+  for (const { app, dir } of knownAgentSkillDirs()) {
+    try {
+      mkdirSync2(dir, { recursive: true });
+      const link = join2(dir, slug);
+      let st = null;
+      try {
+        st = lstatSync(link);
+      } catch {
+        st = null;
+      }
+      if (st) {
+        if (st.isSymbolicLink()) {
+          try {
+            if (readlinkSync(link) === canonicalDir) bridged.push(app);
+          } catch {
+          }
+        }
+        continue;
+      }
+      symlinkSync(canonicalDir, link, "dir");
+      bridged.push(app);
+    } catch {
+    }
+  }
+  return bridged;
+}
+function unbridgeFromAgentApps(slug, canonicalDir) {
+  if (!SLUG_REGEX.test(slug)) return;
+  for (const { dir } of knownAgentSkillDirs()) {
+    try {
+      const link = join2(dir, slug);
+      const st = lstatSync(link);
+      if (st.isSymbolicLink() && readlinkSync(link) === canonicalDir) {
+        rmSync2(link, { force: true });
+      }
+    } catch {
+    }
+  }
+}
+function removeInstalled(destRoot, slug) {
+  if (!SLUG_REGEX.test(slug)) throw new Error(`unsafe slug rejected: ${slug}`);
+  const dest = join2(destRoot, slug);
+  if (!existsSync2(dest)) return false;
+  rmSync2(dest, { recursive: true, force: true });
+  return true;
+}
+
+// src/commands/skills.ts
+var SKILLS_HELP = `uniai skills \u2014 install / list / remove Agent Skills (~/.agents/skills)
+
+  uniai skills add ${DEFAULT_SKILL_REMOTE} --ref release -g   recommended: install the UniAI skill from the remote source (latest published)
+  uniai skills add <source> [--all] [--skill <a,b>] [--ref <branch>] [-g|--global] [-f|--force] [--json]
+       <source> = local directory | owner/repo | git URL
+  uniai skills add --self [-g|--global]                       offline fallback: install the UniAI skill bundled in this package
+  uniai skills list [-g|--global] [--json]
+  uniai skills remove <slug> [-g|--global] [--json]
+
+  -g / --global   target ~/.agents/skills (default: <cwd>/.agents/skills)
+  --self          install the bundled UniAI skill (offline fallback for \`${DEFAULT_SKILL_REMOTE}\`; teaches agents to use \`uniai\`)
+  --all           install every skill found in <source>
+  --skill <a,b>   install only these skill names/slugs (comma-separated)
+  --ref <branch>  clone a specific branch/tag (e.g. --ref release to get published content)
+  --force         overwrite if already installed
+  --json          machine-readable output (envelope on stdout; progress stays on stderr)`;
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function outJson(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+function failSkills(message, asJson) {
+  if (asJson) outJson({ ok: false, error: message });
+  else process.stderr.write(message + "\n");
+  return 1;
+}
+async function runSkills(rest, flags) {
+  const asJson = flags.json === true || flags.json === "true";
+  const opts = {
+    global: flags.global === true,
+    all: flags.all === true,
+    force: flags.force === true
+  };
+  const args = [];
+  for (const tok of rest) {
+    if (tok === "-g") opts.global = true;
+    else if (tok === "-a") opts.all = true;
+    else if (tok === "-f") opts.force = true;
+    else args.push(tok);
+  }
+  const sub = args[0];
+  switch (sub) {
+    case "add":
+      return addCmd(args.slice(1), opts, flags, asJson);
+    case "list":
+    case "ls":
+      return listCmd(opts, asJson);
+    case "remove":
+    case "rm":
+      return removeCmd(args.slice(1), opts, asJson);
+    default:
+      if (sub) return failSkills(`unknown skills subcommand: ${sub}`, asJson);
+      console.log(SKILLS_HELP);
+      return 0;
+  }
+}
+function bundledSkillDir() {
+  return fileURLToPath2(new URL("../skill", import.meta.url));
+}
+function addCmd(args, opts, flags, asJson) {
+  const source = flags.self === true ? bundledSkillDir() : args[0];
+  if (!source) {
+    return failSkills(
+      "skills add: missing <source> (local dir | owner/repo | git URL), or pass --self for the bundled UniAI skill",
+      asJson
+    );
+  }
+  const destRoot = resolveSkillsDir(opts.global);
+  const ref = typeof flags.ref === "string" ? flags.ref : void 0;
+  const skillFilter = typeof flags.skill === "string" ? new Set(
+    flags.skill.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean)
+  ) : null;
+  let resolved;
+  let usedBundledFallback = false;
+  try {
+    resolved = resolveSource(source, ref);
+  } catch (e) {
+    if (flags.self !== true && source === DEFAULT_SKILL_REMOTE) {
+      if (!asJson)
+        process.stderr.write(
+          `Remote ${source} unreachable (${msg(e)}); falling back to the bundled UniAI skill.
+`
+        );
+      try {
+        resolved = resolveSource(bundledSkillDir());
+        usedBundledFallback = true;
+      } catch (e2) {
+        return failSkills(msg(e2), asJson);
+      }
+    } else {
+      return failSkills(msg(e), asJson);
+    }
+  }
+  try {
+    const discovered = discoverSkills(resolved.dir);
+    if (discovered.length === 0) {
+      return failSkills(`No SKILL.md found in "${source}".`, asJson);
+    }
+    let selected;
+    if (skillFilter) {
+      selected = discovered.filter(
+        (s) => skillFilter.has(s.slug) || skillFilter.has(s.name.toLowerCase())
+      );
+      if (selected.length === 0) {
+        const available = discovered.map((s) => s.slug);
+        if (asJson) {
+          outJson({ ok: false, error: "none of --skill matched", available });
+          return 1;
+        }
+        process.stderr.write(`None of --skill matched. Available in "${source}":
+`);
+        for (const s of discovered) process.stderr.write(`  - ${s.slug}
+`);
+        return 1;
+      }
+    } else if (opts.all || discovered.length === 1) {
+      selected = discovered;
+    } else {
+      const available = discovered.map((s) => s.slug);
+      if (asJson) {
+        outJson({ ok: false, error: `found ${discovered.length} skills; pass --all or --skill <name>`, available });
+        return 1;
+      }
+      process.stderr.write(
+        `Found ${discovered.length} skills in "${source}". Use --all or --skill <name>:
+`
+      );
+      for (const s of discovered) process.stderr.write(`  - ${s.slug}
+`);
+      return 1;
+    }
+    const installed = [];
+    const skipped = [];
+    const failed = [];
+    for (const s of selected) {
+      try {
+        const r = installSkill(s, destRoot, opts.force);
+        if (r === "installed") {
+          installed.push(s.slug);
+          if (!asJson) process.stderr.write(`  \u2713 ${s.slug}
+`);
+        } else {
+          skipped.push(s.slug);
+          if (!asJson) process.stderr.write(`  \u2022 ${s.slug} (already installed; use --force to overwrite)
+`);
+        }
+      } catch (e) {
+        failed.push({ slug: s.slug, error: msg(e) });
+        if (!asJson) process.stderr.write(`  \u2717 ${s.slug}: ${msg(e)}
+`);
+      }
+    }
+    if (!asJson) {
+      process.stderr.write(
+        `Installed ${installed.length} skill(s) to ${destRoot}${skipped.length ? `, skipped ${skipped.length}` : ""}.
+`
+      );
+    }
+    const linkedApps = [];
+    if (opts.global) {
+      const apps = /* @__PURE__ */ new Set();
+      for (const s of selected) {
+        for (const app of bridgeToAgentApps(s.slug, join3(destRoot, s.slug))) apps.add(app);
+      }
+      linkedApps.push(...apps);
+      if (!asJson && apps.size > 0) {
+        const names = [...apps];
+        const head = names.slice(0, 5).join(", ");
+        const more = names.length > 5 ? ` +${names.length - 5} more` : "";
+        process.stderr.write(`Linked into: ${head}${more} (+ any tool scanning ~/.agents/skills).
+`);
+      }
+    }
+    if (asJson) {
+      outJson({
+        ok: failed.length === 0,
+        dir: destRoot,
+        installed,
+        skipped,
+        failed,
+        linkedApps,
+        // signal when the install came from the package-bundled copy (remote unreachable) rather than the live remote
+        ...usedBundledFallback ? { source: "bundled-fallback" } : {}
+      });
+    } else {
+      for (const s of selected) process.stdout.write(`${s.slug}
+`);
+    }
+    return 0;
+  } finally {
+    resolved.cleanup();
+  }
+}
+function listCmd(opts, asJson) {
+  const destRoot = resolveSkillsDir(opts.global);
+  const skills = listInstalled(destRoot);
+  if (asJson) {
+    outJson({ ok: true, dir: destRoot, skills: skills.map((s) => ({ slug: s.slug, name: s.name })) });
+    return 0;
+  }
+  if (skills.length === 0) {
+    process.stderr.write(`No skills installed in ${destRoot}.
+`);
+    return 0;
+  }
+  process.stderr.write(`${skills.length} skill(s) in ${destRoot}:
+`);
+  for (const s of skills) process.stdout.write(`${s.slug}	${s.name}
+`);
+  return 0;
+}
+function removeCmd(args, opts, asJson) {
+  const slug = args[0];
+  if (!slug) {
+    return failSkills("skills remove: missing <slug>", asJson);
+  }
+  const destRoot = resolveSkillsDir(opts.global);
+  try {
+    if (opts.global) unbridgeFromAgentApps(slug, join3(destRoot, slug));
+    const ok = removeInstalled(destRoot, slug);
+    if (ok) {
+      if (asJson) outJson({ ok: true, dir: destRoot, removed: slug });
+      else process.stderr.write(`Removed ${slug} from ${destRoot}.
+`);
+      return 0;
+    }
+    return failSkills(`${slug} not found in ${destRoot}.`, asJson);
+  } catch (e) {
+    return failSkills(msg(e), asJson);
+  }
+}
+
+// src/lib/args.ts
+function parseArgs(argv) {
+  const flags = {};
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const key = a.slice(2);
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      }
+    } else {
+      positionals.push(a);
+    }
+  }
+  return { positionals, flags };
+}
+
+// src/cli.ts
+var HELP = `uniai \u2014 UniAI platform CLI (install MCP tools into Codex, or call features directly)
+
+Setup / installer:
+  uniai init [--token <PAT>] [--api-base <url>]   Install UniAI MCP server into ~/.codex/config.toml
+  uniai uninstall                                  Remove it (keeps your other config intact)
+  uniai status                                     Show install status (read-only)
+  uniai update [--check]                           Update @uniai/cli to the latest npm version
+  uniai auth login --token <PAT> [--api-base <url>]  Save credentials for direct commands (~/.uniai/config.json)
+  uniai auth logout | status                         Clear / show stored credentials
+  uniai config show | set --key <token|apiBase> --value <v> | reset
+
+Direct commands (call UniAI platform features from the terminal):
+  uniai image generate "<prompt>" [--model] [--aspect-ratio] [--count] [--quality] [--reference <path|url>] [--download <file>]
+  uniai image models                     List available image models (so you can pick --model / --aspect-ratio / etc.)
+  uniai image edit --image <url> [--output-format png|jpg|webp] [--edge-type sharp|feather] [--download <file>]
+  uniai video generate "<prompt>" [--model] [--aspect-ratio] [--duration] [--first-frame <img>] [--reference <img,..>] [--source-video <vid>] [--download <file>]
+  uniai video models                     List available video models (modes, durations, resolutions, audio support)
+  uniai speech synthesize "<text>" [--voice] [--format] [--rate 0.5-2.0] [--download <file>]
+  uniai speech recognize <audio: path|url> [--language auto|zh|en|ja|ko]
+  uniai chat "<message>"
+  uniai code "<description>" --language <python|typescript|...>
+  uniai search "<query>" [--limit 1-20]
+  uniai ocr <image: path|url>
+  uniai usage                            Show your credit balance \u2014 check budget before spending (alias: quota)
+
+Agent Skills (install UniAI / community skills into ~/.agents/skills, shared across agent apps):
+  uniai skills add ${DEFAULT_SKILL_REMOTE} --ref release -g   recommended: the UniAI skill (latest published)
+  uniai skills add <source> [--all] [--skill <a,b>] [--ref <branch>] [-g|--global] [-f|--force]
+       <source> = local directory | owner/repo | git URL  (--self = offline bundled fallback)
+  uniai skills list [-g|--global]
+  uniai skills remove <slug> [-g|--global]
+
+  Common flags: --token <PAT> / --api-base <url> (override env & config),
+                --download <file> (save returned media), --json (machine-readable output)
+  Credentials priority: --token > UNIAI_TOKEN env > ~/.uniai/config.json
+
+Machine-readable output (for AI agents & scripts):
+  --json emits a JSON envelope instead of text:
+    success: {"ok":true,"text":"...","url":"<media url, when present>"}
+    failure: {"ok":false,"error":"..."}
+  Exit codes: 0 success \xB7 1 runtime / auth / network error \xB7 2 invalid usage
+
+  uniai <command> --help   Show help for a single command
+  uniai --help | --version`;
+var COMMAND_HELP = {
+  image: `uniai image \u2014 generate or edit images, or list models
+  uniai image generate "<prompt>" [--model <id>] [--aspect-ratio 1:1|16:9|9:16|4:3|3:4|21:9|3:1] [--count <n>] [--quality low|medium|high] [--resolution 1K|2K|4K] [--negative-prompt <text>] [--seed <n>] [--reference <path|url>[,...]] [--download <file>] [--json]
+       pass only what the user specified; anything omitted uses the platform-recommended default. Param support is per-model \u2014 run \`uniai image models\`.
+       --reference = image-to-image (variation / style / character consistency). Each ref is a local file path, http(s) URL, or data URL;
+                     local files are uploaded for you. Up to 5, comma-separated. e.g. uniai image generate "full body, black dress" --reference ./person.webp
+  uniai image models   list the platform's live image models + each one's supported aspect ratios / quality tiers / max count / reference-image limit
+  uniai image edit --image <url> [--output-format png|jpg|webp] [--edge-type sharp|feather] [--download <file>] [--json]
+       --image (edit) = sharpen/feather edges or process background; URL only. For "change clothing / new pose from my photo", use \`generate --reference\` instead.`,
+  video: `uniai video \u2014 generate a video, or list models
+  uniai video generate "<prompt>" [--model <id>] [--aspect-ratio 16:9|9:16|1:1|4:3|3:4|21:9|adaptive] [--duration <2-15>] [--resolution 480p|720p|1080p] [--negative-prompt <text>] [--seed <n>] [--download <file>] [--json]
+       media inputs (the MODE is auto-derived from what you attach; local files are uploaded for you):
+         --first-frame <img>                animate an image (image-to-video)
+         --first-frame <img> --last-frame <img>   first\u2192last frame interpolation
+         --reference <img,..> [--reference-video <vid,..>] [--reference-audio <aud,..>]  reference-to-video (omni)
+         --source-video <vid> [--v2v-endpoint edit|reference]   edit / restyle a clip (video-to-video)
+         --continuation-video <vid>         extend a clip
+         (none)                             text-to-video
+       a prompt is always required. pass only what the user specified; the rest uses recommended defaults.
+  uniai video models   list the platform's live video models + each one's modes / durations / resolutions / aspect ratios / audio support`,
+  speech: `uniai speech \u2014 text-to-speech (synthesize) and speech-to-text (recognize)
+  uniai speech synthesize "<text>" [--voice <id>] [--format mp3|wav|pcm|opus|aac|flac] [--rate 0.5-2.0] [--download <file>] [--json]
+  uniai speech recognize <audio: path|url> [--language auto|zh|en|ja|ko] [--json]`,
+  chat: `uniai chat \u2014 ask the configured chat model; returns a single text response
+  uniai chat "<message>" [--json]`,
+  code: `uniai code \u2014 generate code (--language is required)
+  uniai code "<description>" --language <python|typescript|...> [--json]`,
+  search: `uniai search \u2014 web search
+  uniai search "<query>" [--limit 1-20] [--json]`,
+  ocr: `uniai ocr \u2014 extract text from an image (optical character recognition)
+  uniai ocr <image: path|url|dataURL> [--json]`,
+  usage: `uniai usage \u2014 show your credit balance, so you can check the budget before spending
+  uniai usage [--json]    (alias: uniai quota)`,
+  quota: `uniai quota \u2014 alias of \`uniai usage\`: show your credit balance
+  uniai quota [--json]`,
+  config: `uniai config \u2014 view or change stored credentials/config (~/.uniai/config.json)
+  uniai config show
+  uniai config set --key <token|apiBase> --value <value>   (key aliases: base_url / api-base -> apiBase, api_key / pat -> token)
+  uniai config reset`,
+  auth: `uniai auth \u2014 manage credentials for direct commands
+  uniai auth login --token <PAT> [--api-base <url>]
+  uniai auth status
+  uniai auth logout`,
+  skills: `uniai skills \u2014 install Agent Skills into ~/.agents/skills (shared across agent apps)
+  uniai skills add ${DEFAULT_SKILL_REMOTE} --ref release -g   recommended: the UniAI skill from the remote source (latest published)
+  uniai skills add <source> [--all] [--skill <a,b>] [--ref <branch>] [-g|--global] [-f|--force] [--json]
+       <source> = local directory | owner/repo | git URL
+  uniai skills add --self [-g|--global]   offline fallback: the UniAI skill bundled in this package (auto-used when the remote is unreachable)
+  uniai skills list [-g|--global] [--json]
+  uniai skills remove <slug> [-g|--global] [--json]`,
+  update: `uniai update \u2014 update @uniai/cli to the latest version published on npm
+  uniai update [--check] [--json]    --check only reports; default installs @uniai/cli@latest`,
+  init: `uniai init \u2014 install the UniAI MCP server into ~/.codex/config.toml
+  uniai init [--token <PAT>] [--api-base <url>]`,
+  uninstall: `uniai uninstall \u2014 remove the UniAI MCP server (keeps your other Codex config intact)`,
+  status: `uniai status \u2014 show install status (read-only)`
+};
+var DIRECT = {
+  image: runImage,
+  video: runVideo,
+  speech: runSpeech,
+  chat: runChat,
+  code: runCode,
+  search: runSearch,
+  ocr: runOcr,
+  usage: runUsage,
+  quota: runUsage,
+  config: runConfig,
+  auth: runAuth,
+  skills: runSkills
+};
+async function main() {
+  const raw = process.argv.slice(2);
+  if (raw.includes("-v") || raw.includes("--version")) {
+    console.log(VERSION);
+    return 0;
+  }
+  const { positionals, flags } = parseArgs(raw);
+  const cmd = positionals[0];
+  const rest = positionals.slice(1);
+  const helpRequested = raw.includes("-h") || raw.includes("--help");
+  if (helpRequested && cmd && cmd in COMMAND_HELP) {
+    console.log(COMMAND_HELP[cmd]);
+    return 0;
+  }
+  if (helpRequested || cmd === "help" || raw.length === 0) {
+    console.log(HELP);
+    return 0;
+  }
+  if (cmd && cmd in DIRECT) {
+    return DIRECT[cmd](rest, flags);
+  }
+  switch (cmd) {
+    case "init":
+      return runInit({
+        token: typeof flags.token === "string" ? flags.token : null,
+        apiBase: typeof flags["api-base"] === "string" ? flags["api-base"] : null
+      });
+    case "uninstall":
+      return runUninstall();
+    case "status":
+      return runStatus();
+    case "update":
+      return runUpdate(rest, flags);
+    default:
+      console.error(`Unknown command: ${String(cmd)}`);
+      console.log(HELP);
+      return 1;
+  }
+}
+main().then((code) => process.exit(code)).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});