@unityclaw/sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,937 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DocumentAPI: () => DocumentAPI,
+  ImageAPI: () => ImageAPI,
+  MediaAPI: () => MediaAPI,
+  TaskFolderManager: () => TaskFolderManager,
+  UnityClawClient: () => UnityClawClient,
+  VideoAPI: () => VideoAPI
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_axios2 = __toESM(require("axios"), 1);
+
+// src/task-folder.ts
+var import_promises = require("fs/promises");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_date_fns = require("date-fns");
+var import_uuid = require("uuid");
+var import_axios = __toESM(require("axios"), 1);
+var TaskFolderManager = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Create a new task folder with timestamp and unique ID
+   */
+  async createTaskFolder() {
+    const timestamp = (0, import_date_fns.format)(/* @__PURE__ */ new Date(), "yyyyMMdd_HHmmss");
+    const taskId = (0, import_uuid.v4)().slice(0, 8);
+    const folderName = `${timestamp}_${taskId}`;
+    const folderPath = (0, import_path.join)(this.options.taskDir, folderName);
+    const attachmentsPath = (0, import_path.join)(folderPath, "attachments");
+    const logsPath = (0, import_path.join)(folderPath, "logs");
+    await (0, import_promises.mkdir)(attachmentsPath, { recursive: true });
+    await (0, import_promises.mkdir)(logsPath, { recursive: true });
+    return {
+      taskId,
+      folderPath,
+      attachmentsPath,
+      logsPath,
+      startTime: Date.now(),
+      logs: [],
+      downloadedFiles: []
+    };
+  }
+  /**
+   * Log a message to the task folder
+   */
+  async log(ctx, level, message, data) {
+    const logEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      data
+    };
+    ctx.logs.push(logEntry);
+    const logFile = (0, import_path.join)(ctx.logsPath, "execution.log");
+    const logLine = `${logEntry.timestamp} [${level.toUpperCase()}] ${message}${data ? "\n" + JSON.stringify(data, null, 2) : ""}
+`;
+    await (0, import_promises.appendFile)(logFile, logLine, "utf-8");
+  }
+  /**
+   * Download an attachment from URL to local folder
+   * Important: Downloads attachments to avoid tmp_url expiration
+   */
+  async downloadAttachment(ctx, attachment) {
+    if (!this.options.downloadAttachments || !attachment.tmp_url) {
+      return attachment.tmp_url;
+    }
+    try {
+      const url = attachment.tmp_url;
+      const urlPath = url.split("?")[0];
+      const baseName = urlPath ? (0, import_path.basename)(urlPath) : "";
+      const filename = attachment.name || baseName || `file_${Date.now()}`;
+      const localPath = (0, import_path.join)(ctx.attachmentsPath, filename);
+      const response = await import_axios.default.get(url, {
+        responseType: "arraybuffer",
+        timeout: 6e4
+      });
+      await (0, import_promises.writeFile)(localPath, Buffer.from(response.data));
+      ctx.downloadedFiles.push(localPath);
+      return localPath;
+    } catch (error) {
+      await this.log(ctx, "warn", `Failed to download attachment: ${attachment.name}`, {
+        error: error instanceof Error ? error.message : error
+      });
+      return attachment.tmp_url;
+    }
+  }
+  /**
+   * Download multiple attachments
+   */
+  async downloadAttachments(ctx, attachments) {
+    const results = [];
+    for (const attachment of attachments) {
+      const localPath = await this.downloadAttachment(ctx, attachment);
+      if (localPath) {
+        results.push(localPath);
+      }
+    }
+    return results;
+  }
+  /**
+   * Write request details to task folder
+   */
+  async writeRequest(ctx, endpoint, params, context) {
+    const requestFile = (0, import_path.join)(ctx.logsPath, "request.json");
+    await (0, import_promises.writeFile)(
+      requestFile,
+      JSON.stringify(
+        {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          endpoint,
+          params,
+          context
+        },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+  }
+  /**
+   * Write response details to task folder
+   */
+  async writeResponse(ctx, response) {
+    const responseFile = (0, import_path.join)(ctx.logsPath, "response.json");
+    await (0, import_promises.writeFile)(responseFile, JSON.stringify(response, null, 2), "utf-8");
+  }
+  /**
+   * Finalize task folder and return result
+   */
+  async finalizeTaskFolder(ctx, response, success) {
+    const duration = Date.now() - ctx.startTime;
+    const summaryFile = (0, import_path.join)(ctx.logsPath, "summary.json");
+    await (0, import_promises.writeFile)(
+      summaryFile,
+      JSON.stringify(
+        {
+          taskId: ctx.taskId,
+          success,
+          duration,
+          startTime: new Date(ctx.startTime).toISOString(),
+          endTime: (/* @__PURE__ */ new Date()).toISOString(),
+          logsCount: ctx.logs.length,
+          attachmentsCount: ctx.downloadedFiles.length
+        },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+    return {
+      taskId: ctx.taskId,
+      success,
+      response,
+      duration,
+      taskFolder: ctx.folderPath,
+      logs: ctx.logs,
+      attachments: ctx.downloadedFiles
+    };
+  }
+  /**
+   * Clean up old task folders (optional utility)
+   */
+  async cleanOldFolders(maxAge) {
+    if (!(0, import_fs.existsSync)(this.options.taskDir)) {
+      return 0;
+    }
+    const now = Date.now();
+    const folders = await (0, import_promises.readdir)(this.options.taskDir, { withFileTypes: true });
+    let deletedCount = 0;
+    for (const folder of folders) {
+      if (!folder.isDirectory()) continue;
+      const folderPath = (0, import_path.join)(this.options.taskDir, folder.name);
+      const { rm } = await import("fs/promises");
+      const match = folder.name.match(/^(\d{8}_\d{6})/);
+      if (match && match[1]) {
+        try {
+          const folderDate = new Date(
+            match[1].replace(/(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})/, "$1-$2-$3T$4:$5:$6")
+          );
+          if (now - folderDate.getTime() > maxAge) {
+            await rm(folderPath, { recursive: true });
+            deletedCount++;
+          }
+        } catch {
+        }
+      }
+    }
+    return deletedCount;
+  }
+};
+
+// src/apis/image.ts
+var ImageAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Generate image using Gemini API
+   * @see /api/gemini/image
+   *
+   * @example
+   * ```typescript
+   * const result = await client.image.gemini({
+   *   prompt: 'A beautiful sunset over mountains',
+   *   size: { value: '2K', label: '2K' }
+   * });
+   * ```
+   */
+  async gemini(params) {
+    const taskResult = await this.client.request("/api/gemini/image", {
+      prompt: params.prompt,
+      attachment: params.attachment,
+      model: params.model,
+      aspect_ratio: params.aspect_ratio,
+      size: params.size
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate image using Gemini API v2
+   * @see /api/gemini/image/v2
+   */
+  async geminiV2(params) {
+    const taskResult = await this.client.request("/api/gemini/image/v2", {
+      prompt: params.prompt,
+      attachment: params.attachment,
+      model: params.model,
+      aspect_ratio: params.aspect_ratio,
+      size: params.size
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate image using JiMeng (Doubao) API
+   * @see /api/jimeng/image
+   *
+   * @example
+   * ```typescript
+   * const result = await client.image.jimeng({
+   *   prompt: '一只可爱的猫咪',
+   *   size: { value: '1024x1024', label: '1:1' }
+   * });
+   * ```
+   */
+  async jimeng(params) {
+    const taskResult = await this.client.request("/api/jimeng/image", {
+      prompt: params.prompt,
+      attachment: params.attachment,
+      size: params.size,
+      model_selector: params.model_selector,
+      web_search: params.web_search,
+      image_count: params.image_count,
+      model: params.model
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate image using JiMeng V3 API
+   * @see /api/jimeng/image/v3
+   */
+  async jimengV3(params) {
+    const taskResult = await this.client.request("/api/jimeng/image/v3", {
+      prompt: params.prompt,
+      attachment: params.attachment,
+      size: params.size,
+      model_selector: params.model_selector,
+      web_search: params.web_search,
+      image_count: params.image_count,
+      model: params.model
+    });
+    return taskResult.response;
+  }
+  /**
+   * Compress image
+   * @see /api/image/compress
+   */
+  async compress(params) {
+    const taskResult = await this.client.request("/api/image/compress", {
+      attachment: params.attachment,
+      quality: params.quality
+    });
+    return taskResult.response;
+  }
+};
+
+// src/apis/video.ts
+var VideoAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Generate video using Sora API
+   * @see /api/sora/video
+   *
+   * @example
+   * ```typescript
+   * const result = await client.video.sora({
+   *   prompt: 'A cat playing piano',
+   *   orientation: { value: 'landscape', label: 'Landscape' }
+   * });
+   * ```
+   */
+  async sora(params) {
+    const taskResult = await this.client.request("/api/sora/video", {
+      attachment: params.attachment,
+      prompt: params.prompt,
+      orientation: params.orientation
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate video using Sora Stable API
+   * @see /api/sora/video/stable
+   */
+  async soraStable(params) {
+    const taskResult = await this.client.request("/api/sora/video/stable", {
+      attachment: params.attachment,
+      prompt: params.prompt,
+      size: params.size,
+      seconds: params.seconds
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate video using Veo API
+   * @see /api/veo/video
+   *
+   * @example
+   * ```typescript
+   * const result = await client.video.veo({
+   *   prompt: 'A beautiful sunset over the ocean',
+   *   aspect_ratio: { value: '16:9', label: '16:9' },
+   *   duration: { value: '8', label: '8s' }
+   * });
+   * ```
+   */
+  async veo(params) {
+    const taskResult = await this.client.request("/api/veo/video", {
+      prompt: 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
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate video using Kling API
+   * @see /api/kling/video
+   *
+   * @example
+   * ```typescript
+   * const result = await client.video.kling({
+   *   prompt: 'A dog running in the park',
+   *   aspect_ratio: { value: '16:9', label: '16:9' },
+   *   duration: { value: '5', label: '5s' },
+   *   model: { value: 'kling-v1', label: 'V1' }
+   * });
+   * ```
+   */
+  async kling(params) {
+    const taskResult = await this.client.request("/api/kling/video", {
+      attachment: params.attachment,
+      prompt: params.prompt,
+      aspect_ratio: params.aspect_ratio,
+      duration: params.duration,
+      model: params.model
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate video using JiMeng API
+   * @see /api/jimeng/video
+   *
+   * @example
+   * ```typescript
+   * const result = await client.video.jimeng({
+   *   action: { value: 't2v', label: 'Text to Video' },
+   *   prompt: 'A beautiful landscape',
+   *   aspect_ratio: { value: '16:9', label: '16:9' }
+   * });
+   * ```
+   */
+  async jimeng(params) {
+    const taskResult = await this.client.request("/api/jimeng/video", {
+      action: params.action,
+      attachment: params.attachment,
+      prompt: params.prompt,
+      aspect_ratio: params.aspect_ratio
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate video using Doubao API
+   * @see /api/doubao/video
+   *
+   * @example
+   * ```typescript
+   * const result = await client.video.doubao({
+   *   prompt: 'A cinematic drone shot of mountains',
+   *   resolution: { value: '1080p', label: '1080p' },
+   *   ratio: { value: '16:9', label: '16:9' }
+   * });
+   * ```
+   */
+  async doubao(params) {
+    const taskResult = await this.client.request("/api/doubao/video", {
+      action: params.action,
+      attachment: params.attachment,
+      prompt: params.prompt,
+      resolution: params.resolution,
+      ratio: params.ratio,
+      duration: params.duration
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate video using Wan API (Alibaba)
+   * @see /api/wan/video
+   *
+   * @example
+   * ```typescript
+   * const result = await client.video.wan({
+   *   prompt: 'A futuristic city at night',
+   *   size: { value: '1280*720', label: '720p' },
+   *   duration: { value: '5', label: '5s' },
+   *   model: { value: 'wan2.6-t2v', label: 'Wan 2.6' }
+   * });
+   * ```
+   */
+  async wan(params) {
+    const taskResult = await 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
+    });
+    return taskResult.response;
+  }
+  /**
+   * Generate video using MiniMax API
+   * @see /api/minimax/video
+   *
+   * @example
+   * ```typescript
+   * const result = await client.video.minimax({
+   *   prompt: 'A person walking through a forest',
+   *   size: { value: '1360*768', label: '768p' },
+   *   model: { value: 'MiniMax-Hailuo-2.3', label: 'Hailuo 2.3' }
+   * });
+   * ```
+   */
+  async minimax(params) {
+    const taskResult = await this.client.request("/api/minimax/video", {
+      attachment: params.attachment,
+      prompt: params.prompt,
+      size: params.size,
+      duration: params.duration,
+      model: params.model
+    });
+    return taskResult.response;
+  }
+};
+
+// src/apis/document.ts
+var DocumentAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Translate document
+   * @see /api/doc/translate
+   *
+   * @example
+   * ```typescript
+   * const result = await client.document.translate({
+   *   attachment: [{ tmp_url: 'https://...', name: 'document.pdf' }],
+   *   source_language: { value: 'en', label: 'English' },
+   *   target_language: { value: 'zh', label: 'Chinese' }
+   * });
+   * ```
+   */
+  async translate(params) {
+    const taskResult = await this.client.request("/api/doc/translate", {
+      attachment: params.attachment,
+      source_language: params.source_language,
+      target_language: params.target_language
+    });
+    return taskResult.response;
+  }
+  /**
+   * Convert image to Word document
+   * @see /api/doc_convert/image2word
+   */
+  async image2Word(params) {
+    const taskResult = await this.client.request(
+      "/api/doc_convert/image2word",
+      {
+        attachment: params.attachment
+      }
+    );
+    return taskResult.response;
+  }
+  /**
+   * Convert image to PowerPoint
+   * @see /api/doc_convert/image2ppt
+   */
+  async image2Ppt(params) {
+    const taskResult = await this.client.request(
+      "/api/doc_convert/image2ppt",
+      {
+        attachment: params.attachment
+      }
+    );
+    return taskResult.response;
+  }
+  /**
+   * Convert image to Excel
+   * @see /api/doc_convert/image2excel
+   */
+  async image2Excel(params) {
+    const taskResult = await this.client.request(
+      "/api/doc_convert/image2excel",
+      {
+        attachment: params.attachment
+      }
+    );
+    return taskResult.response;
+  }
+  /**
+   * Convert image to PDF
+   * @see /api/doc_convert/image2pdf
+   */
+  async image2Pdf(params) {
+    const taskResult = await this.client.request(
+      "/api/doc_convert/image2pdf",
+      {
+        attachment: params.attachment
+      }
+    );
+    return taskResult.response;
+  }
+  /**
+   * Convert PDF to Word document
+   * @see /api/doc_convert/pdf2word
+   */
+  async pdf2Word(params) {
+    const taskResult = await this.client.request(
+      "/api/doc_convert/pdf2word",
+      {
+        attachment: params.attachment
+      }
+    );
+    return taskResult.response;
+  }
+  /**
+   * Convert PDF to PowerPoint
+   * @see /api/doc_convert/pdf2ppt
+   */
+  async pdf2Ppt(params) {
+    const taskResult = await this.client.request(
+      "/api/doc_convert/pdf2ppt",
+      {
+        attachment: params.attachment
+      }
+    );
+    return taskResult.response;
+  }
+  /**
+   * Convert PDF to Excel
+   * @see /api/doc_convert/pdf2excel
+   */
+  async pdf2Excel(params) {
+    const taskResult = await this.client.request(
+      "/api/doc_convert/pdf2excel",
+      {
+        attachment: params.attachment
+      }
+    );
+    return taskResult.response;
+  }
+  /**
+   * Convert PDF to image
+   * @see /api/doc_convert/pdf2image
+   */
+  async pdf2Image(params) {
+    const taskResult = await this.client.request(
+      "/api/doc_convert/pdf2image",
+      {
+        attachment: params.attachment
+      }
+    );
+    return taskResult.response;
+  }
+  /**
+   * Generic document conversion
+   * @see /api/doc_convert/image
+   * @see /api/doc_convert/pdf
+   */
+  async convert(params) {
+    const isImage = params.input_format === "image" || !params.input_format;
+    const endpoint = isImage ? "/api/doc_convert/image" : "/api/doc_convert/pdf";
+    const taskResult = await this.client.request(endpoint, {
+      attachment: params.attachment,
+      input_format: params.input_format,
+      output_format: params.output_format
+    });
+    return taskResult.response;
+  }
+};
+
+// src/apis/media.ts
+var MediaAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Analyze media (video/audio) from URL or file
+   * @see /api/media_analysis
+   *
+   * @example
+   * ```typescript
+   * // Analyze from URL
+   * const result = await client.media.analyze({
+   *   url: [{ link: 'https://youtube.com/watch?v=...' }]
+   * });
+   *
+   * // Analyze from uploaded file
+   * const result = await client.media.analyze({
+   *   url: [{ tmp_url: 'https://...', type: 'video/mp4', name: 'video.mp4' }]
+   * });
+   * ```
+   */
+  async analyze(params) {
+    const taskResult = await this.client.request("/api/media_analysis", {
+      url: params.url
+    });
+    return taskResult.response;
+  }
+  /**
+   * Analyze video file directly
+   * @see /api/video_analysis (internal)
+   *
+   * @example
+   * ```typescript
+   * const result = await client.media.analyzeVideo({
+   *   file: { tmp_url: 'https://...', type: 'video/mp4', name: 'video.mp4' },
+   *   prompt: 'Summarize this video'
+   * });
+   * ```
+   */
+  async analyzeVideo(params) {
+    const taskResult = await this.client.request("/api/media_analysis", {
+      url: [
+        {
+          tmp_url: params.file.tmp_url,
+          type: params.file.type,
+          name: params.file.name,
+          size: params.file.size
+        }
+      ]
+    });
+    return taskResult.response;
+  }
+  /**
+   * Analyze social media video (TikTok, YouTube, etc.)
+   * @see /api/media_analysis
+   *
+   * @example
+   * ```typescript
+   * const result = await client.media.analyzeSocialVideo({
+   *   url: 'https://www.tiktok.com/@user/video/123456'
+   * });
+   * ```
+   */
+  async analyzeSocialVideo(params) {
+    const taskResult = await this.client.request("/api/media_analysis", {
+      url: [{ link: params.url, type: "url" }]
+    });
+    return taskResult.response;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://unityclaw.com";
+var DEFAULT_TIMEOUT = 3e5;
+var UnityClawClient = class {
+  config;
+  httpClient;
+  taskFolderManager;
+  // API modules
+  image;
+  video;
+  document;
+  media;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.UNITYCLAW_API_KEY ?? "";
+    const baseUrl = config.baseUrl ?? process.env.UNITYCLAW_BASE_URL ?? DEFAULT_BASE_URL;
+    if (!apiKey) {
+      throw new Error("API key is required. Set UNITYCLAW_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.config = {
+      apiKey,
+      baseUrl,
+      taskDir: config.taskDir ?? (() => {
+        const path = require("path");
+        const os = require("os");
+        try {
+          return path.join(process.cwd(), "tasks");
+        } catch {
+          return path.join(os.homedir(), "tasks");
+        }
+      })(),
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      downloadAttachments: config.downloadAttachments ?? true,
+      context: config.context ?? {}
+    };
+    this.httpClient = import_axios2.default.create({
+      baseURL: this.config.baseUrl,
+      timeout: this.config.timeout,
+      headers: {
+        "Content-Type": "application/json",
+        "X-Api-Key": this.config.apiKey
+      }
+    });
+    this.taskFolderManager = new TaskFolderManager({
+      taskDir: this.config.taskDir,
+      downloadAttachments: this.config.downloadAttachments
+    });
+    this.image = new ImageAPI(this);
+    this.video = new VideoAPI(this);
+    this.document = new DocumentAPI(this);
+    this.media = new MediaAPI(this);
+  }
+  /**
+   * Get the underlying HTTP client for custom requests
+   */
+  getHttpClient() {
+    return this.httpClient;
+  }
+  /**
+   * Get the task folder manager
+   */
+  getTaskFolderManager() {
+    return this.taskFolderManager;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Build context object from config defaults
+   */
+  buildContext(overrides) {
+    const now = Date.now();
+    const defaultContext = {
+      logID: `sdk_${now}_${Math.random().toString(36).slice(2, 10)}`,
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      baseID: "",
+      tableID: "",
+      bitable: {
+        logID: `sdk_${now}`,
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        baseID: "",
+        tableID: ""
+      },
+      tenantKey: "",
+      userID: this.config.context.userID ?? "",
+      packID: "",
+      extensionID: "sdk",
+      baseSignature: "",
+      baseOwnerID: this.config.context.userID ?? ""
+    };
+    if (this.config.context) {
+      Object.assign(defaultContext, this.config.context);
+    }
+    if (overrides) {
+      Object.assign(defaultContext, overrides);
+    }
+    return defaultContext;
+  }
+  /**
+   * Make a request to the UnityClaw API
+   * This is the core method that handles task folder creation, logging, and error handling
+   */
+  async request(endpoint, params, contextOverrides) {
+    const taskCtx = await this.taskFolderManager.createTaskFolder();
+    try {
+      await this.taskFolderManager.log(taskCtx, "info", `Starting request to ${endpoint}`);
+      const context = this.buildContext(contextOverrides);
+      const requestBody = {
+        formItemParams: params,
+        context
+      };
+      await this.taskFolderManager.writeRequest(taskCtx, endpoint, params, context);
+      await this.taskFolderManager.log(taskCtx, "info", "Request prepared", { endpoint, params });
+      const response = await this.httpClient.post(endpoint, requestBody);
+      await this.taskFolderManager.writeResponse(taskCtx, response.data);
+      await this.taskFolderManager.log(taskCtx, "info", "Response received", {
+        code: response.data.code,
+        hasData: !!response.data.data
+      });
+      if (response.data.data && Array.isArray(response.data.data)) {
+        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) {
+              const localPath = await this.taskFolderManager.downloadAttachment(taskCtx, {
+                tmp_url: attachmentItem.content,
+                name: attachmentItem.name
+              });
+              if (localPath) {
+                attachmentItem.localPath = localPath;
+              }
+            }
+          }
+        }
+      }
+      return await this.taskFolderManager.finalizeTaskFolder(
+        taskCtx,
+        response.data,
+        response.data.code === 0
+      );
+    } catch (error) {
+      const errorMessage = error instanceof import_axios2.AxiosError ? error.response?.data?.msg || error.message : error instanceof Error ? error.message : String(error);
+      await this.taskFolderManager.log(taskCtx, "error", `Request failed: ${errorMessage}`, {
+        error: error instanceof import_axios2.AxiosError ? { status: error.response?.status, data: error.response?.data } : error
+      });
+      const errorResponse = {
+        code: -1,
+        msg: errorMessage
+      };
+      return await this.taskFolderManager.finalizeTaskFolder(taskCtx, errorResponse, false);
+    }
+  }
+  // ==================== Convenience Methods ====================
+  /**
+   * Generate image using Gemini API
+   * @deprecated Use client.image.gemini() instead
+   */
+  async generateImage(params) {
+    return this.image.gemini(params);
+  }
+  /**
+   * Generate image using JiMeng API
+   * @deprecated Use client.image.jimeng() instead
+   */
+  async generateJiMengImage(params) {
+    return this.image.jimeng(params);
+  }
+  /**
+   * Generate video using Sora API
+   * @deprecated Use client.video.sora() instead
+   */
+  async generateSoraVideo(params) {
+    return this.video.sora(params);
+  }
+  /**
+   * Generate video using Veo API
+   * @deprecated Use client.video.veo() instead
+   */
+  async generateVeoVideo(params) {
+    return this.video.veo(params);
+  }
+  /**
+   * Generate video using Kling API
+   * @deprecated Use client.video.kling() instead
+   */
+  async generateKlingVideo(params) {
+    return this.video.kling(params);
+  }
+  /**
+   * Translate document
+   * @deprecated Use client.document.translate() instead
+   */
+  async translateDocument(params) {
+    return this.document.translate(params);
+  }
+  /**
+   * Analyze media (video/audio from URL)
+   * @deprecated Use client.media.analyze() instead
+   */
+  async analyzeMedia(params) {
+    return this.media.analyze(params);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DocumentAPI,
+  ImageAPI,
+  MediaAPI,
+  TaskFolderManager,
+  UnityClawClient,
+  VideoAPI
+});