jimeng-cli 0.2.0

package/dist/mcp/index.js

@@ -0,0 +1,831 @@
+import {
+  DEFAULT_IMAGE_MODEL,
+  DEFAULT_MODEL,
+  buildRegionInfo,
+  environment_default,
+  generateImageComposition,
+  generateImages,
+  generateVideo,
+  getLiveModels,
+  getTaskResponse,
+  session_pool_default,
+  util_default,
+  waitForTaskResponse
+} from "../chunk-JZY62VNI.js";
+
+// src/mcp/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/config.ts
+function parseBoolean(value, defaultValue) {
+  if (value == null) return defaultValue;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return defaultValue;
+}
+function parseNumber(value, defaultValue) {
+  if (value == null) return defaultValue;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultValue;
+}
+function loadMcpConfig() {
+  var _a;
+  const apiToken = (_a = process.env.JIMENG_API_TOKEN) == null ? void 0 : _a.trim();
+  return {
+    apiToken: apiToken || void 0,
+    httpTimeoutMs: parseNumber(process.env.MCP_HTTP_TIMEOUT_MS, 12e4),
+    enableAdvancedTools: parseBoolean(process.env.MCP_ENABLE_ADVANCED_TOOLS, true),
+    requireRunConfirm: parseBoolean(process.env.MCP_REQUIRE_RUN_CONFIRM, true)
+  };
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/mcp/client.ts
+import fs from "fs";
+import path from "path";
+function resolveTaskType(value) {
+  return value === "video" ? "video" : "image";
+}
+var JimengApiClient = class {
+  defaultToken;
+  tokenPoolReady = false;
+  constructor(config) {
+    this.defaultToken = config.apiToken;
+  }
+  resolveToken(options) {
+    return (options == null ? void 0 : options.token) || this.defaultToken;
+  }
+  async ensureTokenPoolReady() {
+    if (this.tokenPoolReady) return;
+    await session_pool_default.init();
+    this.tokenPoolReady = true;
+  }
+  async pickModelToken(requestedModel, taskType, options, requiredCapabilityTags = []) {
+    await this.ensureTokenPoolReady();
+    const token = this.resolveToken(options);
+    const tokenPick = session_pool_default.pickTokenForRequest({
+      authorization: token ? `Bearer ${token}` : void 0,
+      requestedModel,
+      taskType,
+      requiredCapabilityTags
+    });
+    if (!tokenPick.token || !tokenPick.region) {
+      throw new Error(tokenPick.reason || "Missing available token for model request");
+    }
+    return {
+      token: tokenPick.token,
+      regionInfo: buildRegionInfo(tokenPick.region)
+    };
+  }
+  async pickTaskToken(options, type = "image") {
+    await this.ensureTokenPoolReady();
+    const token = this.resolveToken(options);
+    if (token) {
+      const entry = session_pool_default.getTokenEntry(token);
+      if (!(entry == null ? void 0 : entry.region)) {
+        throw new Error("Missing region for token. Register token with region in token-pool.");
+      }
+      return { token, regionInfo: buildRegionInfo(entry.region) };
+    }
+    const candidates = session_pool_default.getEntries(false).filter((item) => item.enabled && item.live !== false && item.region).filter((item) => {
+      var _a;
+      const modelHint = type === "video" ? "video" : "jimeng";
+      return !((_a = item.allowedModels) == null ? void 0 : _a.length) || item.allowedModels.some((m) => m.includes(modelHint));
+    });
+    if (candidates.length === 0) {
+      throw new Error("No token available for task request. Configure token-pool or pass token.");
+    }
+    return { token: candidates[0].token, regionInfo: buildRegionInfo(candidates[0].region) };
+  }
+  async healthCheck() {
+    return "pong";
+  }
+  async listModels(options) {
+    var _a;
+    await this.ensureTokenPoolReady();
+    const token = this.resolveToken(options);
+    const authorization = token ? `Bearer ${token}` : void 0;
+    const region = token ? (_a = session_pool_default.getTokenEntry(token)) == null ? void 0 : _a.region : void 0;
+    const result = await getLiveModels(authorization, region);
+    return {
+      source: result.source,
+      data: result.data
+    };
+  }
+  async generateImage(body, options) {
+    const model = typeof body.model === "string" && body.model.trim().length > 0 ? body.model : DEFAULT_IMAGE_MODEL;
+    const prompt = String(body.prompt || "");
+    const tokenCtx = await this.pickModelToken(model, "image", options);
+    const responseFormat = body.response_format === "b64_json" ? "b64_json" : "url";
+    const imageResult = await generateImages(
+      model,
+      prompt,
+      {
+        ratio: body.ratio,
+        resolution: body.resolution,
+        sampleStrength: body.sample_strength,
+        negativePrompt: body.negative_prompt,
+        intelligentRatio: body.intelligent_ratio,
+        wait: body.wait,
+        waitTimeoutSeconds: body.wait_timeout_seconds,
+        pollIntervalMs: body.poll_interval_ms
+      },
+      tokenCtx.token,
+      tokenCtx.regionInfo
+    );
+    if (!Array.isArray(imageResult)) {
+      return imageResult;
+    }
+    const data = responseFormat === "b64_json" ? (await Promise.all(imageResult.map((url) => util_default.fetchFileBASE64(url)))).map((b64) => ({ b64_json: b64 })) : imageResult.map((url) => ({ url }));
+    return {
+      created: util_default.unixTimestamp(),
+      data
+    };
+  }
+  async editImage(body, options) {
+    const model = typeof body.model === "string" && body.model.trim().length > 0 ? body.model : DEFAULT_IMAGE_MODEL;
+    const prompt = String(body.prompt || "");
+    const images = Array.isArray(body.images) ? body.images.filter((item) => typeof item === "string") : [];
+    const tokenCtx = await this.pickModelToken(model, "image", options);
+    const responseFormat = body.response_format === "b64_json" ? "b64_json" : "url";
+    const compositionResult = await generateImageComposition(
+      model,
+      prompt,
+      images,
+      {
+        ratio: body.ratio,
+        resolution: body.resolution,
+        sampleStrength: body.sample_strength,
+        negativePrompt: body.negative_prompt,
+        intelligentRatio: body.intelligent_ratio,
+        wait: body.wait,
+        waitTimeoutSeconds: body.wait_timeout_seconds,
+        pollIntervalMs: body.poll_interval_ms
+      },
+      tokenCtx.token,
+      tokenCtx.regionInfo
+    );
+    if (!Array.isArray(compositionResult)) {
+      return compositionResult;
+    }
+    const data = responseFormat === "b64_json" ? (await Promise.all(compositionResult.map((url) => util_default.fetchFileBASE64(url)))).map((b64) => ({ b64_json: b64 })) : compositionResult.map((url) => ({ url }));
+    return {
+      created: util_default.unixTimestamp(),
+      data,
+      input_images: images.length,
+      composition_type: "multi_image_synthesis"
+    };
+  }
+  async generateVideo(body, options) {
+    const model = typeof body.model === "string" && body.model.trim().length > 0 ? body.model : DEFAULT_MODEL;
+    const prompt = String(body.prompt || "");
+    const functionMode = typeof body.functionMode === "string" ? body.functionMode : "first_last_frames";
+    const requiredTags = functionMode === "omni_reference" ? ["omni_reference"] : [];
+    const tokenCtx = await this.pickModelToken(model, "video", options, requiredTags);
+    const videoResult = await generateVideo(
+      model,
+      prompt,
+      {
+        ratio: body.ratio,
+        resolution: body.resolution,
+        duration: body.duration,
+        filePaths: body.filePaths || body.file_paths,
+        files: body.files,
+        httpRequest: { body },
+        functionMode,
+        wait: body.wait,
+        waitTimeoutSeconds: body.wait_timeout_seconds,
+        pollIntervalMs: body.poll_interval_ms
+      },
+      tokenCtx.token,
+      tokenCtx.regionInfo
+    );
+    if (typeof videoResult !== "string") {
+      return videoResult;
+    }
+    if (body.response_format === "b64_json") {
+      const videoBase64 = await util_default.fetchFileBASE64(videoResult);
+      return {
+        created: util_default.unixTimestamp(),
+        data: [{ b64_json: videoBase64, revised_prompt: prompt }]
+      };
+    }
+    return {
+      created: util_default.unixTimestamp(),
+      data: [{ url: videoResult, revised_prompt: prompt }]
+    };
+  }
+  async getTask(taskId, options, query) {
+    const type = (query == null ? void 0 : query.type) === "video" ? "video" : (query == null ? void 0 : query.type) === "image" ? "image" : void 0;
+    const tokenCtx = await this.pickTaskToken(options, resolveTaskType(type));
+    return getTaskResponse(taskId, tokenCtx.token, tokenCtx.regionInfo, {
+      type,
+      responseFormat: (query == null ? void 0 : query.response_format) === "b64_json" ? "b64_json" : "url"
+    });
+  }
+  async waitTask(taskId, body, options) {
+    const type = body.type === "video" ? "video" : body.type === "image" ? "image" : void 0;
+    const tokenCtx = await this.pickTaskToken(options, resolveTaskType(type));
+    return waitForTaskResponse(taskId, tokenCtx.token, tokenCtx.regionInfo, {
+      type,
+      responseFormat: body.response_format === "b64_json" ? "b64_json" : "url",
+      waitTimeoutSeconds: body.wait_timeout_seconds,
+      pollIntervalMs: body.poll_interval_ms
+    });
+  }
+  async generateVideoOmni(body, options, uploadFiles = []) {
+    const files = {};
+    for (const file of uploadFiles) {
+      files[file.fieldName] = {
+        filepath: file.filePath,
+        originalFilename: path.basename(file.filePath)
+      };
+      if (!fs.existsSync(file.filePath)) {
+        throw new Error(`Local file not found: ${file.filePath}`);
+      }
+    }
+    return this.generateVideo(
+      {
+        ...body,
+        functionMode: "omni_reference",
+        files
+      },
+      options
+    );
+  }
+};
+
+// src/mcp/errors.ts
+import axios from "axios";
+var McpToolError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+};
+function normalizeToolError(error) {
+  var _a, _b, _c;
+  if (error instanceof McpToolError) return error;
+  if (axios.isAxiosError(error)) {
+    if (!error.response) {
+      return new McpToolError(
+        "NETWORK_ERROR",
+        "Failed to reach jimeng-cli service",
+        error.message
+      );
+    }
+    const status = error.response.status;
+    const message = String(((_b = (_a = error.response.data) == null ? void 0 : _a.error) == null ? void 0 : _b.message) || ((_c = error.response.data) == null ? void 0 : _c.message) || error.message);
+    if (status === 401 || status === 403) {
+      return new McpToolError("AUTH_ERROR", message, error.response.data);
+    }
+    if (status >= 400 && status < 500) {
+      return new McpToolError("VALIDATION_ERROR", message, error.response.data);
+    }
+    if (status >= 500) {
+      return new McpToolError("UPSTREAM_ERROR", message, error.response.data);
+    }
+  }
+  if (error instanceof Error) {
+    return new McpToolError("INTERNAL_ERROR", error.message);
+  }
+  return new McpToolError("INTERNAL_ERROR", "Unknown internal error");
+}
+function formatToolError(error) {
+  const normalized = normalizeToolError(error);
+  return `[${normalized.code}] ${normalized.message}`;
+}
+
+// src/mcp/guards.ts
+function assertRunConfirm(config, confirm) {
+  if (!config.requireRunConfirm) return;
+  if (confirm === "RUN") return;
+  throw new McpToolError(
+    "VALIDATION_ERROR",
+    'This tool requires explicit confirmation: set "confirm" to "RUN".'
+  );
+}
+
+// src/mcp/schemas.ts
+import * as z from "zod";
+function buildIndexedUrlFields(prefix, max) {
+  return Object.fromEntries(
+    Array.from({ length: max }, (_, index) => [
+      `${prefix}_${index + 1}`,
+      z.string().url().optional()
+    ])
+  );
+}
+function normalizeUniqueValues(values) {
+  return [...new Set(values.map((item) => item.trim()).filter(Boolean))];
+}
+var healthCheckInputSchema = z.object({});
+var listModelsInputSchema = z.object({
+  token: z.string().optional()
+});
+var generateImageInputSchema = z.object({
+  prompt: z.string().min(1),
+  model: z.string().optional(),
+  negative_prompt: z.string().optional(),
+  ratio: z.string().optional(),
+  resolution: z.string().optional(),
+  intelligent_ratio: z.boolean().optional(),
+  sample_strength: z.number().optional(),
+  response_format: z.enum(["url", "b64_json"]).optional(),
+  wait: z.boolean().optional(),
+  wait_timeout_seconds: z.number().int().positive().optional(),
+  poll_interval_ms: z.number().int().positive().optional(),
+  token: z.string().optional(),
+  confirm: z.string().optional()
+});
+var editImageInputSchema = z.object({
+  prompt: z.string().min(1),
+  images: z.array(z.string().url()).min(1).max(10),
+  model: z.string().optional(),
+  negative_prompt: z.string().optional(),
+  ratio: z.string().optional(),
+  resolution: z.string().optional(),
+  intelligent_ratio: z.boolean().optional(),
+  sample_strength: z.number().optional(),
+  response_format: z.enum(["url", "b64_json"]).optional(),
+  wait: z.boolean().optional(),
+  wait_timeout_seconds: z.number().int().positive().optional(),
+  poll_interval_ms: z.number().int().positive().optional(),
+  token: z.string().optional(),
+  confirm: z.string().optional()
+});
+var generateVideoInputSchema = z.object({
+  prompt: z.string().min(1),
+  model: z.string().optional(),
+  ratio: z.string().optional(),
+  resolution: z.string().optional(),
+  duration: z.number().int().min(4).max(15).optional(),
+  wait: z.boolean().optional(),
+  wait_timeout_seconds: z.number().int().positive().optional(),
+  poll_interval_ms: z.number().int().positive().optional(),
+  token: z.string().optional(),
+  confirm: z.string().optional()
+});
+var generateVideoOmniInputSchema = z.object({
+  prompt: z.string().min(1),
+  model: z.string().optional(),
+  ratio: z.string().optional(),
+  resolution: z.string().optional(),
+  duration: z.number().int().min(4).max(15).optional(),
+  response_format: z.enum(["url", "b64_json"]).optional(),
+  wait: z.boolean().optional(),
+  wait_timeout_seconds: z.number().int().positive().optional(),
+  poll_interval_ms: z.number().int().positive().optional(),
+  file_paths: z.array(z.string().url()).max(9).optional(),
+  filePaths: z.array(z.string().url()).max(9).optional(),
+  image_urls: z.array(z.string().url()).max(9).optional(),
+  video_urls: z.array(z.string().url()).max(3).optional(),
+  image_files: z.array(z.string()).max(9).optional(),
+  video_files: z.array(z.string()).max(3).optional(),
+  ...buildIndexedUrlFields("image_file", 9),
+  ...buildIndexedUrlFields("video_file", 3),
+  token: z.string().optional(),
+  confirm: z.string().optional()
+}).superRefine((value, ctx) => {
+  var _a, _b;
+  const imageSlotUrls = Array.from({ length: 9 }, (_, index) => value[`image_file_${index + 1}`]);
+  const videoSlotUrls = Array.from({ length: 3 }, (_, index) => value[`video_file_${index + 1}`]);
+  const imageCount = normalizeUniqueValues(value.image_urls || []).length + (((_a = value.image_files) == null ? void 0 : _a.length) || 0) + normalizeUniqueValues([...value.file_paths || [], ...value.filePaths || []]).length + normalizeUniqueValues(imageSlotUrls.filter((item) => typeof item === "string")).length;
+  const videoCount = normalizeUniqueValues(value.video_urls || []).length + (((_b = value.video_files) == null ? void 0 : _b.length) || 0) + normalizeUniqueValues(videoSlotUrls.filter((item) => typeof item === "string")).length;
+  if (imageCount > 9) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Omni mode supports at most 9 images."
+    });
+  }
+  if (videoCount > 3) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Omni mode supports at most 3 videos."
+    });
+  }
+  if (imageCount + videoCount > 12) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Omni mode supports at most 12 total materials."
+    });
+  }
+  if (imageCount + videoCount === 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Omni mode requires at least one material."
+    });
+  }
+});
+var getTaskInputSchema = z.object({
+  task_id: z.string().min(1),
+  type: z.enum(["image", "video"]).optional(),
+  response_format: z.enum(["url", "b64_json"]).optional(),
+  token: z.string().optional()
+});
+var waitTaskInputSchema = z.object({
+  task_id: z.string().min(1),
+  type: z.enum(["image", "video"]).optional(),
+  response_format: z.enum(["url", "b64_json"]).optional(),
+  wait_timeout_seconds: z.number().int().positive().optional(),
+  poll_interval_ms: z.number().int().positive().optional(),
+  token: z.string().optional()
+});
+
+// src/mcp/result.ts
+function toStructuredContent(data) {
+  if (data != null && typeof data === "object" && !Array.isArray(data)) {
+    return data;
+  }
+  return { data };
+}
+function toToolResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: toStructuredContent(data)
+  };
+}
+async function withToolError(fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw new Error(formatToolError(error));
+  }
+}
+
+// src/mcp/tool-factory.ts
+function registerSafeTool(server, name, options, handler) {
+  const { title, description, inputSchema, annotations } = options;
+  server.registerTool(
+    name,
+    {
+      title,
+      description,
+      inputSchema,
+      ...annotations ? { annotations } : {}
+    },
+    (async (args) => withToolError(async () => {
+      const parsedArgs = inputSchema.parse(args);
+      const result = await handler(parsedArgs);
+      return toToolResult(result);
+    }))
+  );
+}
+
+// src/mcp/tools/edit-image.ts
+function registerEditImageTool({ server, config, client }) {
+  registerSafeTool(
+    server,
+    "edit_image",
+    {
+      title: "Edit Image",
+      description: "Compose image from prompt and image URLs",
+      inputSchema: editImageInputSchema
+    },
+    async (args) => {
+      assertRunConfirm(config, args.confirm);
+      return client.editImage(
+        {
+          prompt: args.prompt,
+          images: args.images,
+          model: args.model,
+          negative_prompt: args.negative_prompt,
+          ratio: args.ratio,
+          resolution: args.resolution || "1k",
+          intelligent_ratio: args.intelligent_ratio,
+          sample_strength: args.sample_strength,
+          response_format: args.response_format,
+          wait: args.wait,
+          wait_timeout_seconds: args.wait_timeout_seconds,
+          poll_interval_ms: args.poll_interval_ms
+        },
+        { token: args.token }
+      );
+    }
+  );
+}
+
+// src/mcp/tools/generate-image.ts
+function registerGenerateImageTool({ server, config, client }) {
+  registerSafeTool(
+    server,
+    "generate_image",
+    {
+      title: "Generate Image",
+      description: "Generate image from prompt",
+      inputSchema: generateImageInputSchema
+    },
+    async (args) => {
+      assertRunConfirm(config, args.confirm);
+      return client.generateImage(
+        {
+          prompt: args.prompt,
+          model: args.model,
+          negative_prompt: args.negative_prompt,
+          ratio: args.ratio,
+          resolution: args.resolution || "1k",
+          intelligent_ratio: args.intelligent_ratio,
+          sample_strength: args.sample_strength,
+          response_format: args.response_format,
+          wait: args.wait,
+          wait_timeout_seconds: args.wait_timeout_seconds,
+          poll_interval_ms: args.poll_interval_ms
+        },
+        { token: args.token }
+      );
+    }
+  );
+}
+
+// src/mcp/tools/video-utils.ts
+import fs2 from "fs";
+var MAX_IMAGE_SLOTS = 9;
+var MAX_VIDEO_SLOTS = 3;
+function buildBaseVideoPayload(args, functionMode) {
+  return {
+    prompt: args.prompt,
+    model: args.model,
+    ratio: args.ratio,
+    resolution: args.resolution,
+    duration: args.duration ?? 5,
+    response_format: args.response_format,
+    wait: args.wait,
+    wait_timeout_seconds: args.wait_timeout_seconds,
+    poll_interval_ms: args.poll_interval_ms,
+    functionMode
+  };
+}
+function uniqueStrings(values) {
+  return [...new Set(values.map((item) => item.trim()).filter(Boolean))];
+}
+function collectStringArray(values) {
+  if (!Array.isArray(values)) return [];
+  return values.filter((item) => typeof item === "string");
+}
+function collectIndexedSlotUrls(args, prefix, max) {
+  const values = /* @__PURE__ */ new Map();
+  for (let i = 1; i <= max; i++) {
+    const key = `${prefix}_${i}`;
+    const slot = args[key];
+    if (typeof slot === "string" && slot.length > 0) {
+      values.set(i, slot);
+    }
+  }
+  return values;
+}
+function assertLocalFilesExist(paths) {
+  for (const filePath of paths) {
+    if (!fs2.existsSync(filePath)) {
+      throw new McpToolError("VALIDATION_ERROR", `Local file not found: ${filePath}`);
+    }
+  }
+}
+function takeNextAvailableSlot(occupiedSlots, maxSlots, materialLabel) {
+  for (let i = 1; i <= maxSlots; i++) {
+    if (!occupiedSlots.has(i)) {
+      occupiedSlots.add(i);
+      return i;
+    }
+  }
+  throw new McpToolError(
+    "VALIDATION_ERROR",
+    `No available ${materialLabel} slot. Maximum supported: ${maxSlots}.`
+  );
+}
+function appendUrlMaterials(body, occupiedSlots, urls, prefix, maxSlots, materialLabel) {
+  for (const url of urls) {
+    const slot = takeNextAvailableSlot(occupiedSlots, maxSlots, materialLabel);
+    body[`${prefix}_${slot}`] = url;
+  }
+}
+function appendFileMaterials(uploadFiles, occupiedSlots, filePaths, prefix, maxSlots, materialLabel) {
+  for (const filePath of filePaths) {
+    const slot = takeNextAvailableSlot(occupiedSlots, maxSlots, materialLabel);
+    uploadFiles.push({
+      fieldName: `${prefix}_${slot}`,
+      filePath
+    });
+  }
+}
+
+// src/mcp/tools/generate-video-omni.ts
+function normalizeOmniPayload(args) {
+  const imageSlotUrls = collectIndexedSlotUrls(args, "image_file", MAX_IMAGE_SLOTS);
+  const videoSlotUrls = collectIndexedSlotUrls(args, "video_file", MAX_VIDEO_SLOTS);
+  const imageUrls = uniqueStrings([
+    ...collectStringArray(args.image_urls),
+    ...collectStringArray(args.file_paths),
+    ...collectStringArray(args.filePaths)
+  ]);
+  const videoUrls = uniqueStrings(collectStringArray(args.video_urls));
+  const imageFiles = uniqueStrings(collectStringArray(args.image_files));
+  const videoFiles = uniqueStrings(collectStringArray(args.video_files));
+  assertLocalFilesExist(imageFiles);
+  assertLocalFilesExist(videoFiles);
+  const body = buildBaseVideoPayload(args, "omni_reference");
+  for (const [slot, url] of imageSlotUrls) {
+    body[`image_file_${slot}`] = url;
+  }
+  for (const [slot, url] of videoSlotUrls) {
+    body[`video_file_${slot}`] = url;
+  }
+  const occupiedImageSlots = new Set(imageSlotUrls.keys());
+  const occupiedVideoSlots = new Set(videoSlotUrls.keys());
+  appendUrlMaterials(body, occupiedImageSlots, imageUrls, "image_file", MAX_IMAGE_SLOTS, "image");
+  appendUrlMaterials(body, occupiedVideoSlots, videoUrls, "video_file", MAX_VIDEO_SLOTS, "video");
+  const uploadFiles = [];
+  appendFileMaterials(
+    uploadFiles,
+    occupiedImageSlots,
+    imageFiles,
+    "image_file",
+    MAX_IMAGE_SLOTS,
+    "image"
+  );
+  appendFileMaterials(
+    uploadFiles,
+    occupiedVideoSlots,
+    videoFiles,
+    "video_file",
+    MAX_VIDEO_SLOTS,
+    "video"
+  );
+  return { body, uploadFiles };
+}
+function registerGenerateVideoOmniTool({ server, config, client }) {
+  registerSafeTool(
+    server,
+    "generate_video_omni",
+    {
+      title: "Generate Video Omni",
+      description: "Generate omni_reference video with URL and local-file materials",
+      inputSchema: generateVideoOmniInputSchema
+    },
+    async (args) => {
+      assertRunConfirm(config, args.confirm);
+      const { body, uploadFiles } = normalizeOmniPayload(args);
+      return client.generateVideoOmni(body, { token: args.token }, uploadFiles);
+    }
+  );
+}
+
+// src/mcp/tools/generate-video.ts
+function registerGenerateVideoTool({ server, config, client }) {
+  registerSafeTool(
+    server,
+    "generate_video_flf",
+    {
+      title: "Generate Video FLF",
+      description: "Generate video for first_last_frames workflow only",
+      inputSchema: generateVideoInputSchema
+    },
+    async (args) => {
+      assertRunConfirm(config, args.confirm);
+      return client.generateVideo(
+        buildBaseVideoPayload(args, "first_last_frames"),
+        { token: args.token }
+      );
+    }
+  );
+}
+
+// src/mcp/tools/get-task.ts
+function registerGetTaskTool({ server, client }) {
+  registerSafeTool(
+    server,
+    "get_task",
+    {
+      title: "Get Task",
+      description: "Get image/video task status by task_id",
+      inputSchema: getTaskInputSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => client.getTask(
+      args.task_id,
+      { token: args.token },
+      {
+        type: args.type,
+        response_format: args.response_format
+      }
+    )
+  );
+}
+
+// src/mcp/tools/health-check.ts
+function registerHealthCheckTool({ server, client }) {
+  registerSafeTool(
+    server,
+    "health_check",
+    {
+      title: "Health Check",
+      description: "Check jimeng-cli health endpoint",
+      inputSchema: healthCheckInputSchema
+    },
+    async () => {
+      const startedAt = Date.now();
+      const raw = await client.healthCheck();
+      return {
+        ok: true,
+        latencyMs: Date.now() - startedAt,
+        raw
+      };
+    }
+  );
+}
+
+// src/mcp/tools/list-models.ts
+function registerListModelsTool({ server, client }) {
+  registerSafeTool(
+    server,
+    "list_models",
+    {
+      title: "List Models",
+      description: "Get available models from jimeng-cli",
+      inputSchema: listModelsInputSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async ({ token }) => client.listModels({ token })
+  );
+}
+
+// src/mcp/tools/wait-task.ts
+function registerWaitTaskTool({ server, client }) {
+  registerSafeTool(
+    server,
+    "wait_task",
+    {
+      title: "Wait Task",
+      description: "Wait for image/video task completion by task_id",
+      inputSchema: waitTaskInputSchema
+    },
+    async (args) => client.waitTask(
+      args.task_id,
+      {
+        type: args.type,
+        response_format: args.response_format,
+        wait_timeout_seconds: args.wait_timeout_seconds,
+        poll_interval_ms: args.poll_interval_ms
+      },
+      { token: args.token }
+    )
+  );
+}
+
+// src/mcp/tools/manifest.ts
+var MCP_TOOL_MANIFEST = [
+  { id: "health_check", register: registerHealthCheckTool },
+  { id: "list_models", register: registerListModelsTool },
+  { id: "get_task", register: registerGetTaskTool },
+  { id: "wait_task", register: registerWaitTaskTool },
+  { id: "generate_image", register: registerGenerateImageTool },
+  { id: "edit_image", isAdvanced: true, register: registerEditImageTool },
+  { id: "generate_video_flf", isAdvanced: true, register: registerGenerateVideoTool },
+  { id: "generate_video_omni", isAdvanced: true, register: registerGenerateVideoOmniTool }
+];
+
+// src/mcp/tools/index.ts
+function registerMcpTools(deps) {
+  for (const item of MCP_TOOL_MANIFEST) {
+    if (item.isAdvanced && !deps.config.enableAdvancedTools) continue;
+    item.register(deps);
+  }
+}
+
+// src/mcp/server.ts
+function createJimengMcpServer(config) {
+  const server = new McpServer({
+    name: "jimeng-cli-mcp",
+    version: environment_default.package.version || "1.0.0"
+  });
+  const client = new JimengApiClient(config);
+  registerMcpTools({ server, config, client });
+  return server;
+}
+
+// src/mcp/index.ts
+async function main() {
+  const config = loadMcpConfig();
+  const server = createJimengMcpServer(config);
+  const transport = new StdioServerTransport();
+  process.on("SIGINT", async () => {
+    await server.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await server.close();
+    process.exit(0);
+  });
+  await server.connect(transport);
+  console.error("[jimeng-cli-mcp] Server started on stdio transport");
+}
+main().catch((error) => {
+  console.error("[jimeng-cli-mcp] Failed to start MCP server:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map