@unityclaw/sdk 1.0.6 → 1.0.8

package/dist/index.cjs

@@ -33,12 +33,27 @@ __export(index_exports, {
   CONFIG_DIR: () => CONFIG_DIR,
   CONFIG_FILE: () => CONFIG_FILE,
   DEFAULT_TASKS_DIR: () => DEFAULT_TASKS_DIR,
+  DOC_CONVERT_INPUT_FORMATS: () => DOC_CONVERT_INPUT_FORMATS,
+  DOC_CONVERT_OUTPUT_FORMATS: () => DOC_CONVERT_OUTPUT_FORMATS,
+  DOC_TRANSLATE_LANGUAGE_CODES: () => DOC_TRANSLATE_LANGUAGE_CODES,
   DocumentAPI: () => DocumentAPI,
+  GEMINI_IMAGE_ASPECT_RATIOS: () => GEMINI_IMAGE_ASPECT_RATIOS,
+  GEMINI_IMAGE_SIZES: () => GEMINI_IMAGE_SIZES,
+  IDPAPI: () => IDPAPI,
+  IDP_TYPES: () => IDP_TYPES,
   ImageAPI: () => ImageAPI,
+  JIMENG_IMAGE_MODELS: () => JIMENG_IMAGE_MODELS,
+  JIMENG_IMAGE_SIZES: () => JIMENG_IMAGE_SIZES,
+  JIMENG_IMAGE_WEB_SEARCH_OPTIONS: () => JIMENG_IMAGE_WEB_SEARCH_OPTIONS,
+  KLING_ASPECT_RATIOS: () => KLING_ASPECT_RATIOS,
+  KLING_DURATIONS: () => KLING_DURATIONS,
+  KLING_MODELS: () => KLING_MODELS,
   MediaAPI: () => MediaAPI,
   TaskFolderManager: () => TaskFolderManager,
   UnityClawClient: () => UnityClawClient,
   VideoAPI: () => VideoAPI,
+  WAN_DEFAULT_MODELS: () => WAN_DEFAULT_MODELS,
+  WAN_SHOT_TYPES: () => WAN_SHOT_TYPES,
   getConfigPath: () => getConfigPath,
   getConfigValue: () => getConfigValue,
   loadConfig: () => loadConfig,
@@ -49,6 +64,8 @@ module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
 var import_axios2 = __toESM(require("axios"), 1);
+var import_path3 = require("path");
+var import_promises2 = require("fs/promises");
 
 // src/task-folder.ts
 var import_promises = require("fs/promises");
@@ -309,7 +326,72 @@ function getConfigValue(key) {
   return value ? String(value) : void 0;
 }
 
+// src/apis/normalize.ts
+function toTextFieldItems(input) {
+  if (input == null) return void 0;
+  if (typeof input === "string") {
+    return [{ type: "text", text: input }];
+  }
+  return input;
+}
+function toLabelFieldItem(input) {
+  if (input == null) return void 0;
+  if (typeof input === "object" && "value" in input && "label" in input) {
+    return input;
+  }
+  return {
+    value: input,
+    label: String(input)
+  };
+}
+
 // src/apis/image.ts
+var JIMENG_3K_SIZES = /* @__PURE__ */ new Set([
+  "3072x3072",
+  "2592x3456",
+  "3456x2592",
+  "4096x2304",
+  "2304x4096",
+  "3744x2496",
+  "2496x3744",
+  "4704x2016"
+]);
+var JIMENG_4K_SIZES = /* @__PURE__ */ new Set([
+  "4096x4096",
+  "3520x4704",
+  "4704x3520",
+  "5504x3040",
+  "3040x5504",
+  "4992x3328",
+  "3328x4992",
+  "6240x2656"
+]);
+function getSelectRawValue(input) {
+  if (input == null) return "";
+  if (typeof input === "object" && "value" in input) {
+    return String(input.value ?? "");
+  }
+  return String(input);
+}
+function validateJimengImageParams(params) {
+  const sizeValue = getSelectRawValue(params.size);
+  const modelValue = getSelectRawValue(params.model_selector) || params.model || "doubao-seedream-5-0-260128";
+  const webSearchValue = getSelectRawValue(params.web_search);
+  if (!sizeValue || !sizeValue.includes("x")) {
+    throw new Error(
+      `Invalid jimeng size "${sizeValue}". /api/jimeng/image expects 2K/3K/4K size values like "2048x2048", "3072x3072", "4096x4096".`
+    );
+  }
+  if (modelValue === "doubao-seedream-5-0-260128" && JIMENG_4K_SIZES.has(sizeValue)) {
+    throw new Error('Invalid jimeng params: model "doubao-seedream-5-0-260128" does not support 4K sizes.');
+  }
+  if (modelValue === "doubao-seedream-4-5-251128" && JIMENG_3K_SIZES.has(sizeValue)) {
+    throw new Error('Invalid jimeng params: model "doubao-seedream-4-5-251128" does not support 3K sizes.');
+  }
+  if (webSearchValue === "true" && modelValue === "doubao-seedream-4-5-251128") {
+    throw new Error('Invalid jimeng params: web_search=true is only supported by model "doubao-seedream-5-0-260128".');
+  }
+}
 var ImageAPI = class {
   constructor(client) {
     this.client = client;
@@ -364,12 +446,13 @@ var ImageAPI = class {
    * ```
    */
   async jimeng(params) {
+    validateJimengImageParams(params);
     return this.client.request("/api/jimeng/image", {
-      prompt: params.prompt,
+      prompt: toTextFieldItems(params.prompt),
       attachment: params.attachment,
-      size: params.size,
-      model_selector: params.model_selector,
-      web_search: params.web_search,
+      size: toLabelFieldItem(params.size),
+      model_selector: toLabelFieldItem(params.model_selector),
+      web_search: toLabelFieldItem(params.web_search),
       image_count: params.image_count,
       model: params.model
     });
@@ -380,11 +463,11 @@ var ImageAPI = class {
    */
   async jimengV3(params) {
     return this.client.request("/api/jimeng/image/v3", {
-      prompt: params.prompt,
+      prompt: toTextFieldItems(params.prompt),
       attachment: params.attachment,
-      size: params.size,
-      model_selector: params.model_selector,
-      web_search: params.web_search,
+      size: toLabelFieldItem(params.size),
+      model_selector: toLabelFieldItem(params.model_selector),
+      web_search: toLabelFieldItem(params.web_search),
       image_count: params.image_count,
       model: params.model
     });
@@ -402,6 +485,17 @@ var ImageAPI = class {
 };
 
 // src/apis/video.ts
+function toNumericDurationLabelFieldItem(input) {
+  const item = toLabelFieldItem(input);
+  if (!item) return void 0;
+  if (typeof item.value === "string" && /^-?\d+(\.\d+)?$/.test(item.value)) {
+    return {
+      value: Number(item.value),
+      label: item.label
+    };
+  }
+  return item;
+}
 var VideoAPI = class {
   constructor(client) {
     this.client = client;
@@ -422,8 +516,8 @@ var VideoAPI = class {
   async sora(params) {
     return this.client.request("/api/sora/video", {
       attachment: params.attachment,
-      prompt: params.prompt,
-      orientation: params.orientation
+      prompt: toTextFieldItems(params.prompt),
+      orientation: toLabelFieldItem(params.orientation)
     });
   }
   /**
@@ -433,9 +527,9 @@ var VideoAPI = class {
   async soraStable(params) {
     return this.client.request("/api/sora/video/stable", {
       attachment: params.attachment,
-      prompt: params.prompt,
-      size: params.size,
-      seconds: params.seconds
+      prompt: toTextFieldItems(params.prompt),
+      size: toLabelFieldItem(params.size),
+      seconds: toLabelFieldItem(params.seconds)
     });
   }
   /**
@@ -453,13 +547,13 @@ var VideoAPI = class {
    */
   async veo(params) {
     return this.client.request("/api/veo/video", {
-      prompt: params.prompt,
+      prompt: toTextFieldItems(params.prompt),
       attachment: params.attachment,
       first_frame: params.first_frame,
       last_frame: params.last_frame,
-      aspect_ratio: params.aspect_ratio,
-      resolution: params.resolution,
-      duration: params.duration
+      aspect_ratio: toLabelFieldItem(params.aspect_ratio),
+      resolution: toLabelFieldItem(params.resolution),
+      duration: toLabelFieldItem(params.duration)
     });
   }
   /**
@@ -479,10 +573,10 @@ var VideoAPI = class {
   async kling(params) {
     return this.client.request("/api/kling/video", {
       attachment: params.attachment,
-      prompt: params.prompt,
-      aspect_ratio: params.aspect_ratio,
-      duration: params.duration,
-      model: params.model
+      prompt: toTextFieldItems(params.prompt),
+      aspect_ratio: toLabelFieldItem(params.aspect_ratio),
+      duration: toLabelFieldItem(params.duration),
+      model: toLabelFieldItem(params.model)
     });
   }
   /**
@@ -500,10 +594,10 @@ var VideoAPI = class {
    */
   async jimeng(params) {
     return this.client.request("/api/jimeng/video", {
-      action: params.action,
+      action: toLabelFieldItem(params.action),
       attachment: params.attachment,
-      prompt: params.prompt,
-      aspect_ratio: params.aspect_ratio
+      prompt: toTextFieldItems(params.prompt),
+      aspect_ratio: toLabelFieldItem(params.aspect_ratio)
     });
   }
   /**
@@ -521,12 +615,12 @@ var VideoAPI = class {
    */
   async doubao(params) {
     return this.client.request("/api/doubao/video", {
-      action: params.action,
+      action: toLabelFieldItem(params.action),
       attachment: params.attachment,
-      prompt: params.prompt,
-      resolution: params.resolution,
-      ratio: params.ratio,
-      duration: params.duration
+      prompt: toTextFieldItems(params.prompt),
+      resolution: toLabelFieldItem(params.resolution),
+      ratio: toLabelFieldItem(params.ratio),
+      duration: toNumericDurationLabelFieldItem(params.duration)
     });
   }
   /**
@@ -546,11 +640,11 @@ var VideoAPI = class {
   async wan(params) {
     return this.client.request("/api/wan/video", {
       attachment: params.attachment,
-      prompt: params.prompt,
-      size: params.size,
-      duration: params.duration,
-      model: params.model,
-      shot_type: params.shot_type
+      prompt: toTextFieldItems(params.prompt),
+      size: toLabelFieldItem(params.size),
+      duration: toLabelFieldItem(params.duration),
+      model: toLabelFieldItem(params.model),
+      shot_type: toLabelFieldItem(params.shot_type)
     });
   }
   /**
@@ -569,10 +663,10 @@ var VideoAPI = class {
   async minimax(params) {
     return this.client.request("/api/minimax/video", {
       attachment: params.attachment,
-      prompt: params.prompt,
-      size: params.size,
-      duration: params.duration,
-      model: params.model
+      prompt: toTextFieldItems(params.prompt),
+      size: toLabelFieldItem(params.size),
+      duration: toLabelFieldItem(params.duration),
+      model: toLabelFieldItem(params.model)
     });
   }
 };
@@ -604,114 +698,73 @@ var DocumentAPI = class {
     });
   }
   /**
-   * Convert image to Word document
-   * @see /api/doc_convert/image2word
+   * Generic document conversion (recommended entrypoint).
+   * Uses /api/doc_convert/image or /api/doc_convert/pdf based on input_format.
+   */
+  async convertDocument(params) {
+    const isPdfInput = String(
+      typeof params.input_format === "object" && params.input_format !== null && "value" in params.input_format ? params.input_format.value : params.input_format ?? ""
+    ).toLowerCase() === "pdf";
+    const endpoint = isPdfInput ? "/api/doc_convert/pdf" : "/api/doc_convert/image";
+    return this.client.request(endpoint, {
+      attachment: params.attachment,
+      input_format: params.input_format,
+      output_format: params.output_format
+    });
+  }
+  /**
+   * @deprecated Use convertDocument({ input_format: 'image', output_format: 'docx' })
    */
   async image2Word(params) {
-    return this.client.request(
-      "/api/doc_convert/image2word",
-      {
-        attachment: params.attachment
-      }
-    );
+    return this.convertDocument({ attachment: params.attachment, input_format: "image", output_format: "docx" });
   }
   /**
-   * Convert image to PowerPoint
-   * @see /api/doc_convert/image2ppt
+   * @deprecated Use convertDocument({ input_format: 'image', output_format: 'pptx' })
    */
   async image2Ppt(params) {
-    return this.client.request(
-      "/api/doc_convert/image2ppt",
-      {
-        attachment: params.attachment
-      }
-    );
+    return this.convertDocument({ attachment: params.attachment, input_format: "image", output_format: "pptx" });
   }
   /**
-   * Convert image to Excel
-   * @see /api/doc_convert/image2excel
+   * @deprecated Use convertDocument({ input_format: 'image', output_format: 'xlsx' })
    */
   async image2Excel(params) {
-    return this.client.request(
-      "/api/doc_convert/image2excel",
-      {
-        attachment: params.attachment
-      }
-    );
+    return this.convertDocument({ attachment: params.attachment, input_format: "image", output_format: "xlsx" });
   }
   /**
-   * Convert image to PDF
-   * @see /api/doc_convert/image2pdf
+   * @deprecated Use convertDocument({ input_format: 'image', output_format: 'pdf' })
    */
   async image2Pdf(params) {
-    return this.client.request(
-      "/api/doc_convert/image2pdf",
-      {
-        attachment: params.attachment
-      }
-    );
+    return this.convertDocument({ attachment: params.attachment, input_format: "image", output_format: "pdf" });
   }
   /**
-   * Convert PDF to Word document
-   * @see /api/doc_convert/pdf2word
+   * @deprecated Use convertDocument({ input_format: 'pdf', output_format: 'docx' })
    */
   async pdf2Word(params) {
-    return this.client.request(
-      "/api/doc_convert/pdf2word",
-      {
-        attachment: params.attachment
-      }
-    );
+    return this.convertDocument({ attachment: params.attachment, input_format: "pdf", output_format: "docx" });
   }
   /**
-   * Convert PDF to PowerPoint
-   * @see /api/doc_convert/pdf2ppt
+   * @deprecated Use convertDocument({ input_format: 'pdf', output_format: 'pptx' })
    */
   async pdf2Ppt(params) {
-    return this.client.request(
-      "/api/doc_convert/pdf2ppt",
-      {
-        attachment: params.attachment
-      }
-    );
+    return this.convertDocument({ attachment: params.attachment, input_format: "pdf", output_format: "pptx" });
   }
   /**
-   * Convert PDF to Excel
-   * @see /api/doc_convert/pdf2excel
+   * @deprecated Use convertDocument({ input_format: 'pdf', output_format: 'xlsx' })
    */
   async pdf2Excel(params) {
-    return this.client.request(
-      "/api/doc_convert/pdf2excel",
-      {
-        attachment: params.attachment
-      }
-    );
+    return this.convertDocument({ attachment: params.attachment, input_format: "pdf", output_format: "xlsx" });
   }
   /**
-   * Convert PDF to image
-   * @see /api/doc_convert/pdf2image
+   * @deprecated Use convertDocument({ input_format: 'pdf', output_format: 'image' })
    */
   async pdf2Image(params) {
-    return this.client.request(
-      "/api/doc_convert/pdf2image",
-      {
-        attachment: params.attachment
-      }
-    );
+    return this.convertDocument({ attachment: params.attachment, input_format: "pdf", output_format: "image" });
   }
   /**
-   * Generic document conversion
-   * @see /api/doc_convert/image
-   * @see /api/doc_convert/pdf
+   * Backward-compatible alias of convertDocument().
    */
   async convert(params) {
-    const isImage = params.input_format === "image" || !params.input_format;
-    const endpoint = isImage ? "/api/doc_convert/image" : "/api/doc_convert/pdf";
-    return this.client.request(endpoint, {
-      attachment: params.attachment,
-      input_format: params.input_format,
-      output_format: params.output_format
-    });
+    return this.convertDocument(params);
   }
 };
 
@@ -785,13 +838,124 @@ var MediaAPI = class {
       url: [{ link: params.url, type: "url" }]
     });
   }
+  /**
+   * Fetch media stats from social video links.
+   * @see /api/media_stats
+   */
+  async stats(params) {
+    return this.client.request("/api/media_stats", {
+      link: params.link
+    });
+  }
+  /**
+   * Fetch media user profile information from homepage links.
+   * @see /api/media_user_info
+   */
+  async userInfo(params) {
+    return this.client.request("/api/media_user_info", {
+      link: params.link
+    });
+  }
+  /**
+   * Download Xiaohongshu media links.
+   * @see /api/xiaohongshu/download
+   */
+  async downloadXiaohongshu(params) {
+    return this.client.request("/api/xiaohongshu/download", {
+      url: params.url
+    });
+  }
+  /**
+   * Extract one frame from video attachment.
+   * @see /api/video/frame
+   */
+  async extractFrame(params) {
+    return this.client.request("/api/video/frame", {
+      attachment: params.attachment,
+      frame_option: toLabelFieldItem(params.frame_option),
+      frame: params.frame
+    });
+  }
+};
+
+// src/apis/idp.ts
+var IDPAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Generic IDP extraction call.
+   * @see /api/idp/{type}
+   */
+  async extract(type, params) {
+    return this.client.request(`/api/idp/${type}`, {
+      attachments: params.attachments
+    });
+  }
+  async bankCard(params) {
+    return this.extract("bank_card", params);
+  }
+  async vehicleLicense(params) {
+    return this.extract("vehicle_license", params);
+  }
+  async trainInvoice(params) {
+    return this.extract("train_invoice", params);
+  }
+  async taxiInvoice(params) {
+    return this.extract("taxi_invoice", params);
+  }
+  async idCard(params) {
+    return this.extract("id_card", params);
+  }
+  async vatInvoice(params) {
+    return this.extract("vat_invoice", params);
+  }
+  async businessLicense(params) {
+    return this.extract("business_license", params);
+  }
+  async businessCard(params) {
+    return this.extract("business_card", params);
+  }
+  async contract(params) {
+    return this.extract("contract", params);
+  }
 };
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://unityclaw.com";
-var DEFAULT_TIMEOUT = 3e5;
+var DEFAULT_TIMEOUT = 9e5;
 var OLD_DOMAINS = ["fieldshortcut.cn", "fieldshortcut.com"];
 var NEW_DOMAIN = "unityclaw.com";
+var MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".avi": "video/x-msvideo",
+  ".webm": "video/webm",
+  ".m4a": "audio/mp4",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".aac": "audio/aac",
+  ".flac": "audio/flac",
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".json": "application/json"
+};
 function replaceOldDomains(text) {
   if (!text || typeof text !== "string") return text;
   let result = text;
@@ -800,6 +964,49 @@ function replaceOldDomains(text) {
   }
   return result;
 }
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getLocalPathCandidate(value) {
+  const candidates = [value.path, value.localPath, value.filePath];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return void 0;
+}
+function inferMimeType(filePath, provided) {
+  if (typeof provided === "string" && provided.trim()) {
+    return provided.trim();
+  }
+  const ext = (0, import_path3.extname)(filePath).toLowerCase();
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+function isDownloadableResponseItem(item) {
+  if (!item.content || typeof item.content !== "string") return false;
+  return /^https?:\/\//i.test(item.content);
+}
+function buildMultipartBody(fileBuffer, fieldName, filename, contentType) {
+  const boundary = `----UnityClawBoundary${Math.random().toString(16).slice(2)}`;
+  const chunks = [
+    Buffer.from(`--${boundary}\r
+`),
+    Buffer.from(`Content-Disposition: form-data; name="${fieldName}"; filename="${filename}"\r
+`),
+    Buffer.from(`Content-Type: ${contentType}\r
+\r
+`),
+    fileBuffer,
+    Buffer.from(`\r
+--${boundary}--\r
+`)
+  ];
+  return {
+    body: Buffer.concat(chunks),
+    contentType: `multipart/form-data; boundary=${boundary}`
+  };
+}
 var UnityClawClient = class {
   config;
   httpClient;
@@ -809,6 +1016,7 @@ var UnityClawClient = class {
   video;
   document;
   media;
+  idp;
   constructor(config = {}) {
     const fileConfig = loadConfig();
     const apiKey = config.apiKey ?? process.env.UNITYCLAW_API_KEY ?? fileConfig.apiKey ?? "";
@@ -822,6 +1030,7 @@ var UnityClawClient = class {
       taskDir: config.taskDir ?? fileConfig.taskDir ?? DEFAULT_TASKS_DIR,
       timeout: config.timeout ?? DEFAULT_TIMEOUT,
       downloadAttachments: config.downloadAttachments ?? true,
+      autoUploadLocalFiles: config.autoUploadLocalFiles ?? true,
       context: config.context ?? {}
     };
     this.httpClient = import_axios2.default.create({
@@ -841,6 +1050,7 @@ var UnityClawClient = class {
     this.video = new VideoAPI(this);
     this.document = new DocumentAPI(this);
     this.media = new MediaAPI(this);
+    this.idp = new IDPAPI(this);
   }
   /**
    * Get the underlying HTTP client for custom requests
@@ -899,13 +1109,14 @@ var UnityClawClient = class {
     const taskCtx = await this.taskFolderManager.createTaskFolder();
     try {
       await this.taskFolderManager.log(taskCtx, "info", `Starting request to ${endpoint}`);
+      const normalizedParams = await this.normalizeParams(params, taskCtx);
       const context = this.buildContext(contextOverrides);
       const requestBody = {
-        formItemParams: params,
+        formItemParams: normalizedParams,
         context
       };
-      await this.taskFolderManager.writeRequest(taskCtx, endpoint, params, context);
-      await this.taskFolderManager.log(taskCtx, "info", "Request prepared", { endpoint, params });
+      await this.taskFolderManager.writeRequest(taskCtx, endpoint, normalizedParams, context);
+      await this.taskFolderManager.log(taskCtx, "info", "Request prepared", { endpoint, params: normalizedParams });
       const response = await this.httpClient.post(endpoint, requestBody);
       if (response.data.msg) {
         response.data.msg = replaceOldDomains(response.data.msg);
@@ -919,7 +1130,7 @@ var UnityClawClient = class {
         for (const item of response.data.data) {
           if (item && typeof item === "object" && "content" in item && "contentType" in item) {
             const attachmentItem = item;
-            if (attachmentItem.contentType === "attachment/url" && attachmentItem.content) {
+            if (isDownloadableResponseItem(attachmentItem)) {
               const localPath = await this.taskFolderManager.downloadAttachment(taskCtx, {
                 tmp_url: attachmentItem.content,
                 name: attachmentItem.name
@@ -949,6 +1160,61 @@ var UnityClawClient = class {
       return await this.taskFolderManager.finalizeTaskFolder(taskCtx, errorResponse, false);
     }
   }
+  async uploadLocalFile(filePath, original) {
+    const file = await (0, import_promises2.readFile)(filePath);
+    const st = await (0, import_promises2.stat)(filePath);
+    const filename = typeof original?.name === "string" && original.name.trim() ? original.name.trim() : (0, import_path3.basename)(filePath);
+    const type = inferMimeType(filePath, original?.type);
+    const { body, contentType } = buildMultipartBody(file, "file", filename, type);
+    const uploadResponse = await this.httpClient.post("/api/upload", body, {
+      headers: {
+        "Content-Type": contentType,
+        "Content-Length": body.length.toString()
+      }
+    });
+    if (uploadResponse.data.code !== 0 || !uploadResponse.data.data) {
+      const message = uploadResponse.data.msg || "upload failed";
+      throw new Error(`Upload failed for ${filePath}: ${message}`);
+    }
+    return {
+      tmp_url: uploadResponse.data.data,
+      name: filename,
+      type,
+      size: Number.isFinite(st.size) ? st.size : void 0
+    };
+  }
+  async normalizeParams(params, taskCtx) {
+    if (!this.config.autoUploadLocalFiles) {
+      return params;
+    }
+    const walk = async (value) => {
+      if (Array.isArray(value)) {
+        const output2 = [];
+        for (const item of value) {
+          output2.push(await walk(item));
+        }
+        return output2;
+      }
+      if (!isRecord(value)) {
+        return value;
+      }
+      if (typeof value.tmp_url === "string" && value.tmp_url.trim()) {
+        return value;
+      }
+      const localPath = getLocalPathCandidate(value);
+      if (localPath) {
+        await this.taskFolderManager.log(taskCtx, "info", "Uploading local attachment", { localPath });
+        return this.uploadLocalFile(localPath, value);
+      }
+      const output = {};
+      for (const [k, v] of Object.entries(value)) {
+        output[k] = await walk(v);
+      }
+      return output;
+    };
+    const normalized = await walk(params);
+    return isRecord(normalized) ? normalized : params;
+  }
   // ==================== Convenience Methods ====================
   /**
    * Generate image using Gemini API
@@ -1000,17 +1266,126 @@ var UnityClawClient = class {
     return this.media.analyze(params);
   }
 };
+
+// src/types.ts
+var GEMINI_IMAGE_ASPECT_RATIOS = [
+  "1:1",
+  "9:16",
+  "16:9",
+  "4:3",
+  "3:4",
+  "3:2",
+  "2:3",
+  "5:4",
+  "4:5",
+  "21:9",
+  "1:4",
+  "1:8",
+  "4:1",
+  "8:1"
+];
+var GEMINI_IMAGE_SIZES = ["1K", "2K", "4K", "1K_pro", "2K_pro", "4K_pro"];
+var JIMENG_IMAGE_MODELS = ["doubao-seedream-5-0-260128", "doubao-seedream-4-5-251128"];
+var JIMENG_IMAGE_SIZES = [
+  "2048x2048",
+  "1728x2304",
+  "2304x1728",
+  "2848x1600",
+  "1600x2848",
+  "2496x1664",
+  "1664x2496",
+  "3136x1344",
+  "3072x3072",
+  "2592x3456",
+  "3456x2592",
+  "4096x2304",
+  "2304x4096",
+  "3744x2496",
+  "2496x3744",
+  "4704x2016",
+  "4096x4096",
+  "3520x4704",
+  "4704x3520",
+  "5504x3040",
+  "3040x5504",
+  "4992x3328",
+  "3328x4992",
+  "6240x2656"
+];
+var JIMENG_IMAGE_WEB_SEARCH_OPTIONS = ["true", "false"];
+var KLING_MODELS = [
+  "kling-v1",
+  "kling-v1-5",
+  "kling-v1-6",
+  "kling-v2-master",
+  "kling-v2-1",
+  "kling-v2-1-master",
+  "kling-v2-5-turbo",
+  "kling-v2-6"
+];
+var KLING_ASPECT_RATIOS = ["16:9", "9:16", "1:1"];
+var KLING_DURATIONS = ["5", "10"];
+var WAN_DEFAULT_MODELS = ["wan2.6-t2v", "wan2.6-i2v", "wan2.6-i2v-flash", "wan2.6-r2v"];
+var WAN_SHOT_TYPES = ["single", "multi"];
+var DOC_CONVERT_INPUT_FORMATS = ["image", "pdf"];
+var DOC_CONVERT_OUTPUT_FORMATS = ["docx", "pptx", "xlsx", "pdf", "image"];
+var DOC_TRANSLATE_LANGUAGE_CODES = [
+  "en",
+  "zh",
+  "zh-TW",
+  "ja",
+  "ko",
+  "es",
+  "fr",
+  "de",
+  "pt",
+  "ru",
+  "ar",
+  "it",
+  "nl",
+  "pl",
+  "tr",
+  "vi",
+  "th",
+  "id"
+];
+var IDP_TYPES = [
+  "bank_card",
+  "vehicle_license",
+  "train_invoice",
+  "taxi_invoice",
+  "id_card",
+  "vat_invoice",
+  "business_license",
+  "business_card",
+  "contract"
+];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CONFIG_DIR,
   CONFIG_FILE,
   DEFAULT_TASKS_DIR,
+  DOC_CONVERT_INPUT_FORMATS,
+  DOC_CONVERT_OUTPUT_FORMATS,
+  DOC_TRANSLATE_LANGUAGE_CODES,
   DocumentAPI,
+  GEMINI_IMAGE_ASPECT_RATIOS,
+  GEMINI_IMAGE_SIZES,
+  IDPAPI,
+  IDP_TYPES,
   ImageAPI,
+  JIMENG_IMAGE_MODELS,
+  JIMENG_IMAGE_SIZES,
+  JIMENG_IMAGE_WEB_SEARCH_OPTIONS,
+  KLING_ASPECT_RATIOS,
+  KLING_DURATIONS,
+  KLING_MODELS,
   MediaAPI,
   TaskFolderManager,
   UnityClawClient,
   VideoAPI,
+  WAN_DEFAULT_MODELS,
+  WAN_SHOT_TYPES,
   getConfigPath,
   getConfigValue,
   loadConfig,