natureco-cli 5.64.2 → 5.64.4

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to NatureCo CLI will be documented in this file.
 
+## [5.64.4] - 2026-07-13 — Unified MiniMax media routing
+
+### Added
+- MiniMax chat configurations now automatically expose image understanding through `MiniMax-VL-01`, image generation through `image-01`, and video generation through `MiniMax-Hailuo-2.3` using the existing provider key.
+- Added provider-native GUI vision transports for MiniMax VLM and Anthropic image blocks; OpenAI-compatible and Gemini vision paths remain supported.
+- MiniMax video generation now submits an asynchronous task and polls its status until `Success`, `Fail`, or timeout.
+
+### Fixed
+- `media_understanding` no longer rejects MiniMax configurations or incorrectly claims Gemini support without an implementation.
+- Image and video generation automatically select MiniMax when the active provider is MiniMax, while explicit provider overrides remain respected.
+
+### Verification
+- Live MiniMax VLM smoke test read a unique string from a synthetic PNG using the existing NatureCo provider key.
+- Added HTTP contract and provider-routing regression tests for MiniMax VLM, Anthropic vision, MiniMax image generation, and MiniMax video generation selection.
+
+## [5.64.3] - 2026-07-13 — Evidence-based GUI completion
+
+### Fixed
+- `computer_use_loop` no longer trusts the action model's `done` claim as proof of completion.
+- GUI success now requires a real state-changing action, a changed screenshot hash, and a separate visual-verification pass with explicit evidence and at least 80% confidence.
+- Failed GUI tools now display the error reason beside the persistent `✗` status line.
+- Typed values are redacted from GUI step history.
+- MiniMax M-series chat configurations automatically route screenshots to the Token Plan VLM endpoint using the existing provider key; no second API key is required.
+
+### Configuration
+- Added optional `guiVisionProviderUrl`, `guiVisionApiKey`, and `guiVisionModel` overrides; MiniMax users use the existing provider configuration by default.
+
+### Tests
+- Added regression coverage for no-action claims, unchanged screens, weak evidence, verified completion, automatic MiniMax VLM routing, and dedicated vision-provider overrides.
+
 ## [5.64.2] - 2026-07-13 — Visible and reliable macOS GUI automation
 
 ### Fixed

package/README.md

@@ -51,6 +51,8 @@ natureco code
 
 | Version | Highlights |
 |---------|-----------|
+| **v5.64.4** | **Unified MiniMax media:** the existing MiniMax key now powers `MiniMax-VL-01` analysis, `image-01` generation, `MiniMax-Hailuo-2.3` video, and verified GUI vision—no second key required. |
+| **v5.64.3** | **Evidence-based GUI completion:** desktop actions require a changed screen plus independent visual evidence before success. MiniMax screenshots use the Token Plan VLM with the existing provider key. |
 | **v5.64.2** | **Reliable macOS GUI automation:** tool names stay visible in REPL transcripts, visual tasks use a verified screenshot loop, MiniMax GUI routing avoids duplicate paths, and failed/unverified actions no longer claim success. |
 | **v5.64.1** | **Reliable follow-ups + lower token cost:** `natureco code` now preserves same-session context across workflow calls and caps repeated history by token budget (1,024 / 2,048 / 8,192). Provider labels are rendered correctly. |
 | **v5.64.0** | **Unified secure agent foundation:** one execution gateway, hard-stop guardrails, schema-validated tools, rollback/checkpoints, sourced memory, resilient channel delivery, OS keychains and encrypted sync. |
@@ -133,6 +135,18 @@ NatureCo uses progressive disclosure and bounded context instead of sending ever
 
 For a 32,000-character previous response, the Balanced profile bounds repeated history to about 2,048 tokens instead of roughly 8,000—a reduction of approximately 74% for that repeated context.
 
+### 👁️ Verified GUI Automation
+
+MiniMax Token Plan users need no extra key: NatureCo automatically sends screenshots to MiniMax VLM while keeping the M-series model for chat. A separate OpenAI-compatible vision provider remains an optional override:
+
+```bash
+natureco config set guiVisionProviderUrl https://api.openai.com/v1
+natureco config set guiVisionApiKey "$OPENAI_API_KEY"
+natureco config set guiVisionModel gpt-4.1-mini
+```
+
+NatureCo reports GUI success only after a state-changing action, a changed screen, and a separate visual verification with explicit evidence. Purchasing, booking, sending, or other consequential actions should still be reviewed at the final confirmation step.
+
 ### 📡 10 Messaging Channels
 
 | Platform | Connect | Notes |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.64.2",
+  "version": "5.64.4",
   "description": "Terminal-native AI agent CLI with bilingual TR/EN UI, multi-agent orchestration, persistent memory, secure tools and messaging integrations.",
   "bin": {
     "natureco": "bin/natureco.js"

package/src/commands/config.js

@@ -149,6 +149,9 @@ function config(args) {
       apiKey: { type: 'string', description: 'API key for the provider', required: true },
       providerUrl: { type: 'string', description: 'Base URL of the provider API', required: true },
       providerModel: { type: 'string', description: 'Default model identifier', required: false, default: 'gpt-4' },
+      guiVisionProviderUrl: { type: 'string', description: 'OpenAI-compatible vision API base URL for GUI screenshot analysis', required: false },
+      guiVisionApiKey: { type: 'string', description: 'API key for the GUI vision provider', required: false },
+      guiVisionModel: { type: 'string', description: 'Vision-capable model used by computer_use_loop', required: false },
       temperature: { type: 'number', description: 'Sampling temperature (0-2)', required: false, default: 0.7 },
       maxTokens: { type: 'number', description: 'Maximum tokens per response', required: false, default: 2048 },
       systemPrompt: { type: 'string', description: 'Custom system prompt', required: false },

package/src/tools/computer_use_loop.js

@@ -9,12 +9,77 @@ const https = require('https');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { buildChatEndpoint } = require('../utils/provider-detect');
+const crypto = require('crypto');
+const { buildChatEndpoint, isMiniMax, isAnthropic } = require('../utils/provider-detect');
 
 function loadConfig() {
   try { return JSON.parse(fs.readFileSync(path.join(os.homedir(), '.natureco', 'config.json'), 'utf8')); } catch { return {}; }
 }
 
+function resolveVisionConfig(cfg) {
+  const main = {
+    providerUrl: cfg.providerUrl,
+    apiKey: cfg.providerApiKey,
+    model: cfg.providerModel || 'default',
+  };
+  const explicit = cfg.guiVisionProviderUrl && cfg.guiVisionApiKey && cfg.guiVisionModel
+    ? { providerUrl: cfg.guiVisionProviderUrl, apiKey: cfg.guiVisionApiKey, model: cfg.guiVisionModel }
+    : null;
+  if (explicit) return { success: true, ...explicit, dedicated: true };
+  if (isMiniMax(main.providerUrl) || /^MiniMax-M/i.test(main.model)) {
+    if (!main.providerUrl || !main.apiKey) return { success: false, error: 'Provider not configured' };
+    return { success: true, ...main, dedicated: false, transport: 'minimax-vlm' };
+  }
+  if (!main.providerUrl || !main.apiKey) return { success: false, error: 'Provider not configured' };
+  return { success: true, ...main, dedicated: false };
+}
+
+async function visionCall(providerUrl, apiKey, model, prompt, screenshot) {
+  if (isMiniMax(providerUrl) || /^MiniMax-M/i.test(model)) {
+    const base = providerUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+    const response = await fetch(base + '/v1/coding_plan/vlm', {
+      method: 'POST',
+      headers: { Authorization: 'Bearer ' + apiKey, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ prompt, image_url: 'data:image/png;base64,' + screenshot.base64 }),
+      signal: AbortSignal.timeout(120000),
+    });
+    if (!response.ok) throw new Error('MiniMax VLM HTTP ' + response.status + ': ' + (await response.text()).slice(0, 300));
+    const data = await response.json();
+    if (data.base_resp?.status_code) throw new Error(data.base_resp.status_msg || 'MiniMax VLM request failed');
+    return String(data.content || '');
+  }
+
+  if (isAnthropic(providerUrl) || /^claude-/i.test(model)) {
+    const origin = new URL(providerUrl).origin;
+    const response = await fetch(origin + '/v1/messages', {
+      method: 'POST',
+      headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        max_tokens: 500,
+        messages: [{ role: 'user', content: [
+          { type: 'image', source: { type: 'base64', media_type: 'image/png', data: screenshot.base64 } },
+          { type: 'text', text: prompt },
+        ] }],
+      }),
+      signal: AbortSignal.timeout(120000),
+    });
+    if (!response.ok) throw new Error('Anthropic vision HTTP ' + response.status + ': ' + (await response.text()).slice(0, 300));
+    const data = await response.json();
+    return String(data.content?.find(item => item.type === 'text')?.text || '');
+  }
+
+  const messages = [{
+    role: 'user',
+    content: [
+      { type: 'text', text: prompt },
+      { type: 'image_url', image_url: { url: 'data:image/png;base64,' + screenshot.base64 } },
+    ],
+  }];
+  const result = await apiCall(providerUrl, apiKey, { model, messages, stream: false, temperature: 0, max_tokens: 500 });
+  return String(result.choices?.[0]?.message?.content || '');
+}
+
 function apiCall(providerUrl, apiKey, body) {
   return new Promise((resolve, reject) => {
     const endpoint = buildChatEndpoint(providerUrl);
@@ -38,13 +103,41 @@ function apiCall(providerUrl, apiKey, body) {
   });
 }
 
-function screenshotBase64() {
+function captureScreenshot() {
   if (os.platform() !== 'darwin') throw new Error('computer_use_loop currently requires macOS');
   const file = path.join(os.tmpdir(), 'ncloop_' + Date.now() + '.png');
   require('child_process').execSync('screencapture -x "' + file + '"', { timeout: 5000 });
   const buf = fs.readFileSync(file);
   fs.unlinkSync(file);
-  return buf.toString('base64');
+  return {
+    base64: buf.toString('base64'),
+    hash: crypto.createHash('sha256').update(buf).digest('hex'),
+  };
+}
+
+function evaluateCompletionEvidence({ mutationCount, initialHash, currentHash, verification }) {
+  if (mutationCount < 1) return { verified: false, error: 'No state-changing GUI action was executed' };
+  if (!initialHash || !currentHash || initialHash === currentHash) {
+    return { verified: false, error: 'The screen did not change after GUI actions' };
+  }
+  if (!verification || verification.verified !== true) {
+    return { verified: false, error: verification?.reason || 'Visual verifier could not confirm the goal' };
+  }
+  const confidence = Number(verification.confidence || 0);
+  if (confidence < 0.8 || !String(verification.evidence || '').trim()) {
+    return { verified: false, error: 'Visual verification evidence was insufficient' };
+  }
+  return { verified: true, evidence: String(verification.evidence).trim(), confidence };
+}
+
+async function verifyGoal(providerUrl, apiKey, model, goal, screenshot) {
+  const prompt = `You are a strict independent verifier. Inspect only the screenshot. Goal: ${goal}\nReturn JSON only: {"verified":boolean,"confidence":0..1,"evidence":"exact visible evidence","reason":"why not"}. Never infer success from the goal text. If the requested sent message, booking, purchase, or confirmation is not visibly present, verified must be false.`;
+  const reply = await visionCall(providerUrl, apiKey, model, prompt, screenshot);
+  try { return JSON.parse(reply); }
+  catch {
+    const match = reply.match(/\{[\s\S]*\}/);
+    return match ? JSON.parse(match[0]) : { verified: false, confidence: 0, reason: 'Verifier returned invalid JSON' };
+  }
 }
 
 function executeAction(action, params) {
@@ -110,17 +203,14 @@ Actions:
 - wait: { "action": "wait" }
 - done: { "action": "done", "reason": "gorev tamamlandi" }
 
+"done" yalnız görev sonucunu mevcut ekranda açıkça görüyorsan kullanılabilir. Bir mesajı yazmak gönderildiği anlamına gelmez; gönderilen mesajın konuşmada görünmesi gerekir.
 Sadece JSON yanit ver, baska metin ekleme. Her action'dan sonra otomatik screenshot alinir, sen sadece bir sonraki en mantikli adimi soyle.`;
 
 async function loop(goal, maxSteps) {
   const cfg = loadConfig();
-  const providerUrl = cfg.providerUrl;
-  const apiKey = cfg.providerApiKey;
-  const model = cfg.providerModel || 'default';
-
-  if (!providerUrl || !apiKey) {
-    return { success: false, error: 'Provider not configured' };
-  }
+  const vision = resolveVisionConfig(cfg);
+  if (!vision.success) return vision;
+  const { providerUrl, apiKey, model } = vision;
 
   if (os.platform() !== 'darwin') {
     return { success: false, error: 'computer_use_loop currently requires macOS' };
@@ -128,42 +218,20 @@ async function loop(goal, maxSteps) {
 
   const steps = [];
   let completed = false;
+  let initialHash = null;
+  let mutationCount = 0;
+  let completionEvidence = null;
   for (let i = 0; i < maxSteps; i++) {
     try {
       // 1. Screenshot
-      const b64 = screenshotBase64();
+      const screenshot = captureScreenshot();
+      if (!initialHash) initialHash = screenshot.hash;
       steps.push({ step: i + 1, action: 'screenshot' });
 
       // 2. LLM vision analysis
-      const messages = [
-        { role: 'system', content: SYSTEM_PROMPT },
-      ];
-
       const history = steps.filter(s => s.action && s.action !== 'screenshot' && s.action !== 'done').slice(-5);
-      if (history.length > 0) {
-        messages.push({ role: 'user', content: 'Onceki adimlar:\n' + history.map(h =>
-          'Adim ' + h.step + ': ' + JSON.stringify(h)
-        ).join('\n') });
-      }
-
-      messages.push({
-        role: 'user',
-        content: [
-          { type: 'text', text: 'Gorev: ' + goal + '\n\nEkran goruntusunu analiz et. Siradaki action ne?' },
-          { type: 'image_url', image_url: { url: 'data:image/png;base64,' + b64 } },
-        ],
-      });
-
-      const body = {
-        model,
-        messages,
-        stream: false,
-        temperature: 0.2,
-        max_tokens: 500,
-      };
-
-      const result = await apiCall(providerUrl, apiKey, body);
-      const reply = result.choices?.[0]?.message?.content || '';
+      const historyText = history.length > 0 ? '\nOnceki adimlar:\n' + history.map(h => 'Adim ' + h.step + ': ' + JSON.stringify(h)).join('\n') : '';
+      const reply = await visionCall(providerUrl, apiKey, model, SYSTEM_PROMPT + '\n\nGorev: ' + goal + historyText + '\n\nEkran goruntusunu analiz et. Siradaki action ne?', screenshot);
       let decision;
       try {
         decision = JSON.parse(reply);
@@ -176,13 +244,21 @@ async function loop(goal, maxSteps) {
 
       // 3. Execute
       if (decision.action === 'done') {
-        steps.push({ step: i + 1, action: 'done', reason: decision.reason || 'Goal achieved' });
-        completed = true;
-        break;
+        const verification = await verifyGoal(providerUrl, apiKey, model, goal, screenshot);
+        const evidence = evaluateCompletionEvidence({ mutationCount, initialHash, currentHash: screenshot.hash, verification });
+        if (evidence.verified) {
+          steps.push({ step: i + 1, action: 'verified', evidence: evidence.evidence, confidence: evidence.confidence });
+          completionEvidence = evidence;
+          completed = true;
+          break;
+        }
+        steps.push({ step: i + 1, action: 'verification_failed', error: evidence.error });
+        continue;
       }
 
       const execResult = executeAction(decision.action, decision);
-      steps.push({ step: i + 1, action: decision.action, params: decision, result: execResult.success });
+      const safeParams = decision.action === 'type' ? { action: 'type', text: '[redacted]' } : decision;
+      steps.push({ step: i + 1, action: decision.action, params: safeParams, result: execResult.success });
 
       if (!execResult.success) {
         // Retry once with wait
@@ -193,6 +269,7 @@ async function loop(goal, maxSteps) {
           return { success: false, error: execResult.error, goal, totalSteps: steps.length, steps };
         }
       }
+      if (['click', 'type', 'keypress', 'scroll', 'drag'].includes(decision.action)) mutationCount++;
 
       // Small delay between actions
       require('child_process').execSync('sleep 0.5');
@@ -210,7 +287,7 @@ async function loop(goal, maxSteps) {
   if (!completed) {
     return { success: false, error: 'Goal was not verified', goal, totalSteps: steps.length, steps };
   }
-  return { success: true, goal, totalSteps: steps.length, steps };
+  return { success: true, verified: true, evidence: completionEvidence.evidence, confidence: completionEvidence.confidence, goal, totalSteps: steps.length, steps };
 }
 
 const name = 'computer_use_loop';
@@ -228,4 +305,4 @@ async function execute(params) {
   return await loop(params.goal, params.maxSteps || 30);
 }
 
-module.exports = { name, description, parameters, execute, executeAction };
+module.exports = { name, description, parameters, execute, executeAction, evaluateCompletionEvidence, resolveVisionConfig, visionCall };

package/src/tools/image_generation.js

@@ -1,6 +1,31 @@
 const { getConfig } = require('../utils/config');
+const fs = require('fs');
+const path = require('path');
 
 const PROVIDERS = {
+  minimax: {
+    name: 'MiniMax image-01',
+    async generate({ prompt, n, apiKey, model, aspectRatio, baseUrl }) {
+      const response = await fetch(baseUrl + '/v1/image_generation', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify({ model: model || 'image-01', prompt, n: n || 1, response_format: 'base64', ...(aspectRatio ? { aspect_ratio: aspectRatio } : {}) }),
+        signal: AbortSignal.timeout(120000),
+      });
+      if (!response.ok) throw new Error(`MiniMax image error ${response.status}: ${(await response.text()).slice(0, 300)}`);
+      const data = await response.json();
+      if (data.base_resp?.status_code) throw new Error(data.base_resp.status_msg || `MiniMax image API error ${data.base_resp.status_code}`);
+      const images = data.data?.image_base64 || [];
+      if (!images.length) throw new Error('MiniMax image generation returned no images');
+      const outDir = path.join(process.cwd(), 'minimax-output');
+      fs.mkdirSync(outDir, { recursive: true });
+      return images.map((base64, index) => {
+        const file = path.join(outDir, `image-${Date.now()}-${index + 1}.png`);
+        fs.writeFileSync(file, Buffer.from(base64, 'base64'));
+        return { file, mime: 'image/png' };
+      });
+    }
+  },
   // v4.8.4: Pollinations.ai — TAMAMEN ÜCRETSİZ, API key gerektirmez
   // Default provider olarak ayarlandı (herkes kullanabilsin)
   pollinations: {
@@ -56,6 +81,11 @@ const PROVIDERS = {
   }
 };
 
+function selectImageProvider(config, params = {}) {
+  if (params.provider || config.imageProvider) return params.provider || config.imageProvider;
+  return /minimax\.io|minimaxi\.com|minimax\.cn/i.test(config.providerUrl || '') ? 'minimax' : undefined;
+}
+
 module.exports = {
   name: 'image_generation',
   description: 'Generate images using AI. Supports OpenAI DALL-E, FAL.ai, and Together AI providers.',
@@ -63,7 +93,8 @@ module.exports = {
     type: 'object',
     properties: {
       prompt: { type: 'string', description: 'Text description of the image to generate' },
-      provider: { type: 'string', description: 'Image provider: openai, fal, together (default: openai)', enum: ['openai', 'fal', 'together'] },
+      provider: { type: 'string', description: 'Image provider: minimax, openai, fal, together, pollinations (auto-detected)', enum: ['minimax', 'openai', 'fal', 'together', 'pollinations'] },
+      aspectRatio: { type: 'string', description: 'Aspect ratio such as 1:1, 16:9 or 9:16' },
       model: { type: 'string', description: 'Model override (e.g. fast-sdxl for FAL, FLUX.1-schnell for Together)' },
       size: { type: 'string', description: 'Image size for DALL-E: 1024x1024, 1792x1024, 1024x1792 (default: 1024x1024)' },
       n: { type: 'number', description: 'Number of images to generate (default: 1, max: 4)' }
@@ -79,14 +110,17 @@ module.exports = {
       const openaiKey = params.apiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
       const falKey = params.apiKey || config.falApiKey || process.env.FAL_KEY;
       const togetherKey = params.apiKey || config.togetherApiKey || process.env.TOGETHER_API_KEY;
+      const minimaxKey = params.apiKey || config.providerApiKey || process.env.MINIMAX_API_KEY;
+      const isMiniMax = /minimax\.io|minimaxi\.com|minimax\.cn/i.test(config.providerUrl || '');
 
       // Explicit provider tercih edilmişse onu kullan
-      let provider = params.provider || config.imageProvider;
+      let provider = selectImageProvider(config, params) || (isMiniMax && minimaxKey ? 'minimax' : undefined);
       let apiKey;
 
       if (provider) {
         // Explicit provider
-        if (provider === 'openai') apiKey = openaiKey;
+        if (provider === 'minimax') apiKey = minimaxKey;
+        else if (provider === 'openai') apiKey = openaiKey;
         else if (provider === 'fal') apiKey = falKey;
         else if (provider === 'together') apiKey = togetherKey;
         else if (provider === 'pollinations') apiKey = 'free'; // key gereksiz
@@ -114,6 +148,8 @@ module.exports = {
         prompt: params.prompt,
         apiKey,
         model: params.model,
+        aspectRatio: params.aspectRatio,
+        baseUrl: (config.providerUrl || 'https://api.minimax.io').replace(/\/+$/, '').replace(/\/v1$/, ''),
         size: params.size,
         n: params.n
       });
@@ -122,11 +158,14 @@ module.exports = {
         success: true,
         prompt: params.prompt,
         provider: provider,
-        images: images.filter(i => i.url).map(i => ({ url: i.url, revisedPrompt: i.revised_prompt })),
-        count: images.filter(i => i.url).length
+        images: images.filter(i => i.url || i.file).map(i => ({ url: i.url, file: i.file, revisedPrompt: i.revised_prompt })),
+        count: images.filter(i => i.url || i.file).length
       };
     } catch (error) {
       return { success: false, error: error.message };
     }
   }
 };
+
+module.exports._providers = PROVIDERS;
+module.exports.selectImageProvider = selectImageProvider;

package/src/tools/media_understanding.js

@@ -11,7 +11,7 @@ module.exports = {
       imagePath: { type: 'string', description: 'Local image file path' },
       imageUrl: { type: 'string', description: 'Remote image URL (if no local file)' },
       prompt: { type: 'string', description: 'Analysis prompt (default: "Describe this image in detail")' },
-      provider: { type: 'string', description: 'Vision provider: openai, anthropic, groq (default: openai)', enum: ['openai', 'anthropic', 'groq'] },
+      provider: { type: 'string', description: 'Vision provider: minimax, openai, anthropic, gemini, groq (auto-detected)', enum: ['minimax', 'openai', 'anthropic', 'gemini', 'groq'] },
       model: { type: 'string', description: 'Model override' }
     }
   },
@@ -20,11 +20,10 @@ module.exports = {
     try {
       const config = getConfig();
       const prompt = params.prompt || 'Describe this image in detail';
-      let provider = params.provider || config.visionProvider || 'openai';
-
-      // v5.6.22: MiniMax, Ollama, local provider'lar vision desteklemiyor olabilir
       const providerUrl = (config.providerUrl || '').toLowerCase();
-      if (!params.provider && (providerUrl.includes('minimax') || providerUrl.includes('ollama') || providerUrl.includes('localhost'))) {
+      let provider = params.provider || config.visionProvider || (providerUrl.includes('minimax') ? 'minimax' : providerUrl.includes('generativelanguage.googleapis.com') || providerUrl.includes('gemini') ? 'gemini' : 'openai');
+
+      if (!params.provider && (providerUrl.includes('ollama') || providerUrl.includes('localhost'))) {
         return {
           success: false,
           error: `Görsel analiz bu provider (${providerUrl}) için desteklenmiyor. Lütfen OpenAI, Anthropic, Gemini veya Groq provider'ı kullanın.`,
@@ -58,6 +57,30 @@ module.exports = {
 
       const dataUrl = params.imageUrl || `data:${mediaType};base64,${imageBase64}`;
 
+      if (provider === 'minimax') {
+        const apiKey = params.apiKey || config.providerApiKey || process.env.MINIMAX_CODE_PLAN_KEY || process.env.MINIMAX_API_KEY;
+        if (!apiKey) return { success: false, error: 'MiniMax API key gerekli' };
+        let imageDataUrl = dataUrl;
+        if (/^https?:\/\//i.test(imageDataUrl)) {
+          const downloaded = await fetch(imageDataUrl);
+          if (!downloaded.ok) throw new Error(`Görsel indirilemedi: HTTP ${downloaded.status}`);
+          const mime = (downloaded.headers.get('content-type') || 'image/jpeg').split(';')[0];
+          imageDataUrl = `data:${mime};base64,${Buffer.from(await downloaded.arrayBuffer()).toString('base64')}`;
+        }
+        const base = (config.providerUrl || 'https://api.minimax.io').replace(/\/+$/, '').replace(/\/v1$/, '');
+        const response = await fetch(base + '/v1/coding_plan/vlm', {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json', 'MM-API-Source': 'NatureCo' },
+          body: JSON.stringify({ prompt, image_url: imageDataUrl }),
+          signal: AbortSignal.timeout(60000),
+        });
+        if (!response.ok) throw new Error(`MiniMax VLM error ${response.status}: ${(await response.text()).slice(0, 300)}`);
+        const data = await response.json();
+        if (data.base_resp?.status_code) throw new Error(data.base_resp.status_msg || `MiniMax VLM API error ${data.base_resp.status_code}`);
+        if (!data.content) throw new Error('MiniMax VLM boş yanıt döndürdü');
+        return { success: true, provider: 'minimax', model: 'MiniMax-VL-01', analysis: data.content };
+      }
+
       if (provider === 'openai') {
         const apiKey = params.apiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
         if (!apiKey) return { success: false, error: 'OpenAI API key gerekli' };
@@ -83,6 +106,23 @@ module.exports = {
         return { success: true, provider: 'openai', analysis: data.choices?.[0]?.message?.content || '' };
       }
 
+      if (provider === 'gemini') {
+        const apiKey = params.apiKey || config.providerApiKey || process.env.GEMINI_API_KEY;
+        if (!apiKey) return { success: false, error: 'Gemini API key gerekli' };
+        const base = (config.providerUrl || 'https://generativelanguage.googleapis.com/v1beta').replace(/\/+$/, '');
+        const response = await fetch(base + '/openai/chat/completions', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+          body: JSON.stringify({ model: params.model || config.providerModel, messages: [{ role: 'user', content: [
+            { type: 'text', text: prompt },
+            { type: 'image_url', image_url: { url: dataUrl } },
+          ] }], max_tokens: 1000 }),
+        });
+        if (!response.ok) throw new Error(`Gemini vision error ${response.status}`);
+        const data = await response.json();
+        return { success: true, provider: 'gemini', analysis: data.choices?.[0]?.message?.content || '' };
+      }
+
       if (provider === 'anthropic') {
         const apiKey = params.apiKey || config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
         if (!apiKey) return { success: false, error: 'Anthropic API key gerekli' };

package/src/tools/video_generation.js

@@ -1,6 +1,31 @@
 const { getConfig } = require('../utils/config');
 
 const PROVIDERS = {
+  minimax: {
+    name: 'MiniMax Hailuo',
+    async generate({ prompt, apiKey, model, baseUrl }) {
+      const headers = { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` };
+      const submittedResponse = await fetch(baseUrl + '/v1/video_generation', {
+        method: 'POST', headers,
+        body: JSON.stringify({ model: model || 'MiniMax-Hailuo-2.3', prompt }),
+        signal: AbortSignal.timeout(120000),
+      });
+      if (!submittedResponse.ok) throw new Error(`MiniMax video error ${submittedResponse.status}: ${(await submittedResponse.text()).slice(0, 300)}`);
+      const submitted = await submittedResponse.json();
+      if (submitted.base_resp?.status_code) throw new Error(submitted.base_resp.status_msg || 'MiniMax video submission failed');
+      if (!submitted.task_id) throw new Error('MiniMax video response missing task_id');
+      for (let attempt = 0; attempt < 120; attempt++) {
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        const statusResponse = await fetch(baseUrl + '/v1/query/video_generation?task_id=' + encodeURIComponent(submitted.task_id), { headers, signal: AbortSignal.timeout(30000) });
+        if (!statusResponse.ok) throw new Error(`MiniMax video status error ${statusResponse.status}`);
+        const status = await statusResponse.json();
+        if (status.base_resp?.status_code) throw new Error(status.base_resp.status_msg || 'MiniMax video generation failed');
+        if (status.status === 'Fail') throw new Error(status.base_resp?.status_msg || 'MiniMax video generation failed');
+        if (status.status === 'Success') return [{ url: status.video_url || null, fileId: status.file_id || null, taskId: submitted.task_id }];
+      }
+      throw new Error(`MiniMax video task ${submitted.task_id} timed out`);
+    }
+  },
   runway: {
     name: 'RunwayML',
     async generate({ prompt, apiKey, model }) {
@@ -21,6 +46,11 @@ const PROVIDERS = {
   }
 };
 
+function selectVideoProvider(config, params = {}) {
+  if (params.provider) return params.provider;
+  return /minimax\.io|minimaxi\.com|minimax\.cn/i.test(config.providerUrl || '') ? 'minimax' : 'runway';
+}
+
 module.exports = {
   name: 'video_generation',
   description: 'Generate videos using AI. Supports RunwayML provider.',
@@ -28,7 +58,7 @@ module.exports = {
     type: 'object',
     properties: {
       prompt: { type: 'string', description: 'Text description of the video to generate' },
-      provider: { type: 'string', description: 'Video provider: runway (default: runway)', enum: ['runway'] },
+      provider: { type: 'string', description: 'Video provider: minimax or runway (auto-detected)', enum: ['minimax', 'runway'] },
       model: { type: 'string', description: 'Model override (default: gen3a_turbo)' }
     },
     required: ['prompt']
@@ -37,14 +67,16 @@ module.exports = {
   async execute(params) {
     try {
       const config = getConfig();
-      const provider = params.provider || 'runway';
+      const provider = selectVideoProvider(config, params);
 
       const providerConfig = PROVIDERS[provider];
       if (!providerConfig) {
         return { success: false, error: `Desteklenmeyen provider: ${provider}` };
       }
 
-      const apiKey = params.apiKey || config.runwayApiKey || process.env.RUNWAY_API_KEY;
+      const apiKey = provider === 'minimax'
+        ? (params.apiKey || config.providerApiKey || process.env.MINIMAX_API_KEY)
+        : (params.apiKey || config.runwayApiKey || process.env.RUNWAY_API_KEY);
       if (!apiKey) {
         return {
           success: false,
@@ -55,7 +87,8 @@ module.exports = {
       const videos = await providerConfig.generate({
         prompt: params.prompt,
         apiKey,
-        model: params.model
+        model: params.model,
+        baseUrl: (config.providerUrl || 'https://api.minimax.io').replace(/\/+$/, '').replace(/\/v1$/, '')
       });
 
       return {
@@ -70,3 +103,6 @@ module.exports = {
     }
   }
 };
+
+module.exports._providers = PROVIDERS;
+module.exports.selectVideoProvider = selectVideoProvider;

package/src/tools/workflow.js

@@ -348,12 +348,13 @@ async function workflow(params) {
           const label = TOOL_LABEL[ev.tool] || ev.tool;
           const hint = briefHint(ev.args);
           process.stdout.write('\n\x1b[2m  🔧 ' + label + (hint ? ' · ' + hint : '') + '\x1b[0m');
-        } else {
-          const rec = (ev.records || [])[0] || {};
+        } else {
+          const rec = (ev.records || [])[0] || {};
           // Satırı burada bitir. Sonraki model çağrısının thinking göstergesi
           // mevcut satırı \r + erase-line ile temizlediği için newline yoksa
           // kullanıcı araç adını ve sonucunu hiç göremiyordu.
-          process.stdout.write((rec.status === 'done' ? ' \x1b[32m✓\x1b[0m' : ' \x1b[31m✗\x1b[0m') + '\n');
+          const error = rec.status === 'done' ? '' : String(rec.error || rec.result?.error || '').replace(/\s+/g, ' ').slice(0, 100);
+          process.stdout.write((rec.status === 'done' ? ' \x1b[32m✓\x1b[0m' : ' \x1b[31m✗\x1b[0m') + (error ? ' \x1b[31m' + error + '\x1b[0m' : '') + '\n');
         }
       } : null;