bizydraft 0.2.31__py3-none-any.whl → 0.2.78.dev20251117024007__py3-none-any.whl

bizydraft/patch_handlers.py

@@ -3,10 +3,12 @@ import math
 import mimetypes
 import os
 import uuid
+from io import BytesIO
 from urllib.parse import unquote
 
 from aiohttp import ClientSession, ClientTimeout, web
 from loguru import logger
+from PIL import Image
 
 try:
     import execution
@@ -29,6 +31,7 @@ BIZYDRAFT_CHUNK_SIZE = int(os.getenv("BIZYDRAFT_CHUNK_SIZE", 1024 * 16))  # 16KB
 
 
 async def view_image(request):
+
     logger.debug(f"Received request for /view with query: {request.rel_url.query}")
     if "filename" not in request.rel_url.query:
         logger.warning("'filename' not provided in query string, returning 404")
@@ -36,6 +39,8 @@ async def view_image(request):
 
     filename = request.rel_url.query["filename"]
     subfolder = request.rel_url.query.get("subfolder", "")
+    channel = request.rel_url.query.get("channel", "rgba")
+    preview = request.rel_url.query.get("preview", None)
 
     http_prefix_options = ("http:", "https:")
 
@@ -51,20 +56,35 @@ async def view_image(request):
         if "http" in subfolder:
             subfolder = subfolder[subfolder.find("http") :]
         subfolder = unquote(subfolder)
-        filename = (
+        if "https:/" in subfolder and not subfolder.startswith("https://"):
+            subfolder = subfolder.replace("https:/", "https://", 1)
+        if "http:/" in subfolder and not subfolder.startswith("http://"):
+            subfolder = subfolder.replace("http:/", "http://", 1)
+
+        # 构建完整URL
+        full_url = (
             f"{subfolder}/{filename}"
             if not filename.startswith(http_prefix_options)
             else filename
-        )  # preview 3d request: https://host:port/api/view?filename=filename.glb&type=output&subfolder=https://bizyair-dev.oss-cn-shanghai.aliyuncs.com/outputs&rand=0.5763957215362988
+        )
 
-        content_type, _ = mimetypes.guess_type(filename)
-        if content_type and any(x in content_type for x in ("image", "video")):
-            return web.HTTPFound(filename)
+        # 获取原始文件名用于响应头
+        original_filename = filename.split("/")[-1] if "/" in filename else filename
+
+        content_type, _ = mimetypes.guess_type(full_url)
 
         timeout = ClientTimeout(total=BIZYDRAFT_REQUEST_TIMEOUT)
         async with ClientSession(timeout=timeout) as session:
-            async with session.get(filename) as resp:
+            async with session.get(full_url) as resp:
                 resp.raise_for_status()
+
+                # 优先使用服务器返回的Content-Type，如果无法获取则使用猜测的类型
+                final_content_type = (
+                    resp.headers.get("Content-Type")
+                    or content_type
+                    or "application/octet-stream"
+                )
+
                 content_length = int(resp.headers.get("Content-Length", 0))
                 if content_length > BIZYDRAFT_MAX_FILE_SIZE:
                     logger.warning(
@@ -75,9 +95,99 @@ async def view_image(request):
                         text=f"File size exceeds limit ({human_readable_size(BIZYDRAFT_MAX_FILE_SIZE)})",
                     )
 
+                # 检查是否需要图像处理（preview或channel参数）
+                is_image = final_content_type and final_content_type.startswith(
+                    "image/"
+                )
+                needs_processing = is_image and (
+                    preview is not None or channel != "rgba"
+                )
+
+                if needs_processing:
+                    logger.debug(f"Image processing requested: {channel=}, {preview=}")
+                    # 下载完整图像到内存
+                    image_data = await resp.read()
+
+                    # 检查实际大小
+                    if len(image_data) > BIZYDRAFT_MAX_FILE_SIZE:
+                        return web.Response(
+                            status=413,
+                            text=f"File size exceeds limit ({human_readable_size(BIZYDRAFT_MAX_FILE_SIZE)})",
+                        )
+
+                    # 使用PIL处理图像
+                    with Image.open(BytesIO(image_data)) as img:
+                        # 处理preview参数
+                        if preview is not None:
+                            preview_info = preview.split(";")
+                            image_format = preview_info[0]
+                            if image_format not in ["webp", "jpeg"] or "a" in channel:
+                                image_format = "webp"
+                            quality = 90
+                            if preview_info[-1].isdigit():
+                                quality = int(preview_info[-1])
+
+                            buffer = BytesIO()
+                            if image_format in ["jpeg"] or channel == "rgb":
+                                img = img.convert("RGB")
+                            img.save(buffer, format=image_format, quality=quality)
+                            buffer.seek(0)
+
+                            return web.Response(
+                                body=buffer.read(),
+                                content_type=f"image/{image_format}",
+                                headers={
+                                    "Content-Disposition": f'filename="{original_filename}"'
+                                },
+                            )
+
+                        # 处理channel参数
+                        if channel == "rgb":
+                            logger.debug("Converting image to RGB (removing alpha)")
+                            if img.mode == "RGBA":
+                                r, g, b, a = img.split()
+                                new_img = Image.merge("RGB", (r, g, b))
+                            else:
+                                new_img = img.convert("RGB")
+
+                            buffer = BytesIO()
+                            new_img.save(buffer, format="PNG")
+                            buffer.seek(0)
+
+                            return web.Response(
+                                body=buffer.read(),
+                                content_type="image/png",
+                                headers={
+                                    "Content-Disposition": f'filename="{original_filename}"'
+                                },
+                            )
+
+                        elif channel == "a":
+                            logger.debug("Extracting alpha channel only")
+                            if img.mode == "RGBA":
+                                _, _, _, a = img.split()
+                            else:
+                                a = Image.new("L", img.size, 255)
+
+                            # 创建alpha通道图像
+                            alpha_img = Image.new("RGBA", img.size)
+                            alpha_img.putalpha(a)
+                            alpha_buffer = BytesIO()
+                            alpha_img.save(alpha_buffer, format="PNG")
+                            alpha_buffer.seek(0)
+
+                            return web.Response(
+                                body=alpha_buffer.read(),
+                                content_type="image/png",
+                                headers={
+                                    "Content-Disposition": f'filename="{original_filename}"'
+                                },
+                            )
+
+                # 默认流式传输（无需处理或非图像文件）
                 headers = {
-                    "Content-Disposition": f'attachment; filename="{uuid.uuid4()}"',
-                    "Content-Type": "application/octet-stream",
+                    "Content-Disposition": f'attachment; filename="{original_filename}"',
+                    "Content-Type": final_content_type,
                 }
 
                 proxy_response = web.StreamResponse(headers=headers)
@@ -102,6 +212,7 @@ async def view_image(request):
             text=f"Request timed out (max {BIZYDRAFT_REQUEST_TIMEOUT//60} minutes)",
         )
     except Exception as e:
+        logger.error(f"Error in view_image: {str(e)}", exc_info=True)
         return web.Response(
             status=502, text=f"Failed to fetch remote resource: {str(e)}"
         )
@@ -117,6 +228,84 @@ def human_readable_size(size_bytes):
     return f"{s} {size_name[i]}"
 
 
+async def view_video(request):
+    """处理VHS插件的viewvideo接口，支持从OSS URL加载视频"""
+    logger.debug(
+        f"Received request for /vhs/viewvideo with query: {request.rel_url.query}"
+    )
+
+    if "filename" not in request.rel_url.query:
+        logger.warning("'filename' not provided in query string, returning 404")
+        return web.Response(status=404, text="'filename' not provided in query string")
+
+    # VHS插件的filename参数本身就是完整的URL（可能是URL编码的）
+    filename = unquote(request.rel_url.query["filename"])
+
+    http_prefix_options = ("http:", "https:")
+
+    if not filename.startswith(http_prefix_options):
+        logger.warning(f"Invalid filename format: {filename=}, only URLs are supported")
+        return web.Response(
+            status=400, text="Invalid filename format(only url supported)"
+        )
+
+    try:
+        content_type, _ = mimetypes.guess_type(filename)
+
+        timeout = ClientTimeout(total=BIZYDRAFT_REQUEST_TIMEOUT)
+        async with ClientSession(timeout=timeout) as session:
+            async with session.get(filename) as resp:
+                resp.raise_for_status()
+
+                # 优先使用服务器返回的Content-Type
+                final_content_type = (
+                    resp.headers.get("Content-Type")
+                    or content_type
+                    or "application/octet-stream"
+                )
+
+                content_length = int(resp.headers.get("Content-Length", 0))
+                if content_length > BIZYDRAFT_MAX_FILE_SIZE:
+                    logger.warning(
+                        f"File size {human_readable_size(content_length)} exceeds limit {human_readable_size(BIZYDRAFT_MAX_FILE_SIZE)}"
+                    )
+                    return web.Response(
+                        status=413,
+                        text=f"File size exceeds limit ({human_readable_size(BIZYDRAFT_MAX_FILE_SIZE)})",
+                    )
+
+                headers = {
+                    "Content-Disposition": f'attachment; filename="{uuid.uuid4()}"',
+                    "Content-Type": final_content_type,
+                }
+
+                proxy_response = web.StreamResponse(headers=headers)
+                await proxy_response.prepare(request)
+
+                total_bytes = 0
+                async for chunk in resp.content.iter_chunked(BIZYDRAFT_CHUNK_SIZE):
+                    total_bytes += len(chunk)
+                    if total_bytes > BIZYDRAFT_MAX_FILE_SIZE:
+                        await proxy_response.write(b"")
+                        return web.Response(
+                            status=413,
+                            text=f"File size exceeds limit during streaming ({human_readable_size(BIZYDRAFT_MAX_FILE_SIZE)})",
+                        )
+                    await proxy_response.write(chunk)
+
+                return proxy_response
+
+    except asyncio.TimeoutError:
+        return web.Response(
+            status=504,
+            text=f"Request timed out (max {BIZYDRAFT_REQUEST_TIMEOUT//60} minutes)",
+        )
+    except Exception as e:
+        return web.Response(
+            status=502, text=f"Failed to fetch remote resource: {str(e)}"
+        )
+
+
 async def post_prompt(request):
     json_data = await request.json()
 

bizydraft/static/js/aiAppHandler.js

@@ -1,8 +1,8 @@
 import { app } from "../../scripts/app.js";
-import { setNodeParams, filterNodeWidgets, isConfigurableNode } from "./nodeParamsFilter.js";
+import { setNodeParams } from "./nodeParamsFilter.js";
 import { processGraphOutput } from './tool.js';
-import { focusNodeOnly, setGlobalReferences, setupCanvasClickHandler, removeCanvasClickHandler } from './nodeFocusHandler.js';
-import { freezeWorkflow, unfreezeWorkflow, updateHighlightedNodes } from './freezeModeHandler.js';
+import { freezeWorkflow, unfreezeWorkflow } from './freezeModeHandler.js';
+import { parseWorkflowIO } from './workflow_io.js';
 // 状态变量
 let selectedInputNodes = [];
 let activeMode = null; // 当前活动的模式: "aiapp" 或 "export"
@@ -39,14 +39,8 @@ function toggleMode(mode, enable, isworkflow = false) {
                     }
                 };
                 try {
-                    const response = await fetch('/bizyair/workflow_io', {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        body: JSON.stringify(formattedData)
-                    });
-                    const responseData = await response.json();
+                    // 使用前端workflow_io模块处理数据
+                    const responseData = parseWorkflowIO(formattedData);
 
                     // 保存节点参数信息
                     if (responseData && responseData.data && Array.isArray(responseData.data.inputs)) {
@@ -456,7 +450,7 @@ window.addEventListener('message', function(event) {
                         {};
 
                     // 直接使用 widget.value，这是截图中显示蓝色高亮的值
-                    const widgetValue = widget.value || "";
+                    const widgetValue = widget.value ?? "";
                     // 创建一个新的简化widget对象，只包含我们实际需要的属性
                     // 确保只使用可序列化的属性
                     let safeWidgetValue = "";
@@ -464,6 +458,9 @@ window.addEventListener('message', function(event) {
                         // 测试是否可序列化
                         JSON.stringify({value: widgetValue});
                         safeWidgetValue = widgetValue;
+                        if (typeof safeWidgetValue === 'string') {
+                            safeWidgetValue = safeWidgetValue.replace(/pasted\/http/g, 'http');
+                        }
                     } catch (e) {
                         console.error('[aiAppHandler] 值不可序列化:', e);
                         // 使用安全的字符串值
@@ -476,6 +473,7 @@ window.addEventListener('message', function(event) {
                         type: widget.type || "string",
                         options: safeOptions,
                         displayName: widget.displayName || widget.label || widget.name || "",
+                        tooltip: widget.tooltip || "", // 添加 tooltip 字段
                         node_title: node.title || "",
                         node_type: node.type || "",
                         node_comfyClass: node.comfyClass || ""
@@ -499,6 +497,7 @@ window.addEventListener('message', function(event) {
                 type: widget.type || "string",
                 options: widget.options || {},
                 displayName: widget.displayName || "",
+                tooltip: widget.tooltip || "", // 添加 tooltip 字段
                 node_title: widget.node_title || "",
                 node_type: widget.node_type || "",
                 node_comfyClass: widget.node_comfyClass || ""

bizydraft/static/js/clipspaceToOss.js

@@ -0,0 +1,316 @@
+import { app } from "../../scripts/app.js";
+import { api } from "../../scripts/api.js";
+
+window.CLIPSPACE_TO_OSS_MAP = window.CLIPSPACE_TO_OSS_MAP || {};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 工具函数：查找 clipspace 文件名对应的 OSS URL
+// ═══════════════════════════════════════════════════════════════════════════
+function findOssUrl(filename) {
+    return window.CLIPSPACE_TO_OSS_MAP[filename]
+        || window.CLIPSPACE_TO_OSS_MAP[`${filename} [input]`]
+        || window.CLIPSPACE_TO_OSS_MAP[`${filename} [output]`];
+}
+
+// 去掉末尾的 " [input]" 或 " [output]" 后缀
+function stripTypeSuffix(value) {
+    if (!value || typeof value !== 'string') return value;
+    return value.replace(/\s\[(input|output)\]$/i, '');
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// 工具函数：替换 clipspace URL 为 OSS URL
+// ═══════════════════════════════════════════════════════════════════════════
+function replaceClipspaceUrl(urlString) {
+    if (!urlString || typeof urlString !== 'string') return urlString;
+    if (!urlString.includes('/view?') || !urlString.includes('clipspace')) return urlString;
+
+    try {
+        const url = new URL(urlString, window.location.origin);
+        const filename = url.searchParams.get('filename');
+        const subfolder = url.searchParams.get('subfolder');
+
+        if (subfolder === 'clipspace' && filename) {
+            const ossUrl = findOssUrl(filename);
+            if (ossUrl) {
+                url.searchParams.set('filename', ossUrl);
+                url.searchParams.set('subfolder', '');
+                return url.pathname + url.search;
+            }
+        }
+    } catch (e) {
+        console.error('[BizyDraft] Error replacing clipspace URL:', e);
+    }
+
+    return urlString;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 拦截图片加载请求，将 clipspace URL 替换为 OSS URL
+// ═══════════════════════════════════════════════════════════════════════════
+(function interceptImageLoading() {
+    const originalSrcDescriptor = Object.getOwnPropertyDescriptor(Image.prototype, 'src');
+
+    Object.defineProperty(Image.prototype, 'src', {
+        get() {
+            return originalSrcDescriptor.get.call(this);
+        },
+        set(value) {
+            const modifiedValue = replaceClipspaceUrl(value);
+            originalSrcDescriptor.set.call(this, modifiedValue);
+        },
+        configurable: true
+    });
+
+    const originalSetAttribute = HTMLImageElement.prototype.setAttribute;
+    HTMLImageElement.prototype.setAttribute = function(name, value) {
+        if (name === 'src') {
+            const modifiedValue = replaceClipspaceUrl(value);
+            return originalSetAttribute.call(this, name, modifiedValue);
+        }
+        return originalSetAttribute.call(this, name, value);
+    };
+})();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 拦截上传响应，保存映射并篡改返回值
+// ═══════════════════════════════════════════════════════════════════════════
+const originalFetchApi = api.fetchApi;
+api.fetchApi = async function(url, options) {
+    const response = await originalFetchApi.call(this, url, options);
+
+    const isUploadApi = url === '/upload/image' || url === '/upload/mask'
+                     || url === '/api/upload/image' || url === '/api/upload/mask';
+
+    if (!isUploadApi || !response.ok) {
+        return response;
+    }
+    try {
+        const data = await response.clone().json();
+
+        // 检查是否是 OSS 上传响应
+        const isOssUpload = data.subfolder?.includes('http://') || data.subfolder?.includes('https://')
+                         || data.name?.startsWith('http://') || data.name?.startsWith('https://');
+
+        if (!isOssUpload) return response;
+
+        // 构造完整的 OSS URL
+        const ossUrl = data.subfolder?.includes('http')
+            ? `${data.subfolder}/${data.name}`
+            : data.name;
+
+        // 处理映射逻辑
+        let finalUrl = ossUrl;
+
+        if (options?.body instanceof FormData) {
+            const imageFile = options.body.get('image');
+            if (imageFile?.name) {
+                const filename = imageFile.name;
+                const idMatch = filename.match(/(\d+)/);
+                const baseId = idMatch?.[1];
+
+                // 第一次 /upload/mask 的结果是涂改后的完整图片
+                if (baseId && url.includes('/upload/mask')) {
+                    const firstMaskKey = `__FIRST_MASK_${baseId}__`;
+
+                    if (!window.CLIPSPACE_TO_OSS_MAP[firstMaskKey]) {
+                        // 首次 mask 上传，保存到所有变体
+                        window.CLIPSPACE_TO_OSS_MAP[firstMaskKey] = ossUrl;
+                        finalUrl = ossUrl;
+
+                        [`clipspace-mask-${baseId}.png`, `clipspace-paint-${baseId}.png`,
+                         `clipspace-painted-${baseId}.png`, `clipspace-painted-masked-${baseId}.png`
+                        ].forEach(v => window.CLIPSPACE_TO_OSS_MAP[v] = ossUrl);
+
+                    } else {
+                        // 后续 mask 上传，使用首次的 URL
+                        finalUrl = window.CLIPSPACE_TO_OSS_MAP[firstMaskKey];
+                    }
+                } else if (baseId) {
+                    // /upload/image 的上传，如果已有 mask 则使用 mask 的 URL
+                    const firstMaskUrl = window.CLIPSPACE_TO_OSS_MAP[`__FIRST_MASK_${baseId}__`];
+                    if (firstMaskUrl) {
+                        finalUrl = firstMaskUrl;
+                    }
+                }
+
+                // 保存映射
+                [filename, `${filename} [input]`, `${filename} [output]`].forEach(key => {
+                    window.CLIPSPACE_TO_OSS_MAP[key] = finalUrl;
+                });
+
+                const filenameWithoutSuffix = filename.replace(/ \[(input|output)\]$/, '');
+                if (filenameWithoutSuffix !== filename) {
+                    window.CLIPSPACE_TO_OSS_MAP[filenameWithoutSuffix] = finalUrl;
+                }
+
+            }
+        }
+
+        // 同时保存后端返回的文件名映射
+        window.CLIPSPACE_TO_OSS_MAP[data.name] = finalUrl;
+
+        // 🔧 修改 ComfyApp.clipspace，让它使用 OSS URL 而不是 clipspace 路径
+        if (window.app?.constructor?.clipspace) {
+            const clipspace = window.app.constructor.clipspace;
+
+            // 修改 clipspace.images
+            if (clipspace.images && clipspace.images.length > 0) {
+                const clipImage = clipspace.images[clipspace.selectedIndex || 0];
+                if (clipImage && clipImage.subfolder === 'clipspace') {
+                    clipspace.images[clipspace.selectedIndex || 0] = {
+                        filename: finalUrl,
+                        subfolder: ''
+                    };
+                }
+            }
+
+            // 修改 clipspace.widgets
+            if (clipspace.widgets) {
+                const imageWidgetIndex = clipspace.widgets.findIndex(w => w.name === 'image');
+                if (imageWidgetIndex >= 0) {
+                    const widgetValue = clipspace.widgets[imageWidgetIndex].value;
+                    if (widgetValue && typeof widgetValue === 'object' && widgetValue.subfolder === 'clipspace') {
+                        clipspace.widgets[imageWidgetIndex].value = {
+                            filename: finalUrl,
+                            subfolder: ''
+                        };
+                    }
+                }
+            }
+        }
+
+        // 篡改响应，让 ComfyUI 使用完整的 OSS URL
+        const modifiedData = { ...data, name: finalUrl, subfolder: '' };
+        return new Response(JSON.stringify(modifiedData), {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+
+    } catch (e) {
+        console.error('[BizyDraft Upload] Error:', e);
+        return response;
+    }
+};
+
+// 转换 prompt 中的 clipspace 路径为 OSS URL
+function convertClipspacePathsInPrompt(prompt) {
+    if (!prompt || typeof prompt !== 'object') {
+        return prompt;
+    }
+
+    for (const [nodeId, node] of Object.entries(prompt)) {
+        if (!node?.inputs) continue;
+
+        for (const [inputKey, inputValue] of Object.entries(node.inputs)) {
+            if (typeof inputValue === 'string' && inputValue.includes('clipspace')) {
+                const match = inputValue.match(/clipspace\/([\w-]+\.(?:png|jpg|jpeg|webp|gif))/i);
+                if (match) {
+                    const filename = match[1];
+                    const ossUrl = findOssUrl(filename);
+
+                    if (ossUrl) {
+                        node.inputs[inputKey] = ossUrl;
+
+                        if (inputKey === 'image' && node.inputs['image_name']) {
+                            node.inputs['image_name'] = ossUrl.split('/').pop();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return prompt;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 拦截 pasteFromClipspace，确保 widget.value 使用 OSS URL
+// ═══════════════════════════════════════════════════════════════════════════
+function interceptPasteFromClipspace() {
+    const ComfyApp = window.app?.constructor;
+    if (!ComfyApp || !ComfyApp.pasteFromClipspace) return;
+
+    const originalPasteFromClipspace = ComfyApp.pasteFromClipspace;
+    ComfyApp.pasteFromClipspace = function(node) {
+        // 调用原始函数
+        originalPasteFromClipspace.call(this, node);
+
+        // 修正 widget.value
+        if (node.widgets) {
+            const imageWidget = node.widgets.find(w => w.name === 'image');
+            if (imageWidget && typeof imageWidget.value === 'string') {
+                const value = imageWidget.value;
+
+                // 1) 如果是 clipspace 路径格式，替换为 OSS URL
+                if (value.includes('clipspace/')) {
+                    // 提取文件名
+                    const match = value.match(/clipspace\/([\w-]+\.(?:png|jpg|jpeg|webp|gif))(\s\[(input|output)\])?/i);
+                    if (match) {
+                        const filename = match[1];
+                        const ossUrl = findOssUrl(filename);
+
+                        if (ossUrl) {
+                            imageWidget.value = ossUrl;
+                        }
+                    }
+                }
+                // 2) 如果是 "https://... [input]" 这样的字符串，移除后缀
+                else if (/https?:\/\/.*\.(png|jpg|jpeg|webp|gif)\s\[(input|output)\]$/i.test(value)) {
+                    const cleaned = stripTypeSuffix(value);
+                    if (cleaned !== value) {
+                        imageWidget.value = cleaned;
+                    }
+                }
+            }
+        }
+    };
+}
+// 注册 ComfyUI 扩展
+app.registerExtension({
+    name: "bizyair.clipspace.to.oss",
+
+    async setup() {
+        const originalGraphToPrompt = app.graphToPrompt;
+
+        // 在构建 Prompt 之前，先清理所有 widget 的值，去掉多余的后缀
+        function sanitizeGraphWidgets(graph) {
+            const nodes = graph?._nodes || [];
+            for (const node of nodes) {
+                if (!node?.widgets) continue;
+                for (const widget of node.widgets) {
+                    if (typeof widget?.value === 'string') {
+                        widget.value = stripTypeSuffix(widget.value);
+                    }
+                }
+            }
+        }
+
+        app.graphToPrompt = async function(...args) {
+            // 预清理，避免 workflow.widgets_values 和 prompt 输入里包含 [input]/[output]
+            try { sanitizeGraphWidgets(app.graph); } catch (e) {}
+
+            const result = await originalGraphToPrompt.apply(this, args);
+
+            if (result?.output) {
+                // 二次清理并转换 clipspace
+                const cleaned = convertClipspacePathsInPrompt(result.output);
+                // 额外移除任何字符串输入中的类型后缀
+                for (const nodeId of Object.keys(cleaned || {})) {
+                    const node = cleaned[nodeId];
+                    if (!node?.inputs) continue;
+                    for (const key of Object.keys(node.inputs)) {
+                        const v = node.inputs[key];
+                        node.inputs[key] = typeof v === 'string' ? stripTypeSuffix(v) : v;
+                    }
+                }
+                result.output = cleaned;
+            }
+
+            return result;
+        };
+
+        // 拦截 pasteFromClipspace
+        interceptPasteFromClipspace();
+    }
+});