intention-coding 0.6.9 → 0.7.0

package/dist/index.cjs

@@ -1084,6 +1084,11 @@ var __webpack_modules__ = {
             return module;
         });
     },
+    https: function(module) {
+        module.exports = import("https").then(function(module) {
+            return module;
+        });
+    },
     "path?5fdd": function(module) {
         module.exports = import("path").then(function(module) {
             return module;
@@ -1093,6 +1098,11 @@ var __webpack_modules__ = {
         module.exports = import("pdf-parse/lib/pdf-parse.js").then(function(module) {
             return module;
         });
+    },
+    undici: function(module) {
+        module.exports = import("undici").then(function(module) {
+            return module;
+        });
     }
 };
 var __webpack_module_cache__ = {};
@@ -6116,7 +6126,8 @@ ${logic}` : ""}`;
         kimiConfig = {
             apiKey: "sk-fp8wJSigZBEP3x8y6MAZWGPuVIHJ5PDZtX9lMQQk8hjP2R0u",
             baseUrl: "https://api.moonshot.cn/v1/chat/completions",
-            model: "kimi-k2-0905-preview"
+            model: "kimi-k2-0905-preview",
+            visionModel: "moonshot-v1-128k-vision-preview"
         };
         glm4vConfig = {
             apiKey: "fb26a7ff758c3974e43bfff49a684dd3.apcuRq6v6RvwuJDu",
@@ -6132,6 +6143,12 @@ ${logic}` : ""}`;
             apiKey: "app-AvlLh0nfN4l9oz1MSW4sEAQ6",
             baseUrl: "http://11.0.166.20:9199/v1"
         };
+        internalConfig = {
+            apiKey: "sk-3W5NXAzeXX9mNP5yppQwPt6cnEoSK03u5NgiNW1Hsi41Tniu",
+            baseUrl: "https://aiproxy.jla.petrotech.cnpc/v1/chat/completions",
+            visionModel: "qwen2-7b-vl",
+            ocrModel: "deepseek-ocr"
+        };
         constructor(){}
         async generateText(params) {
             const { prompt, temperature, system_prompt } = params;
@@ -6517,7 +6534,7 @@ ${logic}` : ""}`;
             }
             const image_base64 = `data:${mimeType};base64,${base64}`;
             try {
-                logger.k.info("[OpenAI] \u5C1D\u8BD5\u4F7F\u7528 Kimi \u8FDB\u884C\u56FE\u50CF\u8BC6\u522B");
+                logger.k.info("[OpenAI] \u5C1D\u8BD5\u4F7F\u7528 Kimi Vision \u8FDB\u884C\u56FE\u50CF\u8BC6\u522B");
                 const controller = new AbortController();
                 const timeoutId = setTimeout(()=>controller.abort(), 30000);
                 const response = await fetch(this.kimiConfig.baseUrl, {
@@ -6527,17 +6544,12 @@ ${logic}` : ""}`;
                         Authorization: `Bearer ${this.kimiConfig.apiKey}`
                     },
                     body: JSON.stringify({
-                        model: this.kimiConfig.model,
+                        model: this.kimiConfig.visionModel,
                         messages: [
                             ...system_prompt ? [
                                 {
                                     role: "system",
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: system_prompt
-                                        }
-                                    ]
+                                    content: system_prompt
                                 }
                             ] : [],
                             {
@@ -6558,7 +6570,10 @@ ${logic}` : ""}`;
                         ],
                         stream: false,
                         temperature,
-                        max_tokens
+                        max_tokens,
+                        stop: [
+                            "<<<END>>>"
+                        ]
                     }),
                     signal: controller.signal
                 });
@@ -6569,103 +6584,103 @@ ${logic}` : ""}`;
                 }
                 const data = await response.json();
                 if (!data.choices || 0 === data.choices.length) throw new Error("No choices returned from Kimi Vision API");
-                logger.k.info("[OpenAI] Kimi \u56FE\u50CF\u8BC6\u522B\u6210\u529F");
+                logger.k.info("[OpenAI] Kimi Vision \u56FE\u50CF\u8BC6\u522B\u6210\u529F");
                 return data.choices[0].message.content;
             } catch (kimiError) {
-                logger.k.error("[OpenAI] Kimi \u8C03\u7528\u5931\u8D25\uFF0C\u56DE\u9000\u5230 Dify", {
+                logger.k.error("[OpenAI] Kimi Vision \u8C03\u7528\u5931\u8D25\uFF0C\u56DE\u9000\u5230 GLM-4V", {
                     error: kimiError instanceof Error ? kimiError.message : String(kimiError)
                 });
                 try {
-                    logger.k.info("[OpenAI] \u5C1D\u8BD5\u4F7F\u7528 Dify \u5DE5\u4F5C\u6D41");
-                    const uploadResult = await uploadFile({
-                        appid: this.difyConfig.apiKey,
-                        filePath: image_path,
-                        user: "aico-mcp"
-                    });
-                    logger.k.info("[OpenAI] \u6587\u4EF6\u4E0A\u4F20\u6210\u529F", {
-                        upload_file_id: uploadResult.id
-                    });
-                    const workflowData = {
-                        imagePath: {
-                            type: "image",
-                            transfer_method: "local_file",
-                            upload_file_id: uploadResult.id
+                    logger.k.info("[OpenAI] \u5C1D\u8BD5\u4F7F\u7528 GLM-4V \u8FDB\u884C\u56FE\u50CF\u8BC6\u522B");
+                    const controller = new AbortController();
+                    const timeoutId = setTimeout(()=>controller.abort(), 30000);
+                    const response = await fetch(this.glm4vConfig.baseUrl, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            Authorization: `Bearer ${this.glm4vConfig.apiKey}`
                         },
-                        context: prompt
-                    };
-                    const workflowResponse = await invokeFlow({
-                        appid: this.difyConfig.apiKey,
-                        data: workflowData,
-                        timeout: 120000
-                    });
-                    let summary = "";
-                    if ("string" == typeof workflowResponse && workflowResponse.length > 0) summary = workflowResponse;
-                    else if (workflowResponse?.outputs?.text) summary = workflowResponse.outputs.text;
-                    else if (workflowResponse?.data?.outputs?.text) summary = workflowResponse.data.outputs.text;
-                    else if (workflowResponse?.data?.text) summary = workflowResponse.data.text;
-                    else if (workflowResponse?.answer) summary = workflowResponse.answer;
-                    else if (workflowResponse?.status === "failed") throw new Error(`Dify\u{5DE5}\u{4F5C}\u{6D41}\u{6267}\u{884C}\u{5931}\u{8D25}: ${workflowResponse.error || "\u672A\u77E5\u9519\u8BEF"}`);
-                    if (!summary || 0 === summary.length) throw new Error("Dify\u5DE5\u4F5C\u6D41\u54CD\u5E94\u4E2D\u672A\u627E\u5230\u6709\u6548\u6587\u672C\u5185\u5BB9");
-                    logger.k.info("[OpenAI] Dify \u5206\u6790\u5B8C\u6210", {
-                        summary_length: summary.length
+                        body: JSON.stringify({
+                            model: this.glm4vConfig.model,
+                            messages: [
+                                ...system_prompt ? [
+                                    {
+                                        role: "system",
+                                        content: system_prompt
+                                    }
+                                ] : [],
+                                {
+                                    role: "user",
+                                    content: [
+                                        {
+                                            type: "image_url",
+                                            image_url: {
+                                                url: image_base64
+                                            }
+                                        },
+                                        {
+                                            type: "text",
+                                            text: prompt
+                                        }
+                                    ]
+                                }
+                            ],
+                            stream: false,
+                            temperature,
+                            max_tokens
+                        }),
+                        signal: controller.signal
                     });
-                    return summary;
-                } catch (difyError) {
-                    logger.k.error("[OpenAI] Dify \u8C03\u7528\u5931\u8D25\uFF0C\u56DE\u9000\u5230 GLM-4V", {
-                        error: difyError instanceof Error ? difyError.message : String(difyError)
+                    clearTimeout(timeoutId);
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        throw new Error(`GLM-4V API error: ${response.status} ${response.statusText} - ${errorText}`);
+                    }
+                    const data = await response.json();
+                    if (!data.choices || 0 === data.choices.length) throw new Error("No choices returned from GLM-4V API");
+                    logger.k.info("[OpenAI] GLM-4V \u56FE\u50CF\u8BC6\u522B\u6210\u529F");
+                    return data.choices[0].message.content;
+                } catch (glmError) {
+                    logger.k.error("[OpenAI] GLM-4V \u8C03\u7528\u5931\u8D25\uFF0C\u56DE\u9000\u5230 Dify", {
+                        error: glmError instanceof Error ? glmError.message : String(glmError)
                     });
                     try {
-                        logger.k.info("[OpenAI] \u5C1D\u8BD5\u4F7F\u7528 GLM-4V");
-                        const controller = new AbortController();
-                        const timeoutId = setTimeout(()=>controller.abort(), 30000);
-                        const response = await fetch(this.glm4vConfig.baseUrl, {
-                            method: "POST",
-                            headers: {
-                                "Content-Type": "application/json",
-                                Authorization: `Bearer ${this.glm4vConfig.apiKey}`
+                        logger.k.info("[OpenAI] \u5C1D\u8BD5\u4F7F\u7528 Dify \u5DE5\u4F5C\u6D41");
+                        const uploadResult = await uploadFile({
+                            appid: this.difyConfig.apiKey,
+                            filePath: image_path,
+                            user: "aico-mcp"
+                        });
+                        logger.k.info("[OpenAI] \u6587\u4EF6\u4E0A\u4F20\u6210\u529F", {
+                            upload_file_id: uploadResult.id
+                        });
+                        const workflowData = {
+                            imagePath: {
+                                type: "image",
+                                transfer_method: "local_file",
+                                upload_file_id: uploadResult.id
                             },
-                            body: JSON.stringify({
-                                model: this.glm4vConfig.model,
-                                messages: [
-                                    ...system_prompt ? [
-                                        {
-                                            role: "system",
-                                            content: system_prompt
-                                        }
-                                    ] : [],
-                                    {
-                                        role: "user",
-                                        content: [
-                                            {
-                                                type: "image_url",
-                                                image_url: {
-                                                    url: image_base64
-                                                }
-                                            },
-                                            {
-                                                type: "text",
-                                                text: prompt
-                                            }
-                                        ]
-                                    }
-                                ],
-                                stream: false,
-                                temperature,
-                                max_tokens
-                            }),
-                            signal: controller.signal
+                            context: prompt
+                        };
+                        const workflowResponse = await invokeFlow({
+                            appid: this.difyConfig.apiKey,
+                            data: workflowData,
+                            timeout: 120000
                         });
-                        clearTimeout(timeoutId);
-                        if (!response.ok) {
-                            const errorText = await response.text();
-                            throw new Error(`GLM-4V API error: ${response.status} ${response.statusText} - ${errorText}`);
-                        }
-                        const data = await response.json();
-                        if (!data.choices || 0 === data.choices.length) throw new Error("No choices returned from GLM-4V API");
-                        logger.k.info("[OpenAI] GLM-4V \u56FE\u50CF\u8BC6\u522B\u6210\u529F");
-                        return data.choices[0].message.content;
-                    } catch (glmError) {
-                        throw new Error(`All vision services failed. Kimi: ${kimiError instanceof Error ? kimiError.message : String(kimiError)}, Dify: ${difyError instanceof Error ? difyError.message : String(difyError)}, GLM-4V: ${glmError instanceof Error ? glmError.message : String(glmError)}`);
+                        let summary = "";
+                        if ("string" == typeof workflowResponse && workflowResponse.length > 0) summary = workflowResponse;
+                        else if (workflowResponse?.outputs?.text) summary = workflowResponse.outputs.text;
+                        else if (workflowResponse?.data?.outputs?.text) summary = workflowResponse.data.outputs.text;
+                        else if (workflowResponse?.data?.text) summary = workflowResponse.data.text;
+                        else if (workflowResponse?.answer) summary = workflowResponse.answer;
+                        else if (workflowResponse?.status === "failed") throw new Error(`Dify\u{5DE5}\u{4F5C}\u{6D41}\u{6267}\u{884C}\u{5931}\u{8D25}: ${workflowResponse.error || "\u672A\u77E5\u9519\u8BEF"}`);
+                        if (!summary || 0 === summary.length) throw new Error("Dify\u5DE5\u4F5C\u6D41\u54CD\u5E94\u4E2D\u672A\u627E\u5230\u6709\u6548\u6587\u672C\u5185\u5BB9");
+                        logger.k.info("[OpenAI] Dify \u5206\u6790\u5B8C\u6210", {
+                            summary_length: summary.length
+                        });
+                        return summary;
+                    } catch (difyError) {
+                        throw new Error(`All vision services failed. Kimi: ${kimiError instanceof Error ? kimiError.message : String(kimiError)}, GLM-4V: ${glmError instanceof Error ? glmError.message : String(glmError)}, Dify: ${difyError instanceof Error ? difyError.message : String(difyError)}`);
                     }
                 }
             }
@@ -6775,6 +6790,205 @@ ${logic}` : ""}`;
                 }
             }
         }
+        async analyzeTextImage(imagePath, prompt, systemPrompt, temperature = 0.1, maxTokens = 8000, stop) {
+            const fs = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "fs/promises?238c"));
+            const pathModule = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "path?5fdd"));
+            const imageBuffer = await fs.readFile(imagePath);
+            const base64 = imageBuffer.toString("base64");
+            const ext = pathModule.extname(imagePath).toLowerCase();
+            const mimeType = ".png" === ext ? "image/png" : "image/jpeg";
+            const image_base64 = `data:${mimeType};base64,${base64}`;
+            logger.k.info("[OpenAI] \u4F7F\u7528\u5185\u7F51\u6A21\u578B\u5206\u6790\u7EAF\u6587\u5B57\u56FE\u7247");
+            const [visionResult, ocrResult] = await Promise.all([
+                this.callInternalVision(image_base64, prompt, systemPrompt, temperature, maxTokens, stop),
+                this.callInternalOCR(image_base64)
+            ]);
+            const coverage = this.calculateOcrCoverage(visionResult, ocrResult);
+            logger.k.info("[OpenAI] \u7EAF\u6587\u5B57\u56FE\u7247\u5206\u6790\u5B8C\u6210", {
+                visionLength: visionResult.length,
+                ocrLength: ocrResult.length,
+                coverage: `${(100 * coverage).toFixed(1)}%`
+            });
+            let finalResult = visionResult;
+            if (coverage < 0.7 && ocrResult.length > 0.5 * visionResult.length) {
+                logger.k.warn("[OpenAI] \u89C6\u89C9\u6A21\u578B\u8986\u76D6\u7387\u4F4E\uFF0C\u4F7F\u7528 OCR \u7ED3\u679C\u8865\u5145");
+                finalResult = this.mergeVisionAndOcr(visionResult, ocrResult);
+            }
+            return {
+                result: finalResult,
+                ocrResult,
+                coverage
+            };
+        }
+        async analyzeComplexImage(imagePath, prompt, systemPrompt, temperature = 0.1, maxTokens = 8000) {
+            logger.k.info("[OpenAI] \u4F7F\u7528 Kimi \u5206\u6790\u590D\u6742\u56FE\u7247");
+            return this.analyzeImageWithPath({
+                image_path: imagePath,
+                prompt,
+                system_prompt: systemPrompt,
+                temperature,
+                max_tokens: maxTokens
+            });
+        }
+        async getInternalAgent() {
+            const https = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "https"));
+            return new https.Agent({
+                rejectUnauthorized: false
+            });
+        }
+        async callInternalVision(image_base64, prompt, systemPrompt, temperature = 0.1, maxTokens = 8000, stop) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(()=>controller.abort(), 60000);
+            try {
+                await this.getInternalAgent();
+                const response = await fetch(this.internalConfig.baseUrl, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${this.internalConfig.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        model: this.internalConfig.visionModel,
+                        messages: [
+                            ...systemPrompt ? [
+                                {
+                                    role: "system",
+                                    content: systemPrompt
+                                }
+                            ] : [],
+                            {
+                                role: "user",
+                                content: [
+                                    {
+                                        type: "image_url",
+                                        image_url: {
+                                            url: image_base64
+                                        }
+                                    },
+                                    {
+                                        type: "text",
+                                        text: prompt
+                                    }
+                                ]
+                            }
+                        ],
+                        stream: false,
+                        temperature,
+                        max_tokens: maxTokens,
+                        ...stop ? {
+                            stop
+                        } : {}
+                    }),
+                    signal: controller.signal,
+                    dispatcher: new (await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "undici"))).Agent({
+                        connect: {
+                            rejectUnauthorized: false
+                        }
+                    })
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`Internal Vision API error: ${response.status} - ${errorText}`);
+                }
+                const data = await response.json();
+                if (!data.choices || 0 === data.choices.length) throw new Error("No choices returned from Internal Vision API");
+                logger.k.info("[OpenAI] \u5185\u7F51\u89C6\u89C9\u6A21\u578B\u8C03\u7528\u6210\u529F");
+                return data.choices[0].message.content;
+            } catch (error) {
+                clearTimeout(timeoutId);
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                logger.k.error("[OpenAI] \u5185\u7F51\u89C6\u89C9\u6A21\u578B\u8C03\u7528\u5931\u8D25", {
+                    error: errorMsg,
+                    baseUrl: this.internalConfig.baseUrl,
+                    model: this.internalConfig.visionModel
+                });
+                throw error;
+            }
+        }
+        async callInternalOCR(image_base64, stop) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(()=>controller.abort(), 30000);
+            const ocrPrompt = `\u{8BF7}\u{63D0}\u{53D6}\u{56FE}\u{7247}\u{4E2D}\u{7684}\u{6240}\u{6709}\u{6587}\u{5B57}\u{5185}\u{5BB9}\u{FF0C}\u{539F}\u{6587}\u{7167}\u{6284}\u{FF0C}\u{4FDD}\u{6301}\u{683C}\u{5F0F}\u{3002}\u{53EA}\u{8F93}\u{51FA}\u{6587}\u{5B57}\u{FF0C}\u{4E0D}\u{8981}\u{6DFB}\u{52A0}\u{4EFB}\u{4F55}\u{89E3}\u{91CA}\u{3002}`;
+            try {
+                const response = await fetch(this.internalConfig.baseUrl, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${this.internalConfig.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        model: this.internalConfig.ocrModel,
+                        messages: [
+                            {
+                                role: "user",
+                                content: [
+                                    {
+                                        type: "image_url",
+                                        image_url: {
+                                            url: image_base64
+                                        }
+                                    },
+                                    {
+                                        type: "text",
+                                        text: ocrPrompt
+                                    }
+                                ]
+                            }
+                        ],
+                        stream: false,
+                        temperature: 0,
+                        max_tokens: 4000,
+                        ...stop ? {
+                            stop
+                        } : {
+                            stop: [
+                                "<<<END>>>"
+                            ]
+                        }
+                    }),
+                    signal: controller.signal,
+                    dispatcher: new (await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "undici"))).Agent({
+                        connect: {
+                            rejectUnauthorized: false
+                        }
+                    })
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`Internal OCR API error: ${response.status} - ${errorText}`);
+                }
+                const data = await response.json();
+                if (!data.choices || 0 === data.choices.length) throw new Error("No choices returned from Internal OCR API");
+                logger.k.info("[OpenAI] \u5185\u7F51 OCR \u6A21\u578B\u8C03\u7528\u6210\u529F");
+                return data.choices[0].message.content;
+            } catch (error) {
+                clearTimeout(timeoutId);
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                logger.k.warn("[OpenAI] \u5185\u7F51 OCR \u8C03\u7528\u5931\u8D25", {
+                    error: errorMsg,
+                    baseUrl: this.internalConfig.baseUrl,
+                    model: this.internalConfig.ocrModel
+                });
+                return "";
+            }
+        }
+        calculateOcrCoverage(visionResult, ocrResult) {
+            if (!ocrResult || 0 === ocrResult.length) return 1;
+            const ocrLines = ocrResult.split('\n').map((line)=>line.trim()).filter((line)=>line.length > 5);
+            if (0 === ocrLines.length) return 1;
+            let matchedCount = 0;
+            for (const line of ocrLines){
+                const sample = line.length > 10 ? line.substring(Math.floor(line.length / 2) - 5, Math.floor(line.length / 2) + 5) : line;
+                if (visionResult.includes(sample)) matchedCount++;
+            }
+            return matchedCount / ocrLines.length;
+        }
+        mergeVisionAndOcr(visionResult, ocrResult) {
+            if (ocrResult.length > visionResult.length) return ocrResult;
+            return visionResult;
+        }
     }
     const openAIService = new OpenAIService();
     const renderRequirementDocumentTool = {
@@ -7140,7 +7354,7 @@ ${chaptersContent}
         context;
         constructor(message, code, context){
             super(message), this.code = code, this.context = context;
-            this.name = 'ImageAnalysisError';
+            this.name = "ImageAnalysisError";
         }
     }
     var types_AnalysisErrorCodes = /*#__PURE__*/ function(AnalysisErrorCodes) {
@@ -7153,343 +7367,602 @@ ${chaptersContent}
         return AnalysisErrorCodes;
     }({});
     const SUPPORTED_IMAGE_FORMATS = [
-        'jpg',
-        'jpeg',
-        'png',
-        'gif',
-        'bmp',
-        'tiff',
-        'tif',
-        'webp'
+        "jpg",
+        "jpeg",
+        "png",
+        "gif",
+        "bmp",
+        "tiff",
+        "tif",
+        "webp"
     ];
-    const DEFAULT_CHUNK_CONFIG = {
-        maxChunks: 6,
-        overlapRatio: 0.15,
-        minResultLength: 200
+    const DEFAULT_SEGMENT_CONFIG = {
+        maxHeight: 1500,
+        overlapRatio: 0.1
     };
-    class ImageAnalyzer {
-        async analyzeImage(imagePath, context) {
-            const startTime = Date.now();
-            try {
-                logger.k.info("\u5F00\u59CB\u56FE\u7247\u5185\u5BB9\u5206\u6790", {
-                    imagePath: imagePath
-                });
-                await this.validateParams(imagePath);
-                const basicInfo = await this.getImageBasicInfo(imagePath);
-                const analysisContent = await this.performSmartAnalysis(imagePath, context, basicInfo);
-                const processingTime = Date.now() - startTime;
-                if (!analysisContent) throw new ImageAnalysisError("AI\u5206\u6790\u8FD4\u56DE\u7A7A\u7ED3\u679C", types_AnalysisErrorCodes.ANALYSIS_FAILED, {
-                    params: {
-                        image_path: imagePath
-                    }
-                });
-                const result = {
-                    basic_info: basicInfo,
-                    content: analysisContent,
-                    processing_time_ms: processingTime
-                };
-                logger.k.info("\u56FE\u7247\u5185\u5BB9\u5206\u6790\u5B8C\u6210", {
-                    imagePath: imagePath,
-                    processingTimeMs: processingTime
-                });
-                return result;
-            } catch (error) {
-                logger.k.error("\u56FE\u7247\u5185\u5BB9\u5206\u6790\u5931\u8D25", {
-                    error,
-                    params: {
-                        image_path: imagePath
-                    }
-                });
-                throw error;
-            }
-        }
-        async performSmartAnalysis(imagePath, context, basicInfo) {
-            try {
-                logger.k.info("\u5F00\u59CB\u6574\u4F53\u56FE\u7247\u8BC6\u522B", {
-                    imagePath
-                });
-                const initialResult = await this.performAIAnalysisWithCompletenessCheck(imagePath, context);
-                const completenessCheck = this.checkCompleteness(initialResult);
-                if (completenessCheck.complete) {
-                    logger.k.info("\u56FE\u7247\u8BC6\u522B\u5B8C\u6574\uFF0C\u65E0\u9700\u5206\u5757");
-                    return {
-                        summary: completenessCheck.content,
-                        details: {},
-                        tags: []
-                    };
-                }
-                logger.k.info("\u56FE\u7247\u8BC6\u522B\u4E0D\u5B8C\u6574\uFF0C\u542F\u7528\u5206\u5757\u8BC6\u522B", {
-                    reason: completenessCheck.reason,
-                    width: basicInfo.dimensions.width,
-                    height: basicInfo.dimensions.height
-                });
-                const chunkedResult = await this.analyzeWithChunks(imagePath, context, basicInfo);
-                return {
-                    summary: chunkedResult,
-                    details: {
-                        chunked: true,
-                        reason: completenessCheck.reason
-                    },
-                    tags: []
-                };
-            } catch (error) {
-                logger.k.error("\u667A\u80FD\u5206\u6790\u5931\u8D25", {
-                    error,
-                    imagePath
-                });
-                throw new ImageAnalysisError("\u8BC6\u522B\u56FE\u7247\u5931\u8D25", types_AnalysisErrorCodes.ANALYSIS_FAILED, {
-                    originalError: error
-                });
-            }
+    const LONG_IMAGE_THRESHOLD = {
+        minHeight: 2000,
+        minAspectRatio: 2
+    };
+    async function getImageInfo(imagePath) {
+        try {
+            const metadata = await external_sharp_default()(imagePath).metadata();
+            const stats = await promises_.stat(imagePath);
+            return {
+                path: imagePath,
+                format: metadata.format || "unknown",
+                dimensions: {
+                    width: metadata.width || 0,
+                    height: metadata.height || 0
+                },
+                file_size: stats.size
+            };
+        } catch (error) {
+            throw new ImageAnalysisError(`\u{65E0}\u{6CD5}\u{8BFB}\u{53D6}\u{56FE}\u{7247}\u{4FE1}\u{606F}: ${imagePath}`, types_AnalysisErrorCodes.IMAGE_CORRUPTED, {
+                imagePath,
+                originalError: error
+            });
         }
-        async performAIAnalysisWithCompletenessCheck(imagePath, context) {
-            const systemPrompt = `You are an OCR transcription machine. Your ONLY job is to output the EXACT text from images. 
-You must NEVER summarize, paraphrase, analyze, or interpret. 
-You must NEVER use words like "\u{9875}\u{9762}\u{7ED3}\u{6784}", "\u{6838}\u{5FC3}\u{5185}\u{5BB9}", "\u{4E3B}\u{8981}\u{529F}\u{80FD}", "\u{91CD}\u{8981}\u{901A}\u{77E5}" unless they appear verbatim in the image.
-Output ONLY what you see, character by character.`;
-            const userPrompt = `\u{8BF7}\u{9010}\u{5B57}\u{6284}\u{5F55}\u{56FE}\u{7247}\u{4E2D}\u{7684}\u{6240}\u{6709}\u{6587}\u{5B57}\u{5185}\u{5BB9}\u{3002}
-
-\u{89C4}\u{5219}\u{FF1A}
-1. \u{539F}\u{6587}\u{7167}\u{6284}\u{FF1A}\u{6BCF}\u{4E00}\u{4E2A}\u{5B57}\u{3001}\u{6BCF}\u{4E00}\u{4E2A}\u{6807}\u{70B9}\u{3001}\u{6BCF}\u{4E00}\u{4E2A}\u{7A7A}\u{683C}\u{90FD}\u{8981}\u{5B8C}\u{5168}\u{4E00}\u{6837}
-2. \u{4FDD}\u{6301}\u{683C}\u{5F0F}\u{FF1A}\u{6362}\u{884C}\u{3001}\u{7F29}\u{8FDB}\u{3001}\u{5217}\u{8868}\u{7F16}\u{53F7}\u{90FD}\u{4FDD}\u{6301}\u{539F}\u{6837}
-3. \u{4EE3}\u{7801}\u{5757}\u{FF1A}\u{7528} \`\`\` \u{5305}\u{88F9}\u{FF0C}\u{4FDD}\u{6301}\u{539F}\u{59CB}\u{7F29}\u{8FDB}
-4. \u{8868}\u{683C}\u{FF1A}\u{7528} markdown \u{8868}\u{683C}\u{683C}\u{5F0F}
-5. \u{56FE}\u{7247}/\u{56FE}\u{6807}\u{FF1A}\u{7528} [\u{56FE}\u{7247}: \u{7B80}\u{8981}\u{63CF}\u{8FF0}] \u{6807}\u{6CE8}
-
-\u{7981}\u{6B62}\u{FF1A}
-- \u{7981}\u{6B62}\u{4F7F}\u{7528}"\u{9875}\u{9762}\u{7ED3}\u{6784}"\u{3001}"\u{6838}\u{5FC3}\u{5185}\u{5BB9}"\u{3001}"\u{4E3B}\u{8981}\u{529F}\u{80FD}"\u{7B49}\u{603B}\u{7ED3}\u{6027}\u{8BCD}\u{6C47}\u{FF08}\u{9664}\u{975E}\u{56FE}\u{7247}\u{4E2D}\u{539F}\u{6587}\u{5C31}\u{6709}\u{FF09}
-- \u{7981}\u{6B62}\u{6DFB}\u{52A0}\u{4EFB}\u{4F55}\u{89E3}\u{91CA}\u{3001}\u{5206}\u{6790}\u{3001}\u{8BC4}\u{8BBA}
-- \u{7981}\u{6B62}\u{7701}\u{7565}\u{4EFB}\u{4F55}\u{5185}\u{5BB9}
-
-${context ? `\u{8865}\u{5145}\u{8981}\u{6C42}\u{FF1A}${context}\n\n` : ''}\u{73B0}\u{5728}\u{5F00}\u{59CB}\u{9010}\u{5B57}\u{6284}\u{5F55}\u{FF1A}`;
-            const aiResponse = await openAIService.analyzeImageWithPath({
-                image_path: imagePath,
-                prompt: userPrompt,
-                system_prompt: systemPrompt,
-                temperature: 0,
-                max_tokens: 8000
+    }
+    function image_processor_isLongImage(info) {
+        const { width, height } = info.dimensions;
+        const aspectRatio = height / width;
+        return height > LONG_IMAGE_THRESHOLD.minHeight && aspectRatio > LONG_IMAGE_THRESHOLD.minAspectRatio;
+    }
+    async function validateImage(imagePath) {
+        try {
+            await promises_.access(imagePath);
+        } catch  {
+            throw new ImageAnalysisError(`\u{56FE}\u{7247}\u{6587}\u{4EF6}\u{4E0D}\u{5B58}\u{5728}: ${imagePath}`, types_AnalysisErrorCodes.FILE_NOT_FOUND, {
+                imagePath
             });
-            return aiResponse.trim();
         }
-        checkCompleteness(result) {
-            if (result.includes("[\u5B8C\u6574]")) return {
-                complete: true,
-                content: result.replace(/\[完整\]/g, '').trim()
+        const ext = external_path_.extname(imagePath).slice(1).toLowerCase();
+        if (!SUPPORTED_IMAGE_FORMATS.includes(ext)) throw new ImageAnalysisError(`\u{4E0D}\u{652F}\u{6301}\u{7684}\u{56FE}\u{7247}\u{683C}\u{5F0F}: ${ext}`, types_AnalysisErrorCodes.UNSUPPORTED_FORMAT, {
+            format: ext,
+            supportedFormats: SUPPORTED_IMAGE_FORMATS
+        });
+    }
+    async function splitLongImage(imagePath, info, config = DEFAULT_SEGMENT_CONFIG) {
+        const { width, height } = info.dimensions;
+        const { maxHeight, overlapRatio } = config;
+        const overlap = Math.floor(maxHeight * overlapRatio);
+        const segments = [];
+        let currentY = 0;
+        let index = 0;
+        while(currentY < height){
+            const endY = Math.min(currentY + maxHeight, height);
+            const segmentHeight = endY - currentY;
+            const buffer = await external_sharp_default()(imagePath).extract({
+                left: 0,
+                top: currentY,
+                width: width,
+                height: segmentHeight
+            }).jpeg({
+                quality: 90
+            }).toBuffer();
+            segments.push({
+                index,
+                total: 0,
+                startY: currentY,
+                endY,
+                buffer
+            });
+            currentY = endY - overlap;
+            if (currentY >= height - overlap) break;
+            index++;
+        }
+        const total = segments.length;
+        segments.forEach((s)=>s.total = total);
+        logger.k.info("\u957F\u56FE\u5206\u6BB5\u5B8C\u6210", {
+            width,
+            height,
+            segments: total
+        });
+        return segments;
+    }
+    async function saveSegmentToTemp(segment) {
+        const tempPath = external_path_.join("/tmp", `segment_${Date.now()}_${segment.index}.jpg`);
+        await promises_.writeFile(tempPath, segment.buffer);
+        return tempPath;
+    }
+    async function cleanupTempFile(filePath) {
+        try {
+            await promises_.unlink(filePath);
+        } catch  {}
+    }
+    function mergeSegmentResults(results) {
+        if (0 === results.length) return "";
+        if (1 === results.length) return results[0];
+        let merged = results[0];
+        for(let i = 1; i < results.length; i++){
+            const current = results[i];
+            const overlapLen = findTextOverlap(merged, current);
+            if (overlapLen > 0) merged += "\n" + current.substring(overlapLen);
+            else merged += "\n\n" + current;
+        }
+        return merged.trim();
+    }
+    function findTextOverlap(prev, curr) {
+        const prevLines = prev.split("\n").slice(-10);
+        const currLines = curr.split("\n").slice(0, 10);
+        for(let i = Math.min(prevLines.length, currLines.length); i >= 2; i--){
+            const prevTail = prevLines.slice(-i).map((l)=>l.trim()).join("\n");
+            const currHead = currLines.slice(0, i).map((l)=>l.trim()).join("\n");
+            if (prevTail === currHead) return currLines.slice(0, i).join("\n").length;
+        }
+        return 0;
+    }
+    const INTERNAL_CONFIG = {
+        apiKey: "sk-3W5NXAzeXX9mNP5yppQwPt6cnEoSK03u5NgiNW1Hsi41Tniu",
+        baseUrl: "https://aiproxy.jla.petrotech.cnpc/v1/chat/completions",
+        visionModel: "qwen2-7b-vl",
+        ocrModel: "deepseek-ocr"
+    };
+    const DIFY_CONFIG = {
+        apiKey: "app-xPG7ROh2YaAzR3v9vKnhAWpz"
+    };
+    const KIMI_CONFIG = {
+        apiKey: "sk-fp8wJSigZBEP3x8y6MAZWGPuVIHJ5PDZtX9lMQQk8hjP2R0u",
+        baseUrl: "https://api.moonshot.cn/v1/chat/completions",
+        model: "moonshot-v1-128k-vision-preview"
+    };
+    const GLM_CONFIG = {
+        apiKey: "fb26a7ff758c3974e43bfff49a684dd3.apcuRq6v6RvwuJDu",
+        baseUrl: "https://open.bigmodel.cn/api/paas/v4/chat/completions",
+        model: "glm-4v-flash"
+    };
+    async function getHttpsAgent() {
+        const { Agent } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "undici"));
+        return new Agent({
+            connect: {
+                rejectUnauthorized: false
+            }
+        });
+    }
+    async function imageToBase64(imagePath) {
+        const buffer = await promises_.readFile(imagePath);
+        const ext = external_path_.extname(imagePath).toLowerCase();
+        const mimeType = ".png" === ext ? "image/png" : "image/jpeg";
+        return `data:${mimeType};base64,${buffer.toString("base64")}`;
+    }
+    function bufferToBase64(buffer, format = "jpeg") {
+        const mimeType = "png" === format ? "image/png" : "image/jpeg";
+        return `data:${mimeType};base64,${buffer.toString("base64")}`;
+    }
+    const SYSTEM_PROMPT = `You must interpret and analyze images strictly according to the assigned task.
+When an image is provided, your role is to parse the image content only within the scope of the user's instructions.
+Do not ignore or deviate from the task.
+Always ensure that your response reflects a clear, accurate interpretation of the image aligned with the given objective.`;
+    async function callInternalVision(imageBase64, prompt, maxTokens = 8000) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(()=>controller.abort(), 90000);
+        try {
+            const agent = await getHttpsAgent();
+            const response = await fetch(INTERNAL_CONFIG.baseUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${INTERNAL_CONFIG.apiKey}`
+                },
+                body: JSON.stringify({
+                    model: INTERNAL_CONFIG.visionModel,
+                    messages: [
+                        {
+                            role: "system",
+                            content: SYSTEM_PROMPT
+                        },
+                        {
+                            role: "user",
+                            content: [
+                                {
+                                    type: "image_url",
+                                    image_url: {
+                                        url: imageBase64
+                                    }
+                                },
+                                {
+                                    type: "text",
+                                    text: prompt
+                                }
+                            ]
+                        }
+                    ],
+                    temperature: 0.2,
+                    max_tokens: maxTokens
+                }),
+                signal: controller.signal,
+                dispatcher: agent
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`\u{5185}\u{7F51}\u{89C6}\u{89C9}\u{6A21}\u{578B}\u{9519}\u{8BEF}: ${response.status} - ${errorText}`);
+            }
+            const data = await response.json();
+            const content = data.choices?.[0]?.message?.content || "";
+            if (!content) throw new Error("\u5185\u7F51\u89C6\u89C9\u6A21\u578B\u8FD4\u56DE\u7A7A\u7ED3\u679C");
+            logger.k.info("\u5185\u7F51\u89C6\u89C9\u6A21\u578B\u8C03\u7528\u6210\u529F", {
+                contentLength: content.length
+            });
+            return content;
+        } catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+    }
+    async function callInternalOCR(imageBase64, prompt, maxTokens = 4000) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(()=>controller.abort(), 60000);
+        try {
+            const agent = await getHttpsAgent();
+            const response = await fetch(INTERNAL_CONFIG.baseUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${INTERNAL_CONFIG.apiKey}`
+                },
+                body: JSON.stringify({
+                    model: INTERNAL_CONFIG.ocrModel,
+                    messages: [
+                        {
+                            role: "system",
+                            content: SYSTEM_PROMPT
+                        },
+                        {
+                            role: "user",
+                            content: [
+                                {
+                                    type: "image_url",
+                                    image_url: {
+                                        url: imageBase64
+                                    }
+                                },
+                                {
+                                    type: "text",
+                                    text: prompt
+                                }
+                            ]
+                        }
+                    ],
+                    temperature: 0.2,
+                    max_tokens: maxTokens
+                }),
+                signal: controller.signal,
+                dispatcher: agent
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) throw new Error(`\u{5185}\u{7F51}OCR\u{9519}\u{8BEF}: ${response.status}`);
+            const data = await response.json();
+            const content = data.choices?.[0]?.message?.content || "";
+            logger.k.info("\u5185\u7F51OCR\u8C03\u7528\u6210\u529F", {
+                contentLength: content.length
+            });
+            return content;
+        } catch (error) {
+            clearTimeout(timeoutId);
+            logger.k.warn("\u5185\u7F51OCR\u8C03\u7528\u5931\u8D25", {
+                error
+            });
+            return "";
+        }
+    }
+    async function callDifyWorkflow(imagePath, context) {
+        try {
+            const uploadResult = await uploadFile({
+                appid: DIFY_CONFIG.apiKey,
+                filePath: imagePath,
+                user: "aico-mcp"
+            });
+            logger.k.info("Dify \u6587\u4EF6\u4E0A\u4F20\u6210\u529F", {
+                fileId: uploadResult.id
+            });
+            const workflowData = {
+                imagePath: {
+                    type: "image",
+                    transfer_method: "local_file",
+                    upload_file_id: uploadResult.id
+                },
+                context: context
             };
-            const incompleteMatch = result.match(/\[可能不完整[::：](.+?)\]/i);
-            if (incompleteMatch) return {
-                complete: false,
-                reason: incompleteMatch[1].trim(),
-                content: result.replace(/\[可能不完整[::：].+?\]/gi, '').trim()
+            const response = await invokeFlow({
+                appid: DIFY_CONFIG.apiKey,
+                data: workflowData,
+                timeout: 120000
+            });
+            let content = "";
+            if ("string" == typeof response && response.length > 0) content = response;
+            else if (response?.outputs?.text) content = response.outputs.text;
+            else if (response?.data?.outputs?.text) content = response.data.outputs.text;
+            if (!content) throw new Error("Dify \u54CD\u5E94\u4E2D\u672A\u627E\u5230\u6709\u6548\u5185\u5BB9");
+            logger.k.info("Dify \u5DE5\u4F5C\u6D41\u8C03\u7528\u6210\u529F", {
+                contentLength: content.length
+            });
+            return content;
+        } catch (error) {
+            throw error;
+        }
+    }
+    async function callKimiVision(imageBase64, prompt, maxTokens = 8000) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(()=>controller.abort(), 90000);
+        try {
+            const response = await fetch(KIMI_CONFIG.baseUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${KIMI_CONFIG.apiKey}`
+                },
+                body: JSON.stringify({
+                    model: KIMI_CONFIG.model,
+                    messages: [
+                        {
+                            role: "system",
+                            content: SYSTEM_PROMPT
+                        },
+                        {
+                            role: "user",
+                            content: [
+                                {
+                                    type: "image_url",
+                                    image_url: {
+                                        url: imageBase64
+                                    }
+                                },
+                                {
+                                    type: "text",
+                                    text: prompt
+                                }
+                            ]
+                        }
+                    ],
+                    temperature: 0.2,
+                    max_tokens: maxTokens
+                }),
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Kimi \u{9519}\u{8BEF}: ${response.status} - ${errorText}`);
+            }
+            const data = await response.json();
+            const content = data.choices?.[0]?.message?.content || "";
+            if (!content) throw new Error("Kimi \u8FD4\u56DE\u7A7A\u7ED3\u679C");
+            logger.k.info("Kimi Vision \u8C03\u7528\u6210\u529F", {
+                contentLength: content.length
+            });
+            return content;
+        } catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+    }
+    async function callGLMVision(imageBase64, prompt, maxTokens = 4000) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(()=>controller.abort(), 60000);
+        try {
+            const response = await fetch(GLM_CONFIG.baseUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${GLM_CONFIG.apiKey}`
+                },
+                body: JSON.stringify({
+                    model: GLM_CONFIG.model,
+                    messages: [
+                        {
+                            role: "system",
+                            content: SYSTEM_PROMPT
+                        },
+                        {
+                            role: "user",
+                            content: [
+                                {
+                                    type: "image_url",
+                                    image_url: {
+                                        url: imageBase64
+                                    }
+                                },
+                                {
+                                    type: "text",
+                                    text: prompt
+                                }
+                            ]
+                        }
+                    ],
+                    temperature: 0.2,
+                    max_tokens: maxTokens
+                }),
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`GLM-4V \u{9519}\u{8BEF}: ${response.status} - ${errorText}`);
+            }
+            const data = await response.json();
+            const content = data.choices?.[0]?.message?.content || "";
+            if (!content) throw new Error("GLM-4V \u8FD4\u56DE\u7A7A\u7ED3\u679C");
+            logger.k.info("GLM-4V \u8C03\u7528\u6210\u529F", {
+                contentLength: content.length
+            });
+            return content;
+        } catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+    }
+    async function analyzeWithVision(imagePath, imageBase64, prompt, context) {
+        try {
+            const [visionResult, ocrResult] = await Promise.all([
+                callInternalVision(imageBase64, prompt).catch(()=>""),
+                callInternalOCR(imageBase64, prompt).catch(()=>"")
+            ]);
+            if (visionResult || ocrResult) {
+                const chosen = chooseBestTranscription(visionResult, ocrResult);
+                return {
+                    content: chosen.content,
+                    model: chosen.source
+                };
+            }
+            throw new Error("\u5185\u7F51\u6A21\u578B\u5747\u8FD4\u56DE\u7A7A\u7ED3\u679C");
+        } catch (internalError) {
+            logger.k.warn("\u5185\u7F51\u6A21\u578B\u5931\u8D25", {
+                error: internalError
+            });
+        }
+        try {
+            const content = await callKimiVision(imageBase64, prompt);
+            return {
+                content,
+                model: "kimi"
             };
-            if (result.length < DEFAULT_CHUNK_CONFIG.minResultLength) return {
-                complete: false,
-                reason: "\u8BC6\u522B\u7ED3\u679C\u8FC7\u77ED",
-                content: result
+        } catch (kimiError) {
+            logger.k.warn("Kimi \u5931\u8D25", {
+                error: kimiError
+            });
+        }
+        try {
+            const content = await callGLMVision(imageBase64, prompt);
+            return {
+                content,
+                model: "glm"
             };
+        } catch (glmError) {
+            logger.k.warn("GLM-4V \u5931\u8D25", {
+                error: glmError
+            });
+        }
+        const content = await callDifyWorkflow(imagePath, context || prompt);
+        return {
+            content,
+            model: "dify"
+        };
+    }
+    function chooseBestTranscription(vision, ocr) {
+        const hasSummaryPattern = (s)=>{
+            if (!s) return false;
+            const lines = s.split(/\r?\n/).slice(0, 5).join("\n");
+            const summaryHeaders = /(截图内容分析|核心信息|功能描述|接口说明|限制条件|主要内容|图片内容|内容概述)/;
+            const chattyPrefix = /^(好的|如下|以下为|以下是|我将|这是一张|根据图片|请见)[，,:：]?/m;
+            return summaryHeaders.test(lines) || chattyPrefix.test(lines);
+        };
+        const visionIsSummary = hasSummaryPattern(vision);
+        const ocrIsSummary = hasSummaryPattern(ocr);
+        if (ocr && !ocrIsSummary) return {
+            content: ocr,
+            source: "internal-ocr"
+        };
+        if (vision && !visionIsSummary) return {
+            content: vision,
+            source: "internal-vision"
+        };
+        if ((ocr || "").length >= (vision || "").length) return {
+            content: ocr || vision,
+            source: ocr ? "internal-ocr" : "internal-vision"
+        };
+        return {
+            content: vision,
+            source: "internal-vision"
+        };
+    }
+    class ImageAnalyzer {
+        async analyzeImage(imagePath, context) {
+            const startTime = Date.now();
+            logger.k.info("\u5F00\u59CB\u56FE\u7247\u5206\u6790", {
+                imagePath
+            });
+            await validateImage(imagePath);
+            const imageInfo = await getImageInfo(imagePath);
+            logger.k.info("\u56FE\u7247\u4FE1\u606F", {
+                width: imageInfo.dimensions.width,
+                height: imageInfo.dimensions.height,
+                format: imageInfo.format
+            });
+            let content;
+            content = image_processor_isLongImage(imageInfo) ? await this.analyzeLongImage(imagePath, imageInfo, context) : await this.analyzeSingleImage(imagePath, context);
+            const processingTime = Date.now() - startTime;
+            logger.k.info("\u56FE\u7247\u5206\u6790\u5B8C\u6210", {
+                processingTime,
+                contentLength: content.summary.length
+            });
             return {
-                complete: true,
-                content: result
+                basic_info: imageInfo,
+                content,
+                processing_time_ms: processingTime
             };
         }
-        async analyzeWithChunks(imagePath, context, basicInfo) {
-            const { width, height } = basicInfo.dimensions;
-            const chunks = this.calculateChunks(width, height);
-            logger.k.info("\u56FE\u7247\u5206\u5757\u65B9\u6848", {
-                totalChunks: chunks.length,
-                chunks: chunks.map((c)=>({
-                        position: c.position,
-                        x: c.x,
-                        y: c.y,
-                        width: c.width,
-                        height: c.height
-                    }))
+        async analyzeSingleImage(imagePath, context) {
+            const imageBase64 = await imageToBase64(imagePath);
+            const prompt = this.buildPrompt(context);
+            const result = await analyzeWithVision(imagePath, imageBase64, prompt, context);
+            logger.k.info("\u56FE\u7247\u8BC6\u522B\u5B8C\u6210", {
+                model: result.model,
+                contentLength: result.content.length
             });
-            const chunkResults = [];
-            const tempDir = await promises_.mkdtemp(external_path_.join(external_os_.tmpdir(), 'image-chunks-'));
-            try {
-                const concurrencyLimit = 3;
-                for(let i = 0; i < chunks.length; i += concurrencyLimit){
-                    const batch = chunks.slice(i, i + concurrencyLimit);
-                    const batchResults = await Promise.all(batch.map(async (chunk)=>{
-                        const chunkPath = await this.extractChunk(imagePath, chunk, tempDir);
-                        const content = await this.analyzeChunk(chunkPath, chunk.position, context);
-                        return {
-                            chunk,
-                            content,
-                            isComplete: true
-                        };
-                    }));
-                    chunkResults.push(...batchResults);
-                }
-                const mergedResult = await this.mergeChunkResults(chunkResults, context);
-                return mergedResult;
-            } finally{
+            return {
+                summary: result.content,
+                details: {
+                    model: result.model
+                },
+                tags: []
+            };
+        }
+        async analyzeLongImage(imagePath, imageInfo, context) {
+            const segments = await splitLongImage(imagePath, imageInfo);
+            const results = [];
+            const models = [];
+            for (const segment of segments){
+                const segmentBase64 = bufferToBase64(segment.buffer);
+                const prompt = this.buildPrompt(context, segment.index + 1, segment.total);
+                const tempPath = await saveSegmentToTemp(segment);
                 try {
-                    await promises_.rm(tempDir, {
-                        recursive: true,
-                        force: true
+                    const result = await analyzeWithVision(tempPath, segmentBase64, prompt, context);
+                    results.push(result.content);
+                    models.push(result.model);
+                    logger.k.info(`\u{5206}\u{6BB5} ${segment.index + 1}/${segment.total} \u{5B8C}\u{6210}`, {
+                        model: result.model
                     });
-                } catch (e) {
-                    logger.k.warn("\u6E05\u7406\u4E34\u65F6\u6587\u4EF6\u5931\u8D25", {
-                        tempDir,
-                        error: e
+                } catch (error) {
+                    logger.k.error(`\u{5206}\u{6BB5} ${segment.index + 1} \u{8BC6}\u{522B}\u{5931}\u{8D25}`, {
+                        error
                     });
+                    results.push(`[\u{7B2C} ${segment.index + 1} \u{90E8}\u{5206}\u{8BC6}\u{522B}\u{5931}\u{8D25}]`);
+                } finally{
+                    await cleanupTempFile(tempPath);
                 }
             }
+            const mergedContent = mergeSegmentResults(results);
+            return {
+                summary: mergedContent,
+                details: {
+                    segments: segments.length,
+                    models: [
+                        ...new Set(models)
+                    ]
+                },
+                tags: []
+            };
         }
-        calculateChunks(width, height) {
-            const chunks = [];
-            const area = width * height;
-            let cols, rows;
-            if (area <= 2000000) {
-                cols = 1;
-                rows = 1;
-            } else if (area <= 4000000) {
-                cols = 2;
-                rows = 1;
-            } else if (area <= 6000000) {
-                cols = 2;
-                rows = 2;
-            } else {
-                cols = 3;
-                rows = 2;
-            }
-            if (1 === cols && 1 === rows) return [
-                {
-                    index: 0,
-                    position: "\u5168\u56FE",
-                    x: 0,
-                    y: 0,
-                    width,
-                    height
-                }
-            ];
-            const overlapRatio = DEFAULT_CHUNK_CONFIG.overlapRatio;
-            const chunkWidth = Math.ceil(width / cols);
-            const chunkHeight = Math.ceil(height / rows);
-            const overlapX = Math.ceil(chunkWidth * overlapRatio);
-            const overlapY = Math.ceil(chunkHeight * overlapRatio);
-            const positionNames = [
-                [
-                    "\u5DE6\u4E0A",
-                    "\u4E2D\u4E0A",
-                    "\u53F3\u4E0A"
-                ],
-                [
-                    "\u5DE6\u4E2D",
-                    "\u4E2D\u592E",
-                    "\u53F3\u4E2D"
-                ],
-                [
-                    "\u5DE6\u4E0B",
-                    "\u4E2D\u4E0B",
-                    "\u53F3\u4E0B"
-                ]
-            ];
-            let index = 0;
-            for(let row = 0; row < rows; row++)for(let col = 0; col < cols; col++){
-                const x = Math.max(0, col * chunkWidth - (col > 0 ? overlapX : 0));
-                const y = Math.max(0, row * chunkHeight - (row > 0 ? overlapY : 0));
-                const w = Math.min(chunkWidth + (col > 0 ? overlapX : 0) + (col < cols - 1 ? overlapX : 0), width - x);
-                const h = Math.min(chunkHeight + (row > 0 ? overlapY : 0) + (row < rows - 1 ? overlapY : 0), height - y);
-                chunks.push({
-                    index,
-                    position: positionNames[row]?.[col] || `\u{533A}\u{57DF}${index + 1}`,
-                    x,
-                    y,
-                    width: w,
-                    height: h
-                });
-                index++;
-            }
-            return chunks;
-        }
-        async extractChunk(imagePath, chunk, tempDir) {
-            const chunkPath = external_path_.join(tempDir, `chunk_${chunk.index}.png`);
-            await external_sharp_default()(imagePath).extract({
-                left: chunk.x,
-                top: chunk.y,
-                width: chunk.width,
-                height: chunk.height
-            }).toFile(chunkPath);
-            return chunkPath;
-        }
-        async analyzeChunk(chunkPath, position, context) {
-            const systemPrompt = "You are an OCR transcription machine. Output ONLY the exact text from images. Never summarize or interpret.";
-            const userPrompt = `\u{8FD9}\u{662F}\u{56FE}\u{7247}\u{7684}\u{3010}${position}\u{3011}\u{90E8}\u{5206}\u{3002}\u{8BF7}\u{9010}\u{5B57}\u{6284}\u{5F55}\u{6B64}\u{533A}\u{57DF}\u{5185}\u{7684}\u{6240}\u{6709}\u{6587}\u{5B57}\u{3002}
+        buildPrompt(context, segmentIndex, totalSegments) {
+            let prompt = `\u{4F60}\u{662F}\u{4E00}\u{4E2A}\u{4EC5}\u{505A}\u{9010}\u{5B57}\u{6284}\u{5F55}\u{7684} OCR \u{5DE5}\u{5177}\u{FF0C}\u{53EA}\u{80FD}\u{628A}\u{56FE}\u{7247}\u{91CC}\u{7684}\u{6587}\u{5B57}\u{539F}\u{6837}\u{6284}\u{5199}\u{51FA}\u{6765}\u{FF0C}\u{4E0D}\u{5141}\u{8BB8}\u{6DFB}\u{52A0}\u{4EFB}\u{4F55}\u{8BF4}\u{660E}\u{6216}\u{603B}\u{7ED3}\u{3002}
 
 \u{89C4}\u{5219}\u{FF1A}
-1. \u{539F}\u{6587}\u{7167}\u{6284}\u{FF0C}\u{4FDD}\u{6301}\u{683C}\u{5F0F}
-2. \u{4EE3}\u{7801}\u{7528} \`\`\` \u{5305}\u{88F9}
-3. \u{56FE}\u{7247}/\u{56FE}\u{6807}\u{7528} [\u{56FE}\u{7247}: \u{63CF}\u{8FF0}] \u{6807}\u{6CE8}
-4. \u{7981}\u{6B62}\u{603B}\u{7ED3}\u{3001}\u{7981}\u{6B62}\u{89E3}\u{91CA}
-
-${context ? `\u{8865}\u{5145}\u{FF1A}${context}\n\n` : ''}\u{5F00}\u{59CB}\u{6284}\u{5F55}\u{FF1A}`;
-            const aiResponse = await openAIService.analyzeImageWithPath({
-                image_path: chunkPath,
-                prompt: userPrompt,
-                system_prompt: systemPrompt,
-                temperature: 0,
-                max_tokens: 4000
-            });
-            return aiResponse.trim();
-        }
-        async mergeChunkResults(chunkResults, context) {
-            if (1 === chunkResults.length) return chunkResults[0].content;
-            const chunkedResultsText = chunkResults.map((r)=>`### ${r.chunk.position}\u{533A}\u{57DF}
-${r.content}`).join('\n\n');
-            const mergePrompt = `\u{4EE5}\u{4E0B}\u{662F}\u{540C}\u{4E00}\u{5F20}\u{56FE}\u{7247}\u{4E0D}\u{540C}\u{533A}\u{57DF}\u{7684}\u{8BC6}\u{522B}\u{7ED3}\u{679C}\u{FF0C}\u{8BF7}\u{6574}\u{5408}\u{4E3A}\u{5B8C}\u{6574}\u{7684}\u{56FE}\u{7247}\u{63CF}\u{8FF0}\u{FF1A}
-
-1. \u{5408}\u{5E76}\u{6240}\u{6709}\u{533A}\u{57DF}\u{7684}\u{5185}\u{5BB9}
-2. \u{6D88}\u{9664}\u{91CD}\u{590D}\u{63CF}\u{8FF0}\u{FF08}\u{91CD}\u{53E0}\u{533A}\u{57DF}\u{53EF}\u{80FD}\u{6709}\u{76F8}\u{540C}\u{5185}\u{5BB9}\u{FF09}
-3. \u{4FDD}\u{6301}\u{5185}\u{5BB9}\u{7684}\u{7A7A}\u{95F4}\u{4F4D}\u{7F6E}\u{5173}\u{7CFB}
-4. \u{4E0D}\u{6DFB}\u{52A0}\u{3001}\u{4E0D}\u{4FEE}\u{6539}\u{539F}\u{59CB}\u{8BC6}\u{522B}\u{5230}\u{7684}\u{5185}\u{5BB9}
-
-${context}
+1) \u{539F}\u{6587}\u{7167}\u{6284}\u{FF1A}\u{56FE}\u{7247}\u{91CC}\u{6709}\u{4EC0}\u{4E48}\u{5C31}\u{8F93}\u{51FA}\u{4EC0}\u{4E48}\u{FF0C}\u{4E00}\u{4E2A}\u{5B57}\u{90FD}\u{4E0D}\u{80FD}\u{5C11}\u{6216}\u{6539}
+2) \u{4FDD}\u{6301}\u{683C}\u{5F0F}\u{FF1A}\u{6362}\u{884C}\u{3001}\u{7A7A}\u{683C}\u{3001}\u{7F29}\u{8FDB}\u{3001}\u{5217}\u{8868}\u{7F16}\u{53F7}\u{5168}\u{90E8}\u{4FDD}\u{7559}
+3) \u{4EE3}\u{7801}\u{5757}\u{FF1A}\u{7528} \`\`\` \u{5305}\u{88F9}\u{FF0C}\u{7F29}\u{8FDB}\u{4E0E}\u{7A7A}\u{683C}\u{5FC5}\u{987B}\u{4FDD}\u{6301}
+4) \u{8868}\u{683C}\u{FF1A}\u{7528} markdown \u{8868}\u{683C}\u{8868}\u{793A}
+5) \u{7981}\u{6B62}\u{6DFB}\u{52A0}\u{5F00}\u{573A}\u{767D}\u{FF08}\u{5982}\u{201C}\u{4EE5}\u{4E0B}\u{662F}/\u{4E0B}\u{9762}\u{662F}/\u{6211}\u{5C06}/\u{8FD9}\u{662F}\u{2026}\u{201D}\u{FF09}
+6) \u{7981}\u{6B62}\u{51ED}\u{7A7A}\u{751F}\u{6210}\u{6807}\u{9898}\u{FF08}\u{5982}\u{201C}\u{6838}\u{5FC3}\u{4FE1}\u{606F}/\u{529F}\u{80FD}\u{63CF}\u{8FF0}/\u{63A5}\u{53E3}\u{8BF4}\u{660E}\u{201D}\u{7B49}\u{FF09}\u{3002}\u{5982}\u{679C}\u{8FD9}\u{4E9B}\u{8BCD}\u{51FA}\u{73B0}\u{5728}\u{56FE}\u{7247}\u{91CC}\u{FF0C}\u{6309}\u{539F}\u{6837}\u{8F93}\u{51FA}\u{5373}\u{53EF}
+7) \u{4E0D}\u{8981}\u{7FFB}\u{8BD1}\u{6216}\u{6539}\u{5199}
+`;
+            if (segmentIndex && totalSegments) prompt = `\u{7B2C} ${segmentIndex}/${totalSegments} \u{90E8}\u{5206}
 
-\u{5404}\u{533A}\u{57DF}\u{8BC6}\u{522B}\u{7ED3}\u{679C}\u{FF1A}
-${chunkedResultsText}`;
-            const mergedResult = await openAIService.generateText({
-                prompt: mergePrompt,
-                system_prompt: "\u4F60\u662F\u4E00\u4E2A\u5185\u5BB9\u6574\u5408\u4E13\u5BB6\uFF0C\u64C5\u957F\u5C06\u591A\u4E2A\u7247\u6BB5\u7684\u63CF\u8FF0\u6574\u5408\u4E3A\u5B8C\u6574\u3001\u8FDE\u8D2F\u7684\u6587\u672C\u3002\u4F7F\u7528\u4E2D\u6587\u56DE\u7B54\u3002",
-                temperature: 0.3
-            });
-            return mergedResult.trim();
-        }
-        async getImageBasicInfo(imagePath) {
-            try {
-                const metadata = await external_sharp_default()(imagePath).metadata();
-                const stats = await promises_.stat(imagePath);
-                return {
-                    path: imagePath,
-                    format: metadata.format || "unknown",
-                    dimensions: {
-                        width: metadata.width || 0,
-                        height: metadata.height || 0
-                    },
-                    file_size: stats.size
-                };
-            } catch (error) {
-                throw new ImageAnalysisError(`\u{65E0}\u{6CD5}\u{8BFB}\u{53D6}\u{56FE}\u{7247}\u{4FE1}\u{606F}: ${imagePath}`, types_AnalysisErrorCodes.IMAGE_CORRUPTED, {
-                    imagePath,
-                    originalError: error
-                });
-            }
-        }
-        async validateParams(imagePath) {
-            try {
-                await promises_.access(imagePath);
-            } catch  {
-                throw new ImageAnalysisError(`\u{56FE}\u{7247}\u{6587}\u{4EF6}\u{4E0D}\u{5B58}\u{5728}: ${imagePath}`, types_AnalysisErrorCodes.FILE_NOT_FOUND, {
-                    imagePath: imagePath
-                });
-            }
-            const ext = external_path_.extname(imagePath).slice(1).toLowerCase();
-            if (!SUPPORTED_IMAGE_FORMATS.includes(ext)) throw new ImageAnalysisError(`\u{4E0D}\u{652F}\u{6301}\u{7684}\u{56FE}\u{7247}\u{683C}\u{5F0F}: ${ext}`, types_AnalysisErrorCodes.UNSUPPORTED_FORMAT, {
-                format: ext,
-                supportedFormats: SUPPORTED_IMAGE_FORMATS
-            });
+${prompt}`;
+            if (context) prompt += `
+\u{4E0A}\u{4E0B}\u{6587}\u{63D0}\u{793A}\u{FF08}\u{4EC5}\u{4F9B}\u{4F60}\u{7406}\u{89E3}\u{FF0C}\u{4E0D}\u{5F97}\u{5199}\u{5165}\u{8F93}\u{51FA}\u{FF09}\u{FF1A}${context}`;
+            return prompt;
         }
     }
     const ImageAnalysisParamsSchema = objectType({
@@ -12298,7 +12771,8 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
         usersFile;
         constructor(){
             try {
-                const storageDir = (0, utils_config.WR)();
+                const homeDir = process.env.HOME || process.env.USERPROFILE || "/tmp";
+                const storageDir = external_path_.join(homeDir, ".aico");
                 this.dataDir = external_path_.join(storageDir, "lark");
                 this.usersFile = external_path_.join(this.dataDir, "users.json");
                 this.ensureDataDir();
@@ -12526,12 +13000,16 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
     });
     const createDocTool = {
         name: "lark_doc_create",
-        description: "[\u521B\u5EFA\u65B0\u6587\u6863] \u521B\u5EFA\u6606\u4ED1\u667A\u8054\u4E91\u6587\u6863\u5E76\u5199\u5165\u5185\u5BB9\u3002\u4F7F\u7528\u573A\u666F: \u7528\u6237\u8981\u6C42\u521B\u5EFA/\u65B0\u5EFA/\u7F16\u5199/\u751F\u6210\u4E00\u4E2A\u65B0\u7684\u6587\u6863\u4E14\u6CA1\u6709\u63D0\u4F9B\u5DF2\u6709\u6587\u6863ID\u6216\u94FE\u63A5\u65F6\u4F7F\u7528\u3002\u5982\u679C\u7528\u6237\u63D0\u4F9B\u4E86\u6587\u6863ID\u6216\u94FE\u63A5\u8981\u6C42\u66F4\u65B0\u5185\u5BB9,\u8BF7\u4F7F\u7528lark_doc_append\u3002\u5FC5\u987B\u63D0\u4F9Bemail\u53C2\u6570",
+        description: `\u{3010}\u{521B}\u{5EFA}\u{4E91}\u{6587}\u{6863}\u{9996}\u{9009}\u{3011}\u{521B}\u{5EFA}\u{6606}\u{4ED1}\u{667A}\u{8054}\u{4E91}\u{6587}\u{6863}\u{5E76}\u{5199}\u{5165}\u{5185}\u{5BB9}\u{3002}
+\u{4F7F}\u{7528}\u{573A}\u{666F}: \u{7528}\u{6237}\u{8BF4}"\u{5E2E}\u{6211}\u{5199}\u{4E00}\u{4E2A}XXX\u{6587}\u{6863}/\u{62A5}\u{544A}/\u{8BF4}\u{660E}/\u{65B9}\u{6848}"\u{65F6}\u{4F7F}\u{7528}\u{6B64}\u{5DE5}\u{5177}\u{3002}
+\u{793A}\u{4F8B}: "\u{5199}\u{4E00}\u{4E2A}\u{4F1A}\u{8BAE}\u{7EAA}\u{8981}" \u{2192} title="\u{4F1A}\u{8BAE}\u{7EAA}\u{8981}", blocks=[{type:"h1",content:"\u{4F1A}\u{8BAE}\u{4E3B}\u{9898}"},{type:"text",content:"\u{5185}\u{5BB9}..."}]
+\u{5757}\u{7C7B}\u{578B}: text=\u{6587}\u{672C}, h1-h6=\u{6807}\u{9898}, bullet=\u{65E0}\u{5E8F}\u{5217}\u{8868}, ordered=\u{6709}\u{5E8F}\u{5217}\u{8868}, code=\u{4EE3}\u{7801}, quote=\u{5F15}\u{7528}, todo=\u{5F85}\u{529E}, callout=\u{9AD8}\u{4EAE}, divider=\u{5206}\u{5272}\u{7EBF}
+\u{26A0}\u{FE0F} \u{5FC5}\u{987B}\u{63D0}\u{4F9B}email\u{53C2}\u{6570}\u{FF0C}\u{8BF7}\u{5148}\u{8BE2}\u{95EE}\u{7528}\u{6237}\u{90AE}\u{7BB1}\u{FF01}\u{6210}\u{529F}\u{540E}\u{4EC5}\u{8FD4}\u{56DE}\u{6587}\u{6863}\u{94FE}\u{63A5}\u{3002}`,
         inputSchema: {
-            title: stringType().describe("\u6587\u6863\u6807\u9898"),
-            blocks: arrayType(blockSchema).optional().describe("\u6587\u6863\u5185\u5BB9\u5757\u6570\u7EC4,\u6309\u987A\u5E8F\u5199\u5165\u6587\u6863"),
-            folder: stringType().optional().describe("\u6587\u4EF6\u5939token"),
-            email: stringType().describe("\u6240\u6709\u8005\u90AE\u7BB1(\u5FC5\u586B)")
+            title: stringType().describe("\u6587\u6863\u6807\u9898(\u5982: \u4F1A\u8BAE\u7EAA\u8981, \u9879\u76EE\u65B9\u6848)"),
+            blocks: arrayType(blockSchema).optional().describe("\u6587\u6863\u5185\u5BB9\u5757\u6570\u7EC4\u3002\u793A\u4F8B: [{type:'h1',content:'\u6807\u9898'},{type:'text',content:'\u5185\u5BB9'}]"),
+            folder: stringType().optional().describe("\u6587\u4EF6\u5939token(\u53EF\u9009)"),
+            email: stringType().describe("\u6240\u6709\u8005\u90AE\u7BB1\u3010\u5FC5\u586B\u3011- \u8BF7\u5148\u8BE2\u95EE\u7528\u6237\u90AE\u7BB1\u5730\u5740")
         },
         handler: async (args)=>{
             const client = getLarkClient();
@@ -12569,12 +13047,14 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
     };
     const importMarkdownTool = {
         name: "lark_doc_import_md",
-        description: "\u5C06Markdown\u5185\u5BB9\u5BFC\u5165\u4E3A\u6606\u4ED1\u667A\u8054\u4E91\u6587\u6863,\u8FD4\u56DE\u6587\u6863\u94FE\u63A5\u3002\u5FC5\u987B\u63D0\u4F9Bemail\u53C2\u6570",
+        description: `\u{5C06}Markdown\u{5185}\u{5BB9}\u{5BFC}\u{5165}\u{4E3A}\u{6606}\u{4ED1}\u{667A}\u{8054}\u{4E91}\u{6587}\u{6863}\u{3002}
+\u{4F7F}\u{7528}\u{573A}\u{666F}: \u{7528}\u{6237}\u{63D0}\u{4F9B}\u{4E86}Markdown\u{683C}\u{5F0F}\u{5185}\u{5BB9},\u{8981}\u{6C42}\u{8F6C}\u{4E3A}\u{4E91}\u{6587}\u{6863}\u{3002}
+\u{26A0}\u{FE0F} \u{5FC5}\u{987B}\u{63D0}\u{4F9B}email\u{53C2}\u{6570}\u{FF01}`,
         inputSchema: {
             md: stringType().describe("Markdown\u5185\u5BB9"),
             title: stringType().optional().describe("\u6587\u6863\u6807\u9898"),
-            folder: stringType().optional().describe("\u6587\u4EF6\u5939token"),
-            email: stringType().describe("\u6240\u6709\u8005\u90AE\u7BB1(\u5FC5\u586B)")
+            folder: stringType().optional().describe("\u6587\u4EF6\u5939token(\u53EF\u9009)"),
+            email: stringType().describe("\u6240\u6709\u8005\u90AE\u7BB1\u3010\u5FC5\u586B\u3011")
         },
         handler: async (args)=>{
             const client = getLarkClient();
@@ -12624,9 +13104,10 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
     };
     const getDocContentTool = {
         name: "lark_doc_content",
-        description: "\u83B7\u53D6\u4E91\u6587\u6863\u7684\u7EAF\u6587\u672C\u5185\u5BB9",
+        description: `\u{83B7}\u{53D6}\u{4E91}\u{6587}\u{6863}\u{7684}\u{7EAF}\u{6587}\u{672C}\u{5185}\u{5BB9}\u{3002}
+\u{4F7F}\u{7528}\u{573A}\u{666F}: \u{9700}\u{8981}\u{8BFB}\u{53D6}\u{67D0}\u{4E2A}\u{6587}\u{6863}\u{5185}\u{5BB9}\u{65F6}\u{4F7F}\u{7528}\u{3002}`,
         inputSchema: {
-            id: stringType().describe("\u6587\u6863ID")
+            id: stringType().describe("\u6587\u6863ID(\u4ECE\u94FE\u63A5\u4E2D\u63D0\u53D6,\u5982https://xxx/docx/ABC123\u5219ID\u4E3AABC123)")
         },
         handler: async (args)=>{
             const client = getLarkClient();
@@ -12643,7 +13124,8 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
     };
     const searchDocsTool = {
         name: "lark_doc_search",
-        description: "\u641C\u7D22\u6606\u4ED1\u667A\u8054\u4E91\u6587\u6863",
+        description: `\u{641C}\u{7D22}\u{6606}\u{4ED1}\u{667A}\u{8054}\u{4E91}\u{6587}\u{6863}\u{3002}
+\u{4F7F}\u{7528}\u{573A}\u{666F}: \u{7528}\u{6237}\u{8981}\u{6C42}\u{67E5}\u{627E}/\u{641C}\u{7D22}\u{67D0}\u{4E2A}\u{6587}\u{6863}\u{65F6}\u{4F7F}\u{7528}\u{3002}`,
         inputSchema: {
             q: stringType().describe("\u641C\u7D22\u5173\u952E\u8BCD"),
             types: arrayType(enumType([
@@ -12651,8 +13133,8 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
                 "sheet",
                 "bitable",
                 "docx"
-            ])).optional().describe("\u6587\u6863\u7C7B\u578B"),
-            limit: numberType().optional().describe("\u8FD4\u56DE\u6570\u91CF,\u9ED8\u8BA420")
+            ])).optional().describe("\u6587\u6863\u7C7B\u578B: doc=\u65E7\u7248\u6587\u6863, docx=\u65B0\u7248\u6587\u6863, sheet=\u8868\u683C, bitable=\u591A\u7EF4\u8868\u683C"),
+            limit: numberType().optional().describe("\u8FD4\u56DE\u6570\u91CF(\u9ED8\u8BA420)")
         },
         handler: async (args)=>{
             const client = getLarkClient();
@@ -12680,10 +13162,12 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
     };
     const appendDocTool = {
         name: "lark_doc_append",
-        description: "[\u66F4\u65B0\u5DF2\u6709\u6587\u6863] \u5411\u5DF2\u6709\u4E91\u6587\u6863\u8FFD\u52A0\u5185\u5BB9\u3002\u4F7F\u7528\u573A\u666F: \u7528\u6237\u63D0\u4F9B\u4E86\u6587\u6863ID\u6216\u6587\u6863\u94FE\u63A5,\u8981\u6C42\u66F4\u65B0/\u4FEE\u6539/\u8FFD\u52A0/\u8865\u5145\u5185\u5BB9\u65F6\u4F7F\u7528\u3002\u5982\u679C\u7528\u6237\u8981\u6C42\u521B\u5EFA\u65B0\u6587\u6863,\u8BF7\u4F7F\u7528lark_doc_create",
+        description: `\u{5411}\u{5DF2}\u{6709}\u{4E91}\u{6587}\u{6863}\u{8FFD}\u{52A0}\u{5185}\u{5BB9}\u{3002}
+\u{4F7F}\u{7528}\u{573A}\u{666F}: \u{7528}\u{6237}\u{63D0}\u{4F9B}\u{4E86}\u{6587}\u{6863}ID\u{6216}\u{94FE}\u{63A5},\u{8981}\u{6C42}\u{66F4}\u{65B0}/\u{8FFD}\u{52A0}\u{5185}\u{5BB9}\u{65F6}\u{4F7F}\u{7528}\u{3002}
+\u{6CE8}\u{610F}: \u{5982}\u{679C}\u{7528}\u{6237}\u{8981}\u{6C42}\u{521B}\u{5EFA}\u{65B0}\u{6587}\u{6863},\u{8BF7}\u{4F7F}\u{7528}lark_doc_create\u{3002}`,
         inputSchema: {
-            doc: stringType().describe("\u6587\u6863ID(\u4ECE\u6587\u6863\u94FE\u63A5\u4E2D\u63D0\u53D6,\u5982\u94FE\u63A5\u4E3Ahttps://xxx/docx/ABC123\u5219ID\u4E3AABC123)"),
-            blocks: arrayType(blockSchema).describe("\u8981\u8FFD\u52A0\u7684\u5185\u5BB9\u5757\u6570\u7EC4")
+            doc: stringType().describe("\u6587\u6863ID(\u4ECE\u94FE\u63A5\u4E2D\u63D0\u53D6,\u5982https://xxx/docx/ABC123\u5219ID\u4E3AABC123)"),
+            blocks: arrayType(blockSchema).describe("\u8981\u8FFD\u52A0\u7684\u5185\u5BB9\u5757\u6570\u7EC4\u3002\u793A\u4F8B: [{type:'text',content:'\u65B0\u5185\u5BB9'}]")
         },
         handler: async (args)=>{
             const client = getLarkClient();
@@ -12728,13 +13212,87 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
         if (email) return email;
         return await larkDbOperations.getDefaultEmail();
     }
+    const bitable_tools_fieldSchema = objectType({
+        name: stringType().describe("\u5B57\u6BB5\u540D\u79F0"),
+        type: numberType().describe("\u5B57\u6BB5\u7C7B\u578B: 1=\u6587\u672C, 2=\u6570\u5B57, 3=\u5355\u9009, 4=\u591A\u9009, 5=\u65E5\u671F, 7=\u590D\u9009\u6846, 11=\u4EBA\u5458, 15=\u94FE\u63A5"),
+        options: arrayType(stringType()).optional().describe("\u9009\u9879\u503C(\u4EC5\u5355\u9009/\u591A\u9009\u7C7B\u578B\u9700\u8981)")
+    });
+    const createCompleteBitableTool = {
+        name: "lark_bitable_create_complete",
+        description: `\u{3010}\u{521B}\u{5EFA}\u{591A}\u{7EF4}\u{8868}\u{683C}\u{9996}\u{9009}\u{3011}\u{4E00}\u{6B65}\u{5B8C}\u{6210}\u{521B}\u{5EFA}\u{591A}\u{7EF4}\u{8868}\u{683C}\u{3001}\u{6570}\u{636E}\u{8868}\u{3001}\u{5B57}\u{6BB5}\u{5B9A}\u{4E49}\u{3002}
+\u{4F7F}\u{7528}\u{573A}\u{666F}: \u{7528}\u{6237}\u{8BF4}"\u{5E2E}\u{6211}\u{521B}\u{5EFA}\u{4E00}\u{4E2A}\u{7EDF}\u{8BA1}XXX\u{7684}\u{591A}\u{7EF4}\u{8868}\u{683C}/\u{8868}\u{683C}"\u{65F6}\u{4F7F}\u{7528}\u{6B64}\u{5DE5}\u{5177}\u{3002}
+\u{793A}\u{4F8B}: "\u{521B}\u{5EFA}\u{4E00}\u{4E2A}\u{5458}\u{5DE5}\u{624B}\u{673A}\u{53F7}\u{7EDF}\u{8BA1}\u{8868}\u{683C}" \u{2192} name="\u{5458}\u{5DE5}\u{624B}\u{673A}\u{53F7}\u{7EDF}\u{8BA1}", tableName="\u{5458}\u{5DE5}\u{4FE1}\u{606F}", fields=[{name:"\u{59D3}\u{540D}",type:1},{name:"\u{90E8}\u{95E8}",type:1},{name:"\u{624B}\u{673A}\u{53F7}",type:1}]
+\u{5B57}\u{6BB5}\u{7C7B}\u{578B}: 1=\u{6587}\u{672C}, 2=\u{6570}\u{5B57}, 3=\u{5355}\u{9009}, 4=\u{591A}\u{9009}, 5=\u{65E5}\u{671F}, 7=\u{590D}\u{9009}\u{6846}, 11=\u{4EBA}\u{5458}, 15=\u{94FE}\u{63A5}
+\u{26A0}\u{FE0F} \u{5FC5}\u{987B}\u{63D0}\u{4F9B}email\u{53C2}\u{6570}\u{FF0C}\u{8BF7}\u{5148}\u{8BE2}\u{95EE}\u{7528}\u{6237}\u{90AE}\u{7BB1}\u{FF01}\u{6210}\u{529F}\u{540E}\u{4EC5}\u{8FD4}\u{56DE}\u{8868}\u{683C}\u{94FE}\u{63A5}\u{3002}`,
+        inputSchema: {
+            name: stringType().describe("\u591A\u7EF4\u8868\u683C\u540D\u79F0(\u5982: \u5458\u5DE5\u4FE1\u606F\u7EDF\u8BA1)"),
+            tableName: stringType().describe("\u6570\u636E\u8868\u540D\u79F0(\u5982: \u5458\u5DE5\u5217\u8868)"),
+            fields: arrayType(bitable_tools_fieldSchema).describe("\u5B57\u6BB5\u5B9A\u4E49\u6570\u7EC4\u3002\u793A\u4F8B: [{name:'\u59D3\u540D',type:1},{name:'\u5E74\u9F84',type:2}]"),
+            records: arrayType(recordType(anyType())).optional().describe("\u521D\u59CB\u6570\u636E(\u53EF\u9009),\u5B57\u6BB5\u540D\u4E3Akey\u3002\u793A\u4F8B: [{\u59D3\u540D:'\u5F20\u4E09',\u5E74\u9F84:25}]"),
+            folder: stringType().optional().describe("\u6587\u4EF6\u5939token(\u53EF\u9009)"),
+            email: stringType().describe("\u6240\u6709\u8005\u90AE\u7BB1\u3010\u5FC5\u586B\u3011- \u8BF7\u5148\u8BE2\u95EE\u7528\u6237\u90AE\u7BB1\u5730\u5740")
+        },
+        handler: async (args)=>{
+            const client = getLarkClient();
+            try {
+                const email = await bitable_tools_getEmail(args.email);
+                if (!email) return bitable_tools_formatResponse(false, null, "\u8BF7\u63D0\u4F9B\u90AE\u7BB1(email)\u53C2\u6570,\u7528\u4E8E\u8BBE\u7F6E\u8868\u683C\u6240\u6709\u8005\u3002\u8BF7\u8BE2\u95EE\u7528\u6237\u7684\u90AE\u7BB1\u5730\u5740");
+                const createRes = await client.post("/open-apis/bitable/v1/apps", {
+                    name: args.name,
+                    folder_token: args.folder
+                });
+                if (0 !== createRes.code) throw new Error(createRes.msg);
+                const appToken = createRes.data?.app?.app_token;
+                if (!appToken) throw new Error("\u521B\u5EFA\u8868\u683C\u5931\u8D25,\u672A\u83B7\u53D6\u5230token");
+                const url = createRes.data?.app?.url || client.buildDocUrl(appToken, "bitable");
+                const fields = args.fields.map((f)=>{
+                    const field = {
+                        field_name: f.name,
+                        type: f.type
+                    };
+                    if ((3 === f.type || 4 === f.type) && f.options?.length) field.property = {
+                        options: f.options.map((opt)=>({
+                                name: opt
+                            }))
+                    };
+                    return field;
+                });
+                const tableRes = await client.post(`/open-apis/bitable/v1/apps/${appToken}/tables`, {
+                    table: {
+                        name: args.tableName,
+                        fields
+                    }
+                });
+                if (0 !== tableRes.code) throw new Error(tableRes.msg);
+                const tableId = tableRes.data?.table_id;
+                if (args.records && args.records.length > 0 && tableId) {
+                    const records = args.records.map((r)=>({
+                            fields: r
+                        }));
+                    await client.post(`/open-apis/bitable/v1/apps/${appToken}/tables/${tableId}/records/batch_create`, {
+                        records
+                    });
+                }
+                const ok = await client.transferOwnerByEmail(appToken, "bitable", email);
+                if (ok) await larkDbOperations.saveUser({
+                    email
+                });
+                return bitable_tools_formatResponse(true, {
+                    url
+                });
+            } catch (error) {
+                return bitable_tools_formatResponse(false, null, error.message);
+            }
+        }
+    };
     const createBitableTool = {
         name: "lark_bitable_create",
-        description: "[\u521B\u5EFA\u65B0\u8868\u683C] \u521B\u5EFA\u6606\u4ED1\u667A\u8054\u591A\u7EF4\u8868\u683C,\u8FD4\u56DE\u8868\u683C\u94FE\u63A5\u3002\u4F7F\u7528\u573A\u666F: \u7528\u6237\u8981\u6C42\u521B\u5EFA/\u65B0\u5EFA\u4E00\u4E2A\u65B0\u7684\u591A\u7EF4\u8868\u683C\u4E14\u6CA1\u6709\u63D0\u4F9B\u5DF2\u6709\u8868\u683CID\u6216\u94FE\u63A5\u65F6\u4F7F\u7528\u3002\u5982\u679C\u7528\u6237\u63D0\u4F9B\u4E86\u8868\u683CID\u6216\u94FE\u63A5\u8981\u6C42\u6DFB\u52A0\u6570\u636E,\u8BF7\u4F7F\u7528lark_bitable_add_record\u6216lark_bitable_batch_records\u3002\u5FC5\u987B\u63D0\u4F9Bemail\u53C2\u6570",
+        description: `\u{521B}\u{5EFA}\u{7A7A}\u{767D}\u{591A}\u{7EF4}\u{8868}\u{683C}\u{3002}\u{5982}\u{9700}\u{540C}\u{65F6}\u{521B}\u{5EFA}\u{5B57}\u{6BB5},\u{63A8}\u{8350}\u{4F7F}\u{7528}lark_bitable_create_complete\u{3002}
+\u{26A0}\u{FE0F} \u{5FC5}\u{987B}\u{63D0}\u{4F9B}email\u{53C2}\u{6570}\u{FF01}`,
         inputSchema: {
             name: stringType().describe("\u8868\u683C\u540D\u79F0"),
             folder: stringType().optional().describe("\u6587\u4EF6\u5939token"),
-            email: stringType().describe("\u6240\u6709\u8005\u90AE\u7BB1(\u5FC5\u586B)")
+            email: stringType().describe("\u6240\u6709\u8005\u90AE\u7BB1\u3010\u5FC5\u586B\u3011")
         },
         handler: async (args)=>{
             const client = getLarkClient();
@@ -13003,6 +13561,7 @@ ${failedProjects.map((p)=>`- ${p.projectName}: ${p.errorMessage}`).join("\n")}
         }
     };
     const bitableTools = [
+        createCompleteBitableTool,
         createBitableTool,
         createTableTool,
         listTablesTool,