hanseol-dev 5.0.2-dev.53 → 5.0.2-dev.55

package/dist/agents/office/powerpoint-create-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powerpoint-create-agent.d.ts","sourceRoot":"","sources":["../../../src/agents/office/powerpoint-create-agent.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,YAAY,EAAc,MAAM,sBAAsB,CAAC;AA6ahE,wBAAgB,iCAAiC,IAAI,YAAY,CA2BhE"}
+{"version":3,"file":"powerpoint-create-agent.d.ts","sourceRoot":"","sources":["../../../src/agents/office/powerpoint-create-agent.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,YAAY,EAAc,MAAM,sBAAsB,CAAC;AAiiBhE,wBAAgB,iCAAiC,IAAI,YAAY,CA2BhE"}

package/dist/agents/office/powerpoint-create-agent.js

@@ -1,23 +1,24 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { POWERPOINT_CREATE_TOOLS } from '../../tools/office/powerpoint-tools.js';
-import { resetLayoutCounters } from '../../tools/office/powerpoint-tools/layout-builders.js';
+import { powerpointClient } from '../../tools/office/powerpoint-client.js';
 import { SubAgent } from '../common/sub-agent.js';
 import { getSubAgentPhaseLogger, getSubAgentToolCallLogger } from '../common/sub-agent.js';
 import { logger } from '../../utils/logger.js';
-import { PPT_CREATE_SYSTEM_PROMPT, PPT_CREATE_PLANNING_PROMPT, PPT_CREATE_ENHANCEMENT_PROMPT, PPT_STRUCTURED_PLANNING_PROMPT, buildSlideSystemPrompt, } from './powerpoint-create-prompts.js';
-const VALID_SLIDE_TOOLS = new Set([
-    'ppt_build_title_slide',
-    'ppt_build_layout_a',
-    'ppt_build_layout_b',
-    'ppt_build_layout_c',
-    'ppt_build_layout_d',
-    'ppt_build_layout_e',
-    'ppt_build_layout_f',
-    'ppt_build_closing_slide',
-]);
-const VALID_COLOR_SCHEMES = new Set([
-    'MODERN_TECH', 'WARM_EXECUTIVE', 'CLEAN_MINIMAL', 'CORPORATE', 'NATURE_FRESH', 'BOLD_MODERN',
-]);
-const VALID_DESIGN_STYLES = new Set(['sidebar', 'top_band', 'clean']);
+import { getPlatform } from '../../utils/platform-utils.js';
+import { PPT_CREATE_SYSTEM_PROMPT, PPT_CREATE_PLANNING_PROMPT, PPT_CREATE_ENHANCEMENT_PROMPT, PPT_STRUCTURED_PLANNING_PROMPT, buildSlideHtmlPrompt, } from './powerpoint-create-prompts.js';
+const DEFAULT_DESIGN = {
+    primary_color: '#1B2A4A',
+    accent_color: '#00D4AA',
+    background_color: '#FFFFFF',
+    text_color: '#1A1A2E',
+    accent_light: '#E8F5F0',
+    gradient_end: '#2D5F8A',
+    font_title: 'Segoe UI',
+    font_body: 'Malgun Gothic',
+    mood: 'modern-minimal',
+    design_notes: 'Clean gradients, card-based layouts',
+};
 function extractContent(msg) {
     const content = msg['content'];
     if (content && content.trim())
@@ -28,80 +29,142 @@ function extractContent(msg) {
     return '';
 }
 function validatePlan(plan) {
-    if (!plan.design?.color_scheme || !plan.design?.design_style) {
-        return 'Missing design.color_scheme or design.design_style';
-    }
-    if (!VALID_COLOR_SCHEMES.has(plan.design.color_scheme)) {
-        return `Invalid color_scheme: ${plan.design.color_scheme}`;
-    }
-    if (!VALID_DESIGN_STYLES.has(plan.design.design_style)) {
-        return `Invalid design_style: ${plan.design.design_style}`;
+    if (!plan.design)
+        return 'Missing design object';
+    if (!plan.design.primary_color || !plan.design.accent_color) {
+        return 'Missing design colors (primary_color, accent_color)';
     }
     if (!Array.isArray(plan.slides) || plan.slides.length < 3) {
         return 'slides array must have at least 3 entries';
     }
-    if (plan.slides[0]?.tool !== 'ppt_build_title_slide') {
-        return 'First slide must be ppt_build_title_slide';
+    if (plan.slides[0]?.type !== 'title') {
+        return 'First slide must be type "title"';
     }
-    if (plan.slides[plan.slides.length - 1]?.tool !== 'ppt_build_closing_slide') {
-        return 'Last slide must be ppt_build_closing_slide';
+    if (plan.slides[plan.slides.length - 1]?.type !== 'closing') {
+        return 'Last slide must be type "closing"';
     }
     for (let i = 0; i < plan.slides.length; i++) {
-        const s = plan.slides[i];
-        if (!VALID_SLIDE_TOOLS.has(s.tool)) {
-            return `Slide ${i + 1}: invalid tool "${s.tool}"`;
-        }
-        if (!s.title) {
+        if (!plan.slides[i].title) {
             return `Slide ${i + 1}: missing title`;
         }
     }
-    const counts = {};
-    for (const s of plan.slides) {
-        counts[s.tool] = (counts[s.tool] || 0) + 1;
-    }
-    if ((counts['ppt_build_layout_a'] || 0) > 3) {
-        return `Layout A count ${counts['ppt_build_layout_a']} exceeds max 3`;
-    }
-    if ((counts['ppt_build_layout_b'] || 0) > 4) {
-        return `Layout B count ${counts['ppt_build_layout_b']} exceeds max 4`;
-    }
-    if ((counts['ppt_build_layout_d'] || 0) > 3) {
-        return `Layout D count ${counts['ppt_build_layout_d']} exceeds max 3`;
-    }
-    const layoutTypes = new Set(plan.slides
-        .map(s => s.tool)
-        .filter(t => t.startsWith('ppt_build_layout_')));
-    if (layoutTypes.size < 5) {
-        return `Only ${layoutTypes.size} layout types used, need at least 5`;
-    }
     return null;
 }
 function parseJsonPlan(raw) {
     let cleaned = raw.trim();
     if (cleaned.startsWith('```')) {
-        cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+        cleaned = cleaned.replace(/^```(?:json|JSON)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+    }
+    const firstBrace = cleaned.indexOf('{');
+    if (firstBrace > 0) {
+        cleaned = cleaned.slice(firstBrace);
+    }
+    const lastBrace = cleaned.lastIndexOf('}');
+    if (lastBrace >= 0 && lastBrace < cleaned.length - 1) {
+        cleaned = cleaned.slice(0, lastBrace + 1);
     }
     try {
         return JSON.parse(cleaned);
     }
-    catch {
+    catch (e) {
+        logger.debug('parseJsonPlan: first parse attempt failed', { error: String(e), length: cleaned.length });
         const match = cleaned.match(/\{[\s\S]*\}/);
         if (match) {
             try {
                 return JSON.parse(match[0]);
             }
             catch {
-                return null;
+                try {
+                    let repaired = match[0];
+                    let braces = 0, brackets = 0;
+                    let inString = false, escape = false;
+                    for (const ch of repaired) {
+                        if (escape) {
+                            escape = false;
+                            continue;
+                        }
+                        if (ch === '\\') {
+                            escape = true;
+                            continue;
+                        }
+                        if (ch === '"') {
+                            inString = !inString;
+                            continue;
+                        }
+                        if (inString)
+                            continue;
+                        if (ch === '{')
+                            braces++;
+                        else if (ch === '}')
+                            braces--;
+                        else if (ch === '[')
+                            brackets++;
+                        else if (ch === ']')
+                            brackets--;
+                    }
+                    if (inString)
+                        repaired += '"';
+                    for (let i = 0; i < brackets; i++)
+                        repaired += ']';
+                    for (let i = 0; i < braces; i++)
+                        repaired += '}';
+                    return JSON.parse(repaired);
+                }
+                catch {
+                    return null;
+                }
             }
         }
         return null;
     }
 }
+function extractHtml(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('<!DOCTYPE') || trimmed.startsWith('<html')) {
+        return trimmed;
+    }
+    const fenceMatch = trimmed.match(/```(?:html)?\s*\n([\s\S]*?)\n```/);
+    if (fenceMatch?.[1]) {
+        return fenceMatch[1].trim();
+    }
+    const docMatch = trimmed.match(/(<!DOCTYPE[\s\S]*<\/html>)/i);
+    if (docMatch?.[1]) {
+        return docMatch[1].trim();
+    }
+    return null;
+}
+function getTempDir() {
+    const platform = getPlatform();
+    if (platform === 'wsl') {
+        return { writePath: '/mnt/c/temp', winPath: 'C:\\temp' };
+    }
+    return { writePath: 'C:\\temp', winPath: 'C:\\temp' };
+}
+function ensureTempDir(writePath) {
+    if (!fs.existsSync(writePath)) {
+        fs.mkdirSync(writePath, { recursive: true });
+    }
+}
+function normalizeDesign(raw) {
+    return {
+        primary_color: raw['primary_color'] || DEFAULT_DESIGN.primary_color,
+        accent_color: raw['accent_color'] || DEFAULT_DESIGN.accent_color,
+        background_color: raw['background_color'] || DEFAULT_DESIGN.background_color,
+        text_color: raw['text_color'] || DEFAULT_DESIGN.text_color,
+        accent_light: raw['accent_light'] || DEFAULT_DESIGN.accent_light,
+        gradient_end: raw['gradient_end'] || DEFAULT_DESIGN.gradient_end,
+        font_title: raw['font_title'] || DEFAULT_DESIGN.font_title,
+        font_body: raw['font_body'] || DEFAULT_DESIGN.font_body,
+        mood: raw['mood'] || DEFAULT_DESIGN.mood,
+        design_notes: raw['design_notes'] || DEFAULT_DESIGN.design_notes,
+    };
+}
 async function runStructured(llmClient, instruction) {
     const startTime = Date.now();
     const phaseLogger = getSubAgentPhaseLogger();
     const toolCallLogger = getSubAgentToolCallLogger();
     let totalToolCalls = 0;
+    const timestamp = Date.now();
     logger.enter('PPT-Create.runStructured');
     const hasKorean = /[\uac00-\ud7af\u1100-\u11ff]/.test(instruction);
     const language = hasKorean ? 'ko' : 'en';
@@ -115,7 +178,7 @@ async function runStructured(llmClient, instruction) {
                 { role: 'user', content: instruction },
             ],
             temperature: 0.5,
-            max_tokens: 800,
+            max_tokens: 1200,
         });
         const enhMsg = enhRes.choices[0]?.message;
         guidance = enhMsg ? extractContent(enhMsg) : '';
@@ -138,18 +201,49 @@ async function runStructured(llmClient, instruction) {
                 { role: 'user', content: enhancedInstruction },
             ],
             temperature: 0.4,
-            max_tokens: 2000,
+            max_tokens: 8000,
         });
         const planMsg = planRes.choices[0]?.message;
+        const finishReason = planRes.choices[0]?.finish_reason;
         const rawPlan = planMsg ? extractContent(planMsg) : '';
+        if (finishReason === 'length') {
+            logger.warn('PPT planning response was truncated (finish_reason=length)');
+        }
+        logger.debug('PPT planning raw response', { length: rawPlan.length, finishReason, first200: rawPlan.slice(0, 200) });
         plan = rawPlan ? parseJsonPlan(rawPlan) : null;
         if (plan) {
+            plan.design = normalizeDesign(plan.design);
             const validationError = validatePlan(plan);
             if (validationError) {
                 logger.warn('PPT plan validation failed', { error: validationError });
                 if (phaseLogger)
-                    phaseLogger('powerpoint-create', 'planning', `Validation failed: ${validationError}. Falling back.`);
-                plan = null;
+                    phaseLogger('powerpoint-create', 'planning', `Validation failed: ${validationError}. Retrying...`);
+                const retryRes = await llmClient.chatCompletion({
+                    messages: [
+                        { role: 'system', content: PPT_STRUCTURED_PLANNING_PROMPT },
+                        { role: 'user', content: enhancedInstruction },
+                    ],
+                    temperature: 0.2,
+                    max_tokens: 8000,
+                });
+                const retryMsg = retryRes.choices[0]?.message;
+                const retryRaw = retryMsg ? extractContent(retryMsg) : '';
+                const retryPlan = retryRaw ? parseJsonPlan(retryRaw) : null;
+                if (retryPlan) {
+                    retryPlan.design = normalizeDesign(retryPlan.design);
+                    const retryError = validatePlan(retryPlan);
+                    if (!retryError) {
+                        plan = retryPlan;
+                        if (phaseLogger)
+                            phaseLogger('powerpoint-create', 'planning', `Retry succeeded (${plan.slides.length} slides)`);
+                    }
+                    else {
+                        plan = null;
+                    }
+                }
+                else {
+                    plan = null;
+                }
             }
             else {
                 if (phaseLogger)
@@ -182,147 +276,171 @@ async function runStructured(llmClient, instruction) {
         return agent.run(instruction);
     }
     if (phaseLogger)
-        phaseLogger('powerpoint-create', 'execution', 'Starting slide-by-slide execution...');
-    const toolMap = new Map();
-    for (const tool of POWERPOINT_CREATE_TOOLS) {
-        toolMap.set(tool.definition.function.name, tool);
-    }
+        phaseLogger('powerpoint-create', 'execution', 'Starting HTML rendering pipeline...');
+    const { writePath: tempWritePath, winPath: tempWinPath } = getTempDir();
+    ensureTempDir(tempWritePath);
     const pathMatch = instruction.match(/([A-Za-z]:\\[^\s,]+\.pptx|\/[^\s,]+\.pptx)/i);
     const savePath = pathMatch ? pathMatch[1] : undefined;
-    const createTool = toolMap.get('powerpoint_create');
-    if (!createTool) {
-        return { success: false, error: 'powerpoint_create tool not found' };
-    }
-    resetLayoutCounters();
-    const createResult = await createTool.execute({ reason: 'Creating new presentation' });
+    const createResult = await powerpointClient.powerpointCreate();
     totalToolCalls++;
     if (toolCallLogger)
-        toolCallLogger('powerpoint-create', 'powerpoint_create', { reason: 'Creating new presentation' }, createResult.result || createResult.error || '', createResult.success, 0, totalToolCalls);
+        toolCallLogger('powerpoint-create', 'powerpoint_create', {}, createResult.success ? 'Created' : createResult['error'] || '', createResult.success, 0, totalToolCalls);
     if (!createResult.success) {
-        return { success: false, error: `Failed to create presentation: ${createResult.error}` };
+        return { success: false, error: `Failed to create presentation: ${createResult['error']}` };
+    }
+    const titleSlide = plan.slides.find(s => s.type === 'title');
+    if (titleSlide) {
+        const kstNow = new Date(Date.now() + 9 * 60 * 60 * 1000);
+        const kstDate = `${kstNow.getUTCFullYear()}년 ${kstNow.getUTCMonth() + 1}월`;
+        titleSlide.content_direction = (titleSlide.content_direction || '') + `\nDate text to display: ${kstDate}`;
     }
     const builtSlides = [];
+    let failCount = 0;
+    const tempFiles = [];
     for (let i = 0; i < plan.slides.length; i++) {
         const slidePlan = plan.slides[i];
         const slideNum = i + 1;
-        const tool = toolMap.get(slidePlan.tool);
-        if (!tool) {
-            logger.warn(`Tool ${slidePlan.tool} not found, skipping slide ${slideNum}`);
-            continue;
+        if (failCount >= 3) {
+            logger.warn('Too many slide failures, stopping');
+            break;
         }
-        if (slidePlan.tool === 'ppt_build_title_slide') {
-            const kstNow = new Date(Date.now() + 9 * 60 * 60 * 1000);
-            const kstDate = `${kstNow.getUTCFullYear()}년 ${kstNow.getUTCMonth() + 1}월`;
-            const args = {
-                title: slidePlan.title,
-                subtitle: slidePlan.params?.['subtitle'] || '',
-                date_text: kstDate,
-                color_scheme: plan.design.color_scheme,
-                design_style: plan.design.design_style,
-            };
-            const result = await tool.execute(args);
-            totalToolCalls++;
-            if (toolCallLogger)
-                toolCallLogger('powerpoint-create', slidePlan.tool, args, result.result || result.error || '', result.success, slideNum, totalToolCalls);
-            if (result.success) {
-                builtSlides.push(`Slide ${slideNum}: ${slidePlan.title} (title)`);
-            }
-            else {
-                logger.warn(`Title slide failed: ${result.error}`);
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'execution', `Rendering slide ${slideNum}/${plan.slides.length}: ${slidePlan.title}`);
+        const htmlPrompt = buildSlideHtmlPrompt(slidePlan.title, slidePlan.content_direction || '', plan.design, i, plan.slides.length, language);
+        let html = null;
+        try {
+            const htmlRes = await llmClient.chatCompletion({
+                messages: [
+                    { role: 'system', content: htmlPrompt },
+                    { role: 'user', content: 'Generate the HTML slide now.' },
+                ],
+                temperature: 0.3,
+                max_tokens: 8000,
+            });
+            const htmlMsg = htmlRes.choices[0]?.message;
+            const rawHtml = htmlMsg ? extractContent(htmlMsg) : '';
+            html = extractHtml(rawHtml);
+            if (!html && rawHtml.length > 100) {
+                logger.warn(`Slide ${slideNum}: HTML extraction failed, retrying`);
+                const retryRes = await llmClient.chatCompletion({
+                    messages: [
+                        { role: 'system', content: htmlPrompt },
+                        { role: 'user', content: 'Generate the complete HTML document. Start with <!DOCTYPE html> and end with </html>. No markdown fences.' },
+                    ],
+                    temperature: 0.2,
+                    max_tokens: 4000,
+                });
+                const retryMsg = retryRes.choices[0]?.message;
+                const retryRaw = retryMsg ? extractContent(retryMsg) : '';
+                html = extractHtml(retryRaw);
             }
-            continue;
         }
-        if (slidePlan.tool === 'ppt_build_closing_slide') {
-            const closingText = slidePlan.params?.['text'] || slidePlan.title || '감사합니다';
-            const args = {
-                text: closingText,
-                subtitle: slidePlan.params?.['subtitle'] || '',
-                color_scheme: plan.design.color_scheme,
-                design_style: plan.design.design_style,
-            };
-            const result = await tool.execute(args);
-            totalToolCalls++;
-            if (toolCallLogger)
-                toolCallLogger('powerpoint-create', slidePlan.tool, args, result.result || result.error || '', result.success, slideNum, totalToolCalls);
-            if (result.success) {
-                builtSlides.push(`Slide ${slideNum}: ${closingText} (closing)`);
-            }
-            else {
-                logger.warn(`Closing slide failed: ${result.error}`);
-            }
+        catch (e) {
+            logger.warn(`Slide ${slideNum}: LLM call failed: ${e}`);
+        }
+        if (!html) {
+            logger.warn(`Slide ${slideNum}: Failed to generate HTML, skipping`);
+            failCount++;
             continue;
         }
-        const slideSystemPrompt = buildSlideSystemPrompt(slidePlan.tool, slidePlan.title, slidePlan.direction || '', guidance, language);
-        if (!slideSystemPrompt) {
-            logger.warn(`No system prompt for ${slidePlan.tool}, skipping`);
+        const htmlFileName = `hanseol_slide_${slideNum}_${timestamp}.html`;
+        const pngFileName = `hanseol_slide_${slideNum}_${timestamp}.png`;
+        const htmlWritePath = path.join(tempWritePath, htmlFileName);
+        const pngWritePath = path.join(tempWritePath, pngFileName);
+        const htmlWinPath = `${tempWinPath}\\${htmlFileName}`;
+        const pngWinPath = `${tempWinPath}\\${pngFileName}`;
+        try {
+            fs.writeFileSync(htmlWritePath, html, 'utf-8');
+            tempFiles.push(htmlWritePath);
+        }
+        catch (e) {
+            logger.warn(`Slide ${slideNum}: Failed to write HTML file: ${e}`);
+            failCount++;
             continue;
         }
+        let renderSuccess = false;
         try {
-            const slideRes = await llmClient.chatCompletion({
-                messages: [
-                    { role: 'system', content: slideSystemPrompt },
-                    { role: 'user', content: `Build slide "${slidePlan.title}" now. Call the tool with all required parameters.` },
-                ],
-                tools: [tool.definition],
-                temperature: 0.3,
-                max_tokens: 2000,
-            });
-            const msg = slideRes.choices[0]?.message;
-            if (!msg?.tool_calls || msg.tool_calls.length === 0) {
-                logger.warn(`Slide ${slideNum}: LLM did not call tool, skipping`);
-                continue;
+            const renderResult = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
+            totalToolCalls++;
+            renderSuccess = renderResult.success;
+            if (!renderSuccess) {
+                await new Promise(r => setTimeout(r, 2000));
+                const retryRender = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
+                totalToolCalls++;
+                renderSuccess = retryRender.success;
             }
-            const tc = msg.tool_calls[0];
-            let args;
+        }
+        catch (e) {
+            logger.warn(`Slide ${slideNum}: Edge screenshot failed: ${e}`);
             try {
-                args = JSON.parse(tc.function.arguments);
+                await new Promise(r => setTimeout(r, 2000));
+                const retryRender = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
+                totalToolCalls++;
+                renderSuccess = retryRender.success;
             }
             catch {
-                logger.warn(`Slide ${slideNum}: Invalid JSON args from LLM`);
-                continue;
-            }
-            args['color_scheme'] = plan.design.color_scheme;
-            args['design_style'] = plan.design.design_style;
-            if (slidePlan.tool === 'ppt_build_layout_f' && Array.isArray(args['table_data'])) {
-                args['table_data'] = args['table_data'].filter(row => Array.isArray(row));
-            }
-            const result = await tool.execute(args);
-            totalToolCalls++;
-            if (toolCallLogger)
-                toolCallLogger('powerpoint-create', tc.function.name, args, result.result || result.error || '', result.success, slideNum, totalToolCalls);
-            if (result.success) {
-                builtSlides.push(`Slide ${slideNum}: ${slidePlan.title} (${slidePlan.tool.replace('ppt_build_layout_', 'Layout ').toUpperCase()})`);
-            }
-            else {
-                logger.warn(`Slide ${slideNum} failed: ${result.error}`);
+                renderSuccess = false;
             }
         }
-        catch (e) {
-            logger.warn(`Slide ${slideNum} LLM call failed: ${e}`);
+        try {
+            fs.unlinkSync(htmlWritePath);
+        }
+        catch { }
+        if (!renderSuccess) {
+            logger.warn(`Slide ${slideNum}: Screenshot rendering failed, skipping`);
+            failCount++;
+            continue;
+        }
+        tempFiles.push(pngWritePath);
+        const addResult = await powerpointClient.powerpointAddSlide(7);
+        totalToolCalls++;
+        if (!addResult.success) {
+            logger.warn(`Slide ${slideNum}: Failed to add blank slide`);
+            failCount++;
+            continue;
+        }
+        const bgResult = await powerpointClient.powerpointSetBackground(slideNum, { imagePath: pngWinPath });
+        totalToolCalls++;
+        if (toolCallLogger)
+            toolCallLogger('powerpoint-create', 'setBackground', { slideNum, imagePath: pngWinPath }, bgResult.success ? 'OK' : 'Failed', bgResult.success, slideNum, totalToolCalls);
+        if (bgResult.success) {
+            builtSlides.push(`Slide ${slideNum}: ${slidePlan.title} (${slidePlan.type})`);
+        }
+        else {
+            logger.warn(`Slide ${slideNum}: Failed to set background: ${JSON.stringify(bgResult)}`);
+            failCount++;
         }
     }
-    const saveTool = toolMap.get('powerpoint_save');
-    if (saveTool) {
-        const saveArgs = { reason: 'Saving completed presentation' };
+    if (builtSlides.length > 0) {
+        const saveArgs = {};
         if (savePath)
             saveArgs['path'] = savePath;
-        const saveResult = await saveTool.execute(saveArgs);
-        totalToolCalls++;
-        if (toolCallLogger)
-            toolCallLogger('powerpoint-create', 'powerpoint_save', saveArgs, saveResult.result || saveResult.error || '', saveResult.success, 0, totalToolCalls);
-        if (!saveResult.success) {
-            const fallbackArgs = { reason: 'Retry save', path: 'C:\\temp\\presentation.pptx' };
-            const retryResult = await saveTool.execute(fallbackArgs);
+        const saveTool = POWERPOINT_CREATE_TOOLS.find(t => t.definition.function.name === 'powerpoint_save');
+        if (saveTool) {
+            const saveResult = await saveTool.execute(saveArgs);
             totalToolCalls++;
             if (toolCallLogger)
-                toolCallLogger('powerpoint-create', 'powerpoint_save', fallbackArgs, retryResult.result || retryResult.error || '', retryResult.success, 0, totalToolCalls);
+                toolCallLogger('powerpoint-create', 'powerpoint_save', saveArgs, saveResult.result || saveResult.error || '', saveResult.success, 0, totalToolCalls);
+            if (!saveResult.success) {
+                const fallbackArgs = { path: 'C:\\temp\\presentation.pptx' };
+                const retryResult = await saveTool.execute(fallbackArgs);
+                totalToolCalls++;
+                if (toolCallLogger)
+                    toolCallLogger('powerpoint-create', 'powerpoint_save', fallbackArgs, retryResult.result || retryResult.error || '', retryResult.success, 0, totalToolCalls);
+            }
+        }
+    }
+    for (const tempFile of tempFiles) {
+        try {
+            fs.unlinkSync(tempFile);
         }
+        catch { }
     }
     const duration = Date.now() - startTime;
-    const summary = `Presentation created with ${builtSlides.length} slides (${plan.design.color_scheme}, ${plan.design.design_style} style):\n${builtSlides.join('\n')}`;
+    const summary = `Presentation created with ${builtSlides.length} slides (HTML rendering, ${plan.design.mood}):\n${builtSlides.join('\n')}`;
     logger.exit('PPT-Create.runStructured', { slideCount: builtSlides.length, totalToolCalls, duration });
     return {
-        success: true,
+        success: builtSlides.length > 0,
         result: summary,
         metadata: { iterations: plan.slides.length, toolCalls: totalToolCalls, duration },
     };
@@ -333,7 +451,7 @@ export function createPowerPointCreateRequestTool() {
             type: 'function',
             function: {
                 name: 'powerpoint_create_agent',
-                description: 'Autonomous PowerPoint CREATION agent. Creates NEW presentations from scratch with professional slide designs, color schemes, and visual hierarchy. Uses high-level builder tools where each tool call creates one complete slide. Give it a topic or outline and it produces a polished, enterprise-grade presentation. For EDITING existing .pptx files, use powerpoint_modify_agent instead.',
+                description: 'Autonomous PowerPoint CREATION agent. Creates NEW presentations from scratch with professional slide designs, color schemes, and visual hierarchy. Uses HTML rendering pipeline for maximum design quality — each slide is rendered as a beautiful HTML page and captured as a high-quality image. Give it a topic or outline and it produces a polished, enterprise-grade presentation. For EDITING existing .pptx files, use powerpoint_modify_agent instead.',
                 parameters: {
                     type: 'object',
                     properties: {