@mixio-pro/kalaasetu-mcp 2.3.32 → 2.3.33

package/fal-config.json

@@ -143,6 +143,40 @@
           "default": "replace_audio_and_video"
         }
       }
+    },
+    {
+      "presetName": "multi_angle",
+      "intent": "Generate a single multi-angle image edit using Qwen Image Edit with the Mixio multi-angle LoRA.",
+      "modelId": "fal-ai/qwen-image-edit-2509-lora",
+      "inputType": "image",
+      "outputType": "image",
+      "enabled": false,
+      "pricing": {
+        "baseCredits": 15,
+        "rounding": "ceil"
+      }
+    },
+    {
+      "presetName": "multi_angle_batch",
+      "intent": "Generate multiple multi-angle image edits using Qwen Image Edit with the Mixio multi-angle LoRA.",
+      "modelId": "fal-ai/qwen-image-edit-2509-lora",
+      "inputType": "image",
+      "outputType": "image",
+      "enabled": false,
+      "pricing": {
+        "baseCredits": 15,
+        "modifiers": [
+          {
+            "field": "batch_count",
+            "mode": "step",
+            "operation": "add",
+            "step": 1,
+            "offset": 1,
+            "valuePerStep": 15
+          }
+        ],
+        "rounding": "ceil"
+      }
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "2.3.32",
+  "version": "2.3.33",
   "description": "A powerful Model Context Protocol server providing AI tools for content generation and analysis",
   "type": "module",
   "module": "src/index.ts",

package/src/index.ts

@@ -100,6 +100,8 @@ async function main() {
     server.addTool(falGetPresetDetails);
     server.addTool(falUploadFile);
     server.addTool(falGenerate);
+    server.addTool(mixioMultiAngle);
+    server.addTool(mixioMultiAngleBatch);
     // 4. Register Dynamic FAL AI Tools
     // These are now based on potentially synced remote config
     const falTools = createAllFalTools();
@@ -109,8 +111,6 @@ async function main() {
   }
 
   // 4. Add Mixio Tools
-  // server.addTool(mixioMultiAngle);
-  // server.addTool(mixioMultiAngleBatch);
   // server.addTool(mixioNextScene);
   // server.addTool(mixioFaceSwap);
   if (process.env.GROK_ENABLED === "true") {

package/src/tools/mixio/multi-angle-batch.ts

@@ -1,77 +1,299 @@
 import { z } from "zod";
+import * as path from "path";
 import {
   safeToolExecute,
   extractPrimitiveArgs,
 } from "../../utils/tool-wrapper";
 import {
-  appendImageToFormData,
-  MIXIO_IMAGE_EDIT_URL,
-  handleMixioResponse,
-} from "./common";
-
-const azimuthEnum = z.enum([
-  "front view",
-  "front-right quarter view",
-  "right side view",
-  "back-right quarter view",
-  "back view",
-  "back-left quarter view",
-  "left side view",
-  "front-left quarter view",
-]);
-
-const elevationEnum = z.enum([
-  "low-angle shot",
-  "eye-level shot",
-  "elevated shot",
-  "high-angle shot",
-]);
-
-const distanceEnum = z.enum([
-  "close-up",
-  "medium shot",
-  "wide shot",
-]);
+  FAL_QUEUE_URL,
+  FAL_REST_URL,
+  AUTHENTICATED_TIMEOUT,
+  getApiKey,
+} from "../fal/config";
+import { getStorage } from "../../storage";
+import { saveMixioImage } from "./common";
+
+const QWEN_MULTI_ANGLE_MODEL_ID = "fal-ai/qwen-image-edit-2509-lora";
+const QWEN_MULTI_ANGLE_LORA_PATH =
+  "https://huggingface.co/dx8152/Qwen-Edit-2509-Multiple-angles/resolve/main/%E9%95%9C%E5%A4%B4%E8%BD%AC%E6%8D%A2.safetensors";
+const DEFAULT_LORA_SCALE = 1.0;
+const POLL_INTERVAL_MS = 3000;
+const MAX_POLL_TIME_MS = 90000;
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getMimeType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeTypes: Record<string, string> = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".avif": "image/avif",
+    ".heif": "image/heif",
+  };
+
+  return mimeTypes[ext] || "application/octet-stream";
+}
+
+function extractRequestIdFromStatusUrl(statusUrl: string): string {
+  const parts = statusUrl.split("/").filter(Boolean);
+  const statusIndex = parts.lastIndexOf("status");
+
+  const fromStatus = statusIndex > 0 ? parts[statusIndex - 1] : undefined;
+  if (fromStatus) {
+    return fromStatus;
+  }
+
+  const lastPart = parts[parts.length - 1];
+  return lastPart ?? "";
+}
+
+async function uploadImageToFalCdn(
+  imagePath: string,
+  apiKey: string,
+): Promise<string> {
+  if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+    return imagePath;
+  }
+
+  const storage = getStorage();
+  if (!(await storage.exists(imagePath))) {
+    throw new Error(`File not found: ${imagePath}`);
+  }
+
+  const fileBuffer = Buffer.from(await storage.readFile(imagePath));
+  const fileName = path.basename(imagePath);
+  const contentType = getMimeType(fileName);
+
+  const initiateResponse = await fetch(
+    `${FAL_REST_URL}/storage/upload/initiate?storage_type=fal-cdn-v3`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Key ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        content_type: contentType,
+        file_name: fileName,
+      }),
+      signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+    },
+  );
+
+  if (!initiateResponse.ok) {
+    const errorText = await initiateResponse.text();
+    throw new Error(
+      `Failed to initiate FAL upload [${initiateResponse.status}]: ${errorText}`,
+    );
+  }
+
+  const initiateData = (await initiateResponse.json()) as {
+    file_url?: string;
+    upload_url?: string;
+  };
+
+  if (!initiateData.file_url || !initiateData.upload_url) {
+    throw new Error("FAL upload initiation did not return file_url/upload_url");
+  }
+
+  const uploadResponse = await fetch(initiateData.upload_url, {
+    method: "PUT",
+    headers: {
+      "Content-Type": contentType,
+    },
+    body: fileBuffer,
+    signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+  });
+
+  if (!uploadResponse.ok) {
+    const errorText = await uploadResponse.text();
+    throw new Error(
+      `Failed to upload file to FAL CDN [${uploadResponse.status}]: ${errorText}`,
+    );
+  }
+
+  return initiateData.file_url;
+}
+
+async function submitQwenMultiAngleRequest(
+  payload: Record<string, any>,
+  apiKey: string,
+): Promise<{
+  requestId: string;
+  statusUrl: string;
+  responseUrl: string;
+}> {
+  const submitResponse = await fetch(`${FAL_QUEUE_URL}/${QWEN_MULTI_ANGLE_MODEL_ID}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Key ${apiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+  });
+
+  if (!submitResponse.ok) {
+    const errorText = await submitResponse.text();
+    throw new Error(`FAL submit error [${submitResponse.status}]: ${errorText}`);
+  }
+
+  const submitJson = (await submitResponse.json()) as {
+    request_id?: string;
+    status_url?: string;
+    response_url?: string;
+  };
+
+  const requestId =
+    submitJson.request_id ||
+    (submitJson.status_url
+      ? extractRequestIdFromStatusUrl(submitJson.status_url)
+      : "");
+
+  if (!requestId) {
+    throw new Error("Could not extract FAL request ID from submit response");
+  }
+
+  return {
+    requestId,
+    statusUrl:
+      submitJson.status_url ||
+      `${FAL_QUEUE_URL}/${QWEN_MULTI_ANGLE_MODEL_ID}/requests/${requestId}/status`,
+    responseUrl:
+      submitJson.response_url ||
+      `${FAL_QUEUE_URL}/${QWEN_MULTI_ANGLE_MODEL_ID}/requests/${requestId}`,
+  };
+}
+
+async function waitForQwenMultiAngleResult(
+  statusUrl: string,
+  responseUrl: string,
+  apiKey: string,
+): Promise<any> {
+  const startTime = Date.now();
+  let currentStatusUrl = statusUrl;
+  let currentResponseUrl = responseUrl;
+
+  while (Date.now() - startTime < MAX_POLL_TIME_MS) {
+    const statusResponse = await fetch(currentStatusUrl, {
+      method: "GET",
+      headers: {
+        Authorization: `Key ${apiKey}`,
+      },
+      signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+    });
+
+    if (!statusResponse.ok) {
+      const errorText = await statusResponse.text();
+      if (statusResponse.status === 404) {
+        await wait(POLL_INTERVAL_MS);
+        continue;
+      }
+      throw new Error(
+        `FAL status error [${statusResponse.status}]: ${errorText}`,
+      );
+    }
+
+    const statusJson = (await statusResponse.json()) as {
+      status?: string;
+      status_url?: string;
+      response_url?: string;
+      error?: unknown;
+    };
+
+    if (statusJson.status_url) currentStatusUrl = statusJson.status_url;
+    if (statusJson.response_url) currentResponseUrl = statusJson.response_url;
+
+    if (statusJson.status === "COMPLETED") {
+      const resultResponse = await fetch(currentResponseUrl, {
+        method: "GET",
+        headers: {
+          Authorization: `Key ${apiKey}`,
+        },
+        signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+      });
+
+      if (!resultResponse.ok) {
+        const errorText = await resultResponse.text();
+        throw new Error(
+          `FAL result error [${resultResponse.status}]: ${errorText}`,
+        );
+      }
+
+      return resultResponse.json();
+    }
+
+    if (statusJson.status === "FAILED") {
+      throw new Error(
+        `FAL generation failed: ${JSON.stringify(statusJson.error || statusJson)}`,
+      );
+    }
+
+    await wait(POLL_INTERVAL_MS);
+  }
+
+  throw new Error(
+    "FAL generation timed out. Please reduce batch size or retry with shorter prompts.",
+  );
+}
 
 export const mixioMultiAngleBatch = {
   name: "mixio_multi_angle_batch",
   description:
-    "Precise 3D-like camera control for image editing using Qwen-Image-Edit-2511. " +
-    "Generates multiple images in a single batch process and returns a ZIP file. " +
-    "\n\n**Prompt Format**: Each batch prompt optionally takes [azimuth] [elevation] [distance] [instruction]",
+    "多角度镜头批量编辑（Qwen-Image-Edit-2509 + dx8152/Qwen-Edit-2509-Multiple-angles LoRA）。" +
+    "\n\n每条提示词请直接用中文描述镜头意图，不再使用 azimuth/elevation/zoom 枚举。" +
+    "\n\n**每条 Prompt 推荐格式（中文）**：" +
+    "\n1) 镜头动作（移动/旋转/俯视/特写等）" +
+    "\n2) 保持不变的主体信息（人物、服装、场景）" +
+    "\n3) 构图约束（如居中、近景、广角）" +
+    "\n\n**示例 Prompt**：" +
+    "\n- 将镜头向左旋转45度，保持人物身份与服装一致。" +
+    "\n- 将镜头转为俯视，主体保持居中，背景光照风格不变。" +
+    "\n- 将镜头转为特写并轻微前移，突出面部细节。",
   parameters: z.object({
     image_path: z
       .string()
       .describe("Absolute local path or URL to the base image."),
     batch_prompts: z
       .array(
-        z.object({
-          azimuth: azimuthEnum,
-          elevation: elevationEnum,
-          distance: distanceEnum,
-        }),
+        z.string().describe("Chinese camera-intent prompt for one output image."),
       )
+      .min(1)
+      .max(4)
       .describe(
-        "Array of configurations for batch processing. Returns a .zip containing all generated images.",
+        "Array of Chinese prompts. The tool returns one image per prompt and saves them with indexed filenames.",
       ),
     negative_prompt: z
       .string()
       .optional()
       .default("")
       .describe("Elements to avoid."),
+    lora_scale: z
+      .number()
+      .min(0)
+      .max(4)
+      .optional()
+      .default(DEFAULT_LORA_SCALE)
+      .describe("LoRA weight scale for the multi-angle adapter (0 to 4)."),
     seed: z.number().optional().default(42).describe("Random seed."),
-    output_path: z.string().describe("Local path to save the resulting ZIP archive."),
+    output_path: z
+      .string()
+      .describe(
+        "Local path for output images. The first image uses this path, additional ones use _1, _2, ... suffixes.",
+      ),
   }),
   timeoutMs: 180000,
   async execute(
     args: {
       image_path: string;
-      batch_prompts: Array<{
-        azimuth: string;
-        elevation: string;
-        distance: string;
-      }>;
+      batch_prompts: string[];
       negative_prompt?: string;
+      lora_scale?: number;
       seed?: number;
       output_path: string;
     },
@@ -83,48 +305,121 @@ export const mixioMultiAngleBatch = {
           throw new Error("batch_prompts array cannot be empty.");
         }
 
-        const formData = new FormData();
-        await appendImageToFormData(formData, "image", args.image_path);
+        const normalizedPrompts = args.batch_prompts
+          .map((prompt) => prompt.trim())
+          .filter((prompt) => prompt.length > 0);
 
-        for (const bp of args.batch_prompts) {
-          const parts = [bp.azimuth, bp.elevation, bp.distance];
-          formData.append("prompt", parts.join(" ").trim());
+        if (normalizedPrompts.length === 0) {
+          throw new Error("At least one non-empty prompt is required.");
         }
 
-        formData.append("lora_type", "multi_angle");
-        formData.append("negative_prompt", args.negative_prompt || "");
-        formData.append("seed", (args.seed ?? 42).toString());
-
         if (context?.streamContent) {
           await context.streamContent({
             type: "text" as const,
-            text: `[Mixio] Submitting Multi-Angle Batch edit request for ${args.batch_prompts.length} prompts...`,
+            text: `[Mixio] Preparing image for FAL multi-angle batch (${normalizedPrompts.length} prompts)...`,
           });
         }
 
-        const response = await fetch(MIXIO_IMAGE_EDIT_URL, {
-          method: "POST",
-          body: formData,
-        });
+        const apiKey = getApiKey();
+        const imageUrl = await uploadImageToFalCdn(args.image_path, apiKey);
 
-        if (!response.ok) {
-          const errorText = await response.text();
-          throw new Error(`Mixio API error [${response.status}]: ${errorText}`);
-        }
+        const savedImages: Array<{
+          path: string;
+          url: string;
+          index: number;
+          request_id: string;
+        }> = [];
+
+        for (let index = 0; index < normalizedPrompts.length; index++) {
+          const prompt = normalizedPrompts[index];
+
+          if (context?.streamContent) {
+            await context.streamContent({
+              type: "text" as const,
+              text: `[Mixio] Running batch item ${index + 1}/${normalizedPrompts.length}...`,
+            });
+          }
+
+          const payload = {
+            prompt,
+            image_urls: [imageUrl],
+            negative_prompt: args.negative_prompt || " ",
+            seed: (args.seed ?? 42) + index,
+            output_format: "png",
+            loras: [
+              {
+                path: QWEN_MULTI_ANGLE_LORA_PATH,
+                scale: args.lora_scale ?? DEFAULT_LORA_SCALE,
+              },
+            ],
+          };
+
+          const { requestId, statusUrl, responseUrl } =
+            await submitQwenMultiAngleRequest(payload, apiKey);
 
-        const result = await handleMixioResponse(response, args.output_path);
+          const finalResult = await waitForQwenMultiAngleResult(
+            statusUrl,
+            responseUrl,
+            apiKey,
+          );
+
+          const resultImageUrl =
+            finalResult?.images?.[0]?.url ||
+            finalResult?.image?.url ||
+            finalResult?.data?.url ||
+            finalResult?.url;
+
+          if (!resultImageUrl) {
+            throw new Error(
+              `Batch item ${index + 1} has no output image URL: ${JSON.stringify(finalResult)}`,
+            );
+          }
+
+          const ext = path.extname(args.output_path);
+          const base = ext
+            ? args.output_path.slice(0, -ext.length)
+            : args.output_path;
+          const finalOutputPath =
+            index === 0
+              ? args.output_path
+              : `${base}_${index}${ext || ".png"}`;
+
+          const saved = await saveMixioImage(
+            resultImageUrl,
+            finalOutputPath,
+            `mixio_multi_angle_batch_${index + 1}.png`,
+          );
+
+          savedImages.push({
+            path: saved.path,
+            url: saved.url,
+            index,
+            request_id: requestId,
+          });
+        }
 
         return JSON.stringify({
           status: "COMPLETED",
           message: "Multi-angle batch edit completed.",
-          ...result,
+          images: savedImages,
+          total: savedImages.length,
           seed: args.seed ?? 42,
+          model_id: QWEN_MULTI_ANGLE_MODEL_ID,
+          lora: {
+            path: QWEN_MULTI_ANGLE_LORA_PATH,
+            scale: args.lora_scale ?? DEFAULT_LORA_SCALE,
+          },
         });
       },
       "mixioMultiAngleBatch",
       {
         toolName: "mixio_multi_angle_batch",
-        toolArgs: extractPrimitiveArgs(args),
+        toolArgs: {
+          ...extractPrimitiveArgs(args),
+          batch_count: args.batch_prompts
+            .map((prompt) => prompt.trim())
+            .filter((prompt) => prompt.length > 0).length,
+        },
         requestId: (context as any)?.requestId,
       },
     );

package/src/tools/mixio/multi-angle.ts

@@ -1,63 +1,305 @@
 import { z } from "zod";
+import * as path from "path";
 import {
   safeToolExecute,
   extractPrimitiveArgs,
 } from "../../utils/tool-wrapper";
 import {
-  appendImageToFormData,
-  MIXIO_IMAGE_EDIT_URL,
-  handleMixioResponse,
-} from "./common";
-
-const azimuthEnum = z.enum([
-  "front view",
-  "front-right quarter view",
-  "right side view",
-  "back-right quarter view",
-  "back view",
-  "back-left quarter view",
-  "left side view",
-  "front-left quarter view",
-]);
-
-const elevationEnum = z.enum([
-  "low-angle shot",
-  "eye-level shot",
-  "elevated shot",
-  "high-angle shot",
-]);
-
-const distanceEnum = z.enum([
-  "close-up",
-  "medium shot",
-  "wide shot",
-]);
+  FAL_QUEUE_URL,
+  FAL_REST_URL,
+  AUTHENTICATED_TIMEOUT,
+  getApiKey,
+} from "../fal/config";
+import { getStorage } from "../../storage";
+import { saveMixioImage } from "./common";
+
+const QWEN_MULTI_ANGLE_MODEL_ID = "fal-ai/qwen-image-edit-2509-lora";
+const QWEN_MULTI_ANGLE_LORA_PATH =
+  "https://huggingface.co/dx8152/Qwen-Edit-2509-Multiple-angles/resolve/main/%E9%95%9C%E5%A4%B4%E8%BD%AC%E6%8D%A2.safetensors";
+const DEFAULT_LORA_SCALE = 1.0;
+const POLL_INTERVAL_MS = 3000;
+const MAX_POLL_TIME_MS = 90000;
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getMimeType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeTypes: Record<string, string> = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".avif": "image/avif",
+    ".heif": "image/heif",
+  };
+
+  return mimeTypes[ext] || "application/octet-stream";
+}
+
+function extractRequestIdFromStatusUrl(statusUrl: string): string {
+  const parts = statusUrl.split("/").filter(Boolean);
+  const statusIndex = parts.lastIndexOf("status");
+
+  const fromStatus = statusIndex > 0 ? parts[statusIndex - 1] : undefined;
+  if (fromStatus) {
+    return fromStatus;
+  }
+
+  const lastPart = parts[parts.length - 1];
+  return lastPart ?? "";
+}
+
+async function uploadImageToFalCdn(
+  imagePath: string,
+  apiKey: string,
+): Promise<string> {
+  if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+    return imagePath;
+  }
+
+  const storage = getStorage();
+  if (!(await storage.exists(imagePath))) {
+    throw new Error(`File not found: ${imagePath}`);
+  }
+
+  const fileBuffer = Buffer.from(await storage.readFile(imagePath));
+  const fileName = path.basename(imagePath);
+  const contentType = getMimeType(fileName);
+
+  const initiateResponse = await fetch(
+    `${FAL_REST_URL}/storage/upload/initiate?storage_type=fal-cdn-v3`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Key ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        content_type: contentType,
+        file_name: fileName,
+      }),
+      signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+    },
+  );
+
+  if (!initiateResponse.ok) {
+    const errorText = await initiateResponse.text();
+    throw new Error(
+      `Failed to initiate FAL upload [${initiateResponse.status}]: ${errorText}`,
+    );
+  }
+
+  const initiateData = (await initiateResponse.json()) as {
+    file_url?: string;
+    upload_url?: string;
+  };
+
+  if (!initiateData.file_url || !initiateData.upload_url) {
+    throw new Error("FAL upload initiation did not return file_url/upload_url");
+  }
+
+  const uploadResponse = await fetch(initiateData.upload_url, {
+    method: "PUT",
+    headers: {
+      "Content-Type": contentType,
+    },
+    body: fileBuffer,
+    signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+  });
+
+  if (!uploadResponse.ok) {
+    const errorText = await uploadResponse.text();
+    throw new Error(
+      `Failed to upload file to FAL CDN [${uploadResponse.status}]: ${errorText}`,
+    );
+  }
+
+  return initiateData.file_url;
+}
+
+async function submitQwenMultiAngleRequest(
+  payload: Record<string, any>,
+  apiKey: string,
+): Promise<{
+  requestId: string;
+  statusUrl: string;
+  responseUrl: string;
+}> {
+  const submitResponse = await fetch(`${FAL_QUEUE_URL}/${QWEN_MULTI_ANGLE_MODEL_ID}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Key ${apiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+  });
+
+  if (!submitResponse.ok) {
+    const errorText = await submitResponse.text();
+    throw new Error(`FAL submit error [${submitResponse.status}]: ${errorText}`);
+  }
+
+  const submitJson = (await submitResponse.json()) as {
+    request_id?: string;
+    status_url?: string;
+    response_url?: string;
+  };
+
+  const requestId =
+    submitJson.request_id ||
+    (submitJson.status_url
+      ? extractRequestIdFromStatusUrl(submitJson.status_url)
+      : "");
+
+  if (!requestId) {
+    throw new Error("Could not extract FAL request ID from submit response");
+  }
+
+  return {
+    requestId,
+    statusUrl:
+      submitJson.status_url ||
+      `${FAL_QUEUE_URL}/${QWEN_MULTI_ANGLE_MODEL_ID}/requests/${requestId}/status`,
+    responseUrl:
+      submitJson.response_url ||
+      `${FAL_QUEUE_URL}/${QWEN_MULTI_ANGLE_MODEL_ID}/requests/${requestId}`,
+  };
+}
+
+async function waitForQwenMultiAngleResult(
+  statusUrl: string,
+  responseUrl: string,
+  apiKey: string,
+  context?: any,
+): Promise<any> {
+  const startTime = Date.now();
+  let currentStatusUrl = statusUrl;
+  let currentResponseUrl = responseUrl;
+  let pollCount = 0;
+
+  while (Date.now() - startTime < MAX_POLL_TIME_MS) {
+    pollCount++;
+
+    const statusResponse = await fetch(currentStatusUrl, {
+      method: "GET",
+      headers: {
+        Authorization: `Key ${apiKey}`,
+      },
+      signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+    });
+
+    if (!statusResponse.ok) {
+      const errorText = await statusResponse.text();
+      if (statusResponse.status === 404) {
+        await wait(POLL_INTERVAL_MS);
+        continue;
+      }
+      throw new Error(
+        `FAL status error [${statusResponse.status}]: ${errorText}`,
+      );
+    }
+
+    const statusJson = (await statusResponse.json()) as {
+      status?: string;
+      status_url?: string;
+      response_url?: string;
+      error?: unknown;
+    };
+
+    if (statusJson.status_url) currentStatusUrl = statusJson.status_url;
+    if (statusJson.response_url) currentResponseUrl = statusJson.response_url;
+
+    if (context?.reportProgress) {
+      const elapsed = Date.now() - startTime;
+      const progress = Math.min(
+        Math.round((elapsed / MAX_POLL_TIME_MS) * 100),
+        99,
+      );
+      await context.reportProgress({ progress, total: 100 });
+    }
+
+    if (context?.streamContent && pollCount % 5 === 0) {
+      await context.streamContent({
+        type: "text" as const,
+        text: `[Mixio] FAL request still running... (${Math.round((Date.now() - startTime) / 1000)}s elapsed, status: ${statusJson.status ?? "UNKNOWN"})`,
+      });
+    }
+
+    if (statusJson.status === "COMPLETED") {
+      const resultResponse = await fetch(currentResponseUrl, {
+        method: "GET",
+        headers: {
+          Authorization: `Key ${apiKey}`,
+        },
+        signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+      });
+
+      if (!resultResponse.ok) {
+        const errorText = await resultResponse.text();
+        throw new Error(
+          `FAL result error [${resultResponse.status}]: ${errorText}`,
+        );
+      }
+
+      if (context?.reportProgress) {
+        await context.reportProgress({ progress: 100, total: 100 });
+      }
+
+      return resultResponse.json();
+    }
+
+    if (statusJson.status === "FAILED") {
+      throw new Error(
+        `FAL generation failed: ${JSON.stringify(statusJson.error || statusJson)}`,
+      );
+    }
+
+    await wait(POLL_INTERVAL_MS);
+  }
+
+  throw new Error(
+    "FAL generation timed out. Please retry the request with a shorter prompt.",
+  );
+}
 
 export const mixioMultiAngle = {
   name: "mixio_multi_angle",
   description:
-    "Precise 3D-like camera control for image editing using Qwen-Image-Edit-2511. " +
-    "Use this for steering azimuth, elevation, and distance of the camera relative to the subject." +
-    "\n\n**Prompt Format**: [azimuth] [elevation] [distance] [instruction]" +
-    "\n- **Azimuth**: front view, front-right, right, back-right, back, back-left, left, front-left." +
-    "\n- **Elevation**: high-angle shot, eye-level shot, low-angle shot, bird-view, worm-view." +
-    "\n- **Distance**: extreme wide shot, wide shot, medium shot, close up, macro shot." +
-    "\n\nExample: 'front view eye-level shot medium shot turn the car red'",
+    "多角度镜头控制（Qwen-Image-Edit-2509 + dx8152/Qwen-Edit-2509-Multiple-angles LoRA）。" +
+    "\n\n请直接用中文描述用户意图，不再使用 azimuth/elevation/zoom 枚举。" +
+    "\n\n**推荐提示词格式（中文）**：" +
+    "\n1) 镜头动作（移动/旋转/俯视/特写等）" +
+    "\n2) 保持不变的主体信息（人物、服装、场景）" +
+    "\n3) 构图约束（如居中、近景、广角）" +
+    "\n\n**示例 Prompt**：" +
+    "\n- 将镜头向左旋转45度，保持人物身份、发型和服装不变。" +
+    "\n- 将镜头转为俯视角度，主体保持画面中心，场景与光照风格不变。" +
+    "\n- 将镜头转为特写镜头并轻微前移，突出面部细节，整体色调保持一致。",
   parameters: z.object({
     image_path: z
       .string()
       .describe("Absolute local path or URL to the base image."),
-    azimuth: azimuthEnum
-      .describe("Horizontal angle (e.g., 'front view', 'right side view')."),
-    elevation: elevationEnum
-      .describe("Vertical angle (e.g., 'eye-level shot', 'high-angle shot')."),
-    distance: distanceEnum
-      .describe("Camera distance or zoom (e.g., 'medium shot', 'wide shot')."),
+    prompt: z
+      .string()
+      .describe(
+        "请用中文描述镜头变化与编辑意图。例如：将镜头向左旋转45度，保持人物和服装不变。",
+      ),
     negative_prompt: z
       .string()
       .optional()
       .default("")
       .describe("Elements to avoid."),
+    lora_scale: z
+      .number()
+      .min(0)
+      .max(4)
+      .optional()
+      .default(DEFAULT_LORA_SCALE)
+      .describe("LoRA weight scale for the multi-angle adapter (0 to 4)."),
     seed: z.number().optional().default(42).describe("Random seed."),
     output_path: z.string().describe("Local path to save the resulting PNG."),
   }),
@@ -65,10 +307,9 @@ export const mixioMultiAngle = {
   async execute(
     args: {
       image_path: string;
-      azimuth: string;
-      elevation: string;
-      distance: string;
+      prompt: string;
       negative_prompt?: string;
+      lora_scale?: number;
       seed?: number;
       output_path: string;
     },
@@ -76,41 +317,77 @@ export const mixioMultiAngle = {
   ) {
     return safeToolExecute(
       async () => {
-        const formData = new FormData();
-        await appendImageToFormData(formData, "image", args.image_path);
+        const apiKey = getApiKey();
+
+        if (context?.streamContent) {
+          await context.streamContent({
+            type: "text" as const,
+            text: "[Mixio] Preparing image for FAL Qwen multi-angle edit...",
+          });
+        }
 
-        const promptParts = [args.azimuth, args.elevation, args.distance];
-        const finalPrompt = promptParts.join(" ").trim();
+        const imageUrl = await uploadImageToFalCdn(args.image_path, apiKey);
 
-        formData.append("prompt", finalPrompt);
-        formData.append("lora_type", "multi_angle");
-        formData.append("negative_prompt", args.negative_prompt || "");
-        formData.append("seed", (args.seed ?? 42).toString());
+        const payload = {
+          prompt: args.prompt.trim(),
+          image_urls: [imageUrl],
+          negative_prompt: args.negative_prompt || " ",
+          seed: args.seed ?? 42,
+          output_format: "png",
+          loras: [
+            {
+              path: QWEN_MULTI_ANGLE_LORA_PATH,
+              scale: args.lora_scale ?? DEFAULT_LORA_SCALE,
+            },
+          ],
+        };
 
         if (context?.streamContent) {
           await context.streamContent({
             type: "text" as const,
-            text: `[Mixio] Submitting Multi-Angle edit request...`,
+            text: "[Mixio] Submitting Qwen multi-angle request to FAL...",
           });
         }
 
-        const response = await fetch(MIXIO_IMAGE_EDIT_URL, {
-          method: "POST",
-          body: formData,
-        });
+        const { requestId, statusUrl, responseUrl } =
+          await submitQwenMultiAngleRequest(payload, apiKey);
+
+        const finalResult = await waitForQwenMultiAngleResult(
+          statusUrl,
+          responseUrl,
+          apiKey,
+          context,
+        );
+
+        const resultImageUrl =
+          finalResult?.images?.[0]?.url ||
+          finalResult?.image?.url ||
+          finalResult?.data?.url ||
+          finalResult?.url;
 
-        if (!response.ok) {
-          const errorText = await response.text();
-          throw new Error(`Mixio API error [${response.status}]: ${errorText}`);
+        if (!resultImageUrl) {
+          throw new Error(
+            `FAL response did not contain an output image URL: ${JSON.stringify(finalResult)}`,
+          );
         }
 
-        const result = await handleMixioResponse(response, args.output_path);
+        const saved = await saveMixioImage(
+          resultImageUrl,
+          args.output_path,
+          "mixio_multi_angle.png",
+        );
 
         return JSON.stringify({
           status: "COMPLETED",
           message: "Multi-angle edit completed.",
-          ...result,
+          ...saved,
           seed: args.seed ?? 42,
+          request_id: requestId,
+          model_id: QWEN_MULTI_ANGLE_MODEL_ID,
+          lora: {
+            path: QWEN_MULTI_ANGLE_LORA_PATH,
+            scale: args.lora_scale ?? DEFAULT_LORA_SCALE,
+          },
         });
       },
       "mixioMultiAngle",