natureco-cli 2.23.28 → 2.23.30

package/src/tools/document_extract.js

@@ -0,0 +1,84 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+module.exports = {
+  name: 'document_extract',
+  description: 'Extract text content from local documents (PDF, DOCX, TXT, CSV, JSON, MD, RTF, ODT)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'File path to extract text from' },
+      maxChars: { type: 'number', description: 'Maximum characters to return (default: 50000)', default: 50000 }
+    },
+    required: ['path']
+  },
+
+  async execute(params) {
+    try {
+      const filePath = path.resolve(params.path.replace(/^~/, require('os').homedir()));
+      const maxChars = params.maxChars || 50000;
+
+      if (!fs.existsSync(filePath)) {
+        return { success: false, error: `Dosya bulunamadı: ${filePath}` };
+      }
+
+      const stats = fs.statSync(filePath);
+      if (stats.size > 50 * 1024 * 1024) {
+        return { success: false, error: 'Dosya çok büyük (max 50MB)' };
+      }
+
+      const ext = path.extname(filePath).toLowerCase();
+      let text = '';
+
+      if (ext === '.txt' || ext === '.csv' || ext === '.json' || ext === '.md' || ext === '.xml' || ext === '.yaml' || ext === '.yml') {
+        text = fs.readFileSync(filePath, 'utf-8');
+      } else if (ext === '.pdf') {
+        try {
+          text = execSync(`pdftotext "${filePath}" -`, { encoding: 'utf-8', timeout: 30000, stdio: ['pipe', 'pipe', 'ignore'] });
+        } catch {
+          // Fallback: read raw PDF extract
+          const raw = fs.readFileSync(filePath, 'utf-8');
+          const matches = raw.match(/\((.*?)\)/g);
+          text = (matches || []).map(m => m.slice(1, -1)).filter(s => s.length > 3).join(' ');
+        }
+      } else if (ext === '.docx') {
+        try {
+          const zip = require('../utils/zip-reader');
+          text = await zip.readText(filePath);
+        } catch {
+          return { success: false, error: 'DOCX okuma hatası. npm install adm-zip gerekli olabilir.' };
+        }
+      } else if (ext === '.rtf' || ext === '.odt') {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        text = raw.replace(/<[^>]+>/g, ' ').replace(/\\[a-z]+|\{[^}]*\}|[{}]/g, ' ').replace(/\s+/g, ' ').trim();
+      } else {
+        // Fallback: read as text
+        text = fs.readFileSync(filePath, 'utf-8');
+      }
+
+      const cleaned = text
+        .replace(/\r\n/g, '\n')
+        .replace(/\x00/g, '')
+        .trim();
+
+      const truncated = cleaned.length > maxChars
+        ? cleaned.slice(0, maxChars) + '...'
+        : cleaned;
+
+      return {
+        success: true,
+        path: filePath,
+        extension: ext,
+        fileSize: stats.size,
+        content: truncated,
+        wordCount: cleaned.split(/\s+/).length,
+        totalChars: cleaned.length,
+        truncated: cleaned.length > maxChars,
+        source: 'document_extract'
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/duckduckgo.js

@@ -0,0 +1,54 @@
+const { getConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'duckduckgo_search',
+  description: 'Search the web using DuckDuckGo (no API key required)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query' },
+      maxResults: { type: 'number', description: 'Maximum results (default: 5)', default: 5 }
+    },
+    required: ['query']
+  },
+
+  async execute(params) {
+    try {
+      const query = encodeURIComponent(params.query);
+      const maxResults = params.maxResults || 5;
+
+      const response = await fetch(
+        `https://html.duckduckgo.com/html/?q=${query}`,
+        { headers: { 'User-Agent': 'NatureCo-CLI/2.0' } }
+      );
+
+      if (!response.ok) {
+        return { success: false, error: `DuckDuckGo error: ${response.status}` };
+      }
+
+      const html = await response.text();
+
+      // Extract result snippets from DuckDuckGo HTML
+      const results = [];
+      const resultRegex = /<a rel="nofollow" class="result__a" href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+      let match;
+      while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
+        results.push({
+          title: match[2].replace(/<[^>]+>/g, '').trim(),
+          snippet: match[3].replace(/<[^>]+>/g, '').trim(),
+          url: match[1]
+        });
+      }
+
+      return {
+        success: true,
+        query: params.query,
+        results,
+        count: results.length,
+        source: 'duckduckgo'
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/exa_search.js

@@ -0,0 +1,66 @@
+const { getConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'exa_search',
+  description: 'Search the web using Exa (exa.ai) — AI-powered search with content extraction',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query' },
+      maxResults: { type: 'number', description: 'Maximum results (default: 5)', default: 5 },
+      type: { type: 'string', description: 'Search type: keyword, neural, auto (default: auto)', enum: ['keyword', 'neural', 'auto'] },
+      includeText: { type: 'array', items: { type: 'string' }, description: 'Keywords that must appear' },
+      excludeText: { type: 'array', items: { type: 'string' }, description: 'Keywords to exclude' }
+    },
+    required: ['query']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const apiKey = config.exaApiKey || process.env.EXA_API_KEY;
+
+      if (!apiKey) {
+        return {
+          success: false,
+          error: 'Exa API key gerekli. Kur: natureco config set exaApiKey <key>\nKey al: https://dashboard.exa.ai/api-keys'
+        };
+      }
+
+      const response = await fetch('https://api.exa.ai/search', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey },
+        body: JSON.stringify({
+          query: params.query,
+          type: params.type || 'auto',
+          numResults: params.maxResults || 5,
+          includeTerms: params.includeText,
+          excludeTerms: params.excludeText
+        })
+      });
+
+      if (!response.ok) {
+        const err = await response.text().catch(() => '');
+        return { success: false, error: `Exa error ${response.status}: ${err}` };
+      }
+
+      const data = await response.json();
+
+      return {
+        success: true,
+        query: params.query,
+        results: (data.results || []).map(r => ({
+          title: r.title,
+          snippet: r.text,
+          url: r.url,
+          score: r.score,
+          publishedDate: r.publishedDate
+        })),
+        count: data.results?.length || 0,
+        source: 'exa'
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/firecrawl.js

@@ -0,0 +1,104 @@
+const { getConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'firecrawl',
+  description: 'Scrape and crawl web pages using Firecrawl — extracts markdown content from any URL',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      url: { type: 'string', description: 'URL to scrape or crawl' },
+      mode: { type: 'string', description: 'Mode: scrape (single page) or crawl (entire site, max 10 pages)', enum: ['scrape', 'crawl'], default: 'scrape' },
+      maxPages: { type: 'number', description: 'Max pages to crawl (default: 5, max: 10)', default: 5 },
+      formats: { type: 'array', items: { type: 'string' }, description: 'Output formats: markdown, html, rawHtml, screenshot (default: markdown)' }
+    },
+    required: ['url']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const apiKey = config.firecrawlApiKey || process.env.FIRECRAWL_API_KEY;
+
+      if (!apiKey) {
+        return {
+          success: false,
+          error: 'Firecrawl API key gerekli. Kur: natureco config set firecrawlApiKey <key>\nKey al: https://www.firecrawl.dev'
+        };
+      }
+
+      const formats = params.formats || ['markdown'];
+      const maxPages = Math.min(params.maxPages || 5, 10);
+
+      if (params.mode === 'crawl') {
+        // Crawl mode
+        const crawlResponse = await fetch('https://api.firecrawl.dev/v1/crawl', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+          body: JSON.stringify({
+            url: params.url,
+            limit: maxPages,
+            scrapeOptions: { formats }
+          })
+        });
+
+        if (!crawlResponse.ok) {
+          return { success: false, error: `Firecrawl crawl error: ${crawlResponse.status}` };
+        }
+
+        const { id } = await crawlResponse.json();
+
+        // Poll for results
+        for (let i = 0; i < 30; i++) {
+          await new Promise(r => setTimeout(r, 2000));
+          const statusResponse = await fetch(`https://api.firecrawl.dev/v1/crawl/${id}`, {
+            headers: { 'Authorization': `Bearer ${apiKey}` }
+          });
+          if (!statusResponse.ok) continue;
+
+          const statusData = await statusResponse.json();
+          if (statusData.status === 'completed') {
+            return {
+              success: true,
+              url: params.url,
+              mode: 'crawl',
+              pages: (statusData.data || []).map(p => ({
+                url: p.url || p.metadata?.url,
+                content: p.markdown || '',
+                title: p.metadata?.title
+              })),
+              count: statusData.data?.length || 0,
+              source: 'firecrawl'
+            };
+          }
+        }
+
+        return { success: false, error: 'Firecrawl crawl timed out' };
+      }
+
+      // Scrape mode
+      const response = await fetch('https://api.firecrawl.dev/v1/scrape', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({ url: params.url, formats })
+      });
+
+      if (!response.ok) {
+        return { success: false, error: `Firecrawl scrape error: ${response.status}` };
+      }
+
+      const data = await response.json();
+
+      return {
+        success: true,
+        url: params.url,
+        mode: 'scrape',
+        content: data.data?.markdown || data.data?.content || '',
+        title: data.data?.metadata?.title,
+        description: data.data?.metadata?.description,
+        source: 'firecrawl'
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/image_generation.js

@@ -0,0 +1,99 @@
+const { getConfig } = require('../utils/config');
+
+const PROVIDERS = {
+  openai: {
+    name: 'OpenAI DALL-E',
+    async generate({ prompt, size, n, apiKey }) {
+      const response = await fetch('https://api.openai.com/v1/images/generations', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({ prompt, n: n || 1, size: size || '1024x1024' })
+      });
+      if (!response.ok) throw new Error(`OpenAI error ${response.status}: ${await response.text()}`);
+      return (await response.json()).data;
+    }
+  },
+  fal: {
+    name: 'FAL.ai',
+    async generate({ prompt, apiKey, model }) {
+      const response = await fetch(`https://fal.run/fal-ai/${model || 'fast-sdxl'}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Key ${apiKey}` },
+        body: JSON.stringify({ prompt })
+      });
+      if (!response.ok) throw new Error(`FAL error ${response.status}: ${await response.text()}`);
+      return [{ url: (await response.json()).images?.[0]?.url || (await response.json()).image?.url }];
+    }
+  },
+  together: {
+    name: 'Together AI',
+    async generate({ prompt, apiKey, model }) {
+      const response = await fetch('https://api.together.xyz/v1/images/generations', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({ model: model || 'black-forest-labs/FLUX.1-schnell', prompt, steps: 4, n: 1 })
+      });
+      if (!response.ok) throw new Error(`Together error ${response.status}: ${await response.text()}`);
+      const data = await response.json();
+      return data.data?.map(d => ({ url: d.url })) || [{ url: data.output?.[0] }];
+    }
+  }
+};
+
+module.exports = {
+  name: 'image_generation',
+  description: 'Generate images using AI. Supports OpenAI DALL-E, FAL.ai, and Together AI providers.',
+  inputSchema: {
+    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'] },
+      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)' }
+    },
+    required: ['prompt']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const provider = params.provider || config.imageProvider || 'openai';
+
+      const providerConfig = PROVIDERS[provider];
+      if (!providerConfig) {
+        return { success: false, error: `Desteklenmeyen provider: ${provider}. Kullanılabilir: ${Object.keys(PROVIDERS).join(', ')}` };
+      }
+
+      let apiKey;
+      if (provider === 'openai') apiKey = params.apiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
+      else if (provider === 'fal') apiKey = params.apiKey || config.falApiKey || process.env.FAL_KEY;
+      else if (provider === 'together') apiKey = params.apiKey || config.togetherApiKey || process.env.TOGETHER_API_KEY;
+
+      if (!apiKey) {
+        return {
+          success: false,
+          error: `${providerConfig.name} API key gerekli.\nKur: natureco config set ${provider}ApiKey <key>`
+        };
+      }
+
+      const images = await providerConfig.generate({
+        prompt: params.prompt,
+        apiKey,
+        model: params.model,
+        size: params.size,
+        n: params.n
+      });
+
+      return {
+        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
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/llm_task.js

@@ -0,0 +1,118 @@
+const { getConfig } = require('../utils/config');
+
+function stripCodeFences(s) {
+  const m = s.trim().match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  if (m) return (m[1] || '').trim();
+  return s.trim();
+}
+
+function validateAgainstSchema(value, schema) {
+  if (!schema || typeof schema !== 'object') return { ok: true };
+  if (schema.type === 'object' && schema.properties) {
+    if (typeof value !== 'object' || Array.isArray(value)) return { ok: false, errors: [{ text: 'expected object' }] };
+    const errors = [];
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      if (prop.type && value[key] !== undefined) {
+        const actual = typeof value[key];
+        if (actual !== prop.type && !(prop.type === 'number' && actual === 'integer')) {
+          errors.push({ text: `${key}: expected ${prop.type}, got ${actual}` });
+        }
+      }
+      if (prop.required && value[key] === undefined) {
+        errors.push({ text: `${key}: required but missing` });
+      }
+    }
+    return errors.length ? { ok: false, errors } : { ok: true };
+  }
+  return { ok: true };
+}
+
+module.exports = {
+  name: 'llm_task',
+  description: 'Run a generic JSON-only LLM task and return schema-validated JSON. No tool calls, no commentary.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      prompt: { type: 'string', description: 'Task instruction for the LLM' },
+      input: { type: 'object', description: 'Optional input payload for the task' },
+      schema: { type: 'object', description: 'Optional JSON Schema to validate the returned JSON' },
+      provider: { type: 'string', description: 'Provider override (e.g. openai, anthropic)' },
+      model: { type: 'string', description: 'Model override' },
+      temperature: { type: 'number', description: 'Temperature override' },
+      maxTokens: { type: 'number', description: 'Max tokens override' }
+    },
+    required: ['prompt']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const provider = params.provider || config.provider || 'openai';
+      const model = params.model || config.model || 'gpt-4o';
+
+      let apiKey;
+      if (provider === 'openai') apiKey = params.apiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
+      else if (provider === 'anthropic') apiKey = params.apiKey || config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+      else if (provider === 'groq') apiKey = params.apiKey || config.groqApiKey || process.env.GROQ_API_KEY;
+
+      if (!apiKey) {
+        return { success: false, error: `API key required for ${provider}. Set: natureco config set ${provider}ApiKey <key>` };
+      }
+
+      const systemPrompt = [
+        'You are a JSON-only function.',
+        'Return ONLY a valid JSON value.',
+        'Do not wrap in markdown fences.',
+        'Do not include commentary.',
+        'Do not call tools.'
+      ].join(' ');
+
+      const inputJson = JSON.stringify(params.input ?? null, null, 2);
+      const fullPrompt = `${systemPrompt}\n\nTASK:\n${params.prompt}\n\nINPUT:\n${inputJson}\n`;
+
+      const baseUrl = provider === 'openai' ? 'https://api.openai.com/v1' : `https://api.${provider}.com/v1`;
+      const requestBody = {
+        model,
+        messages: [{ role: 'user', content: fullPrompt }],
+        temperature: params.temperature ?? 0.1,
+        max_tokens: params.maxTokens ?? 4096
+      };
+
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify(requestBody)
+      });
+
+      if (!response.ok) {
+        return { success: false, error: `${provider} error ${response.status}: ${await response.text()}` };
+      }
+
+      const data = await response.json();
+      const text = data.choices?.[0]?.message?.content?.trim();
+      if (!text) return { success: false, error: 'LLM returned empty output' };
+
+      const raw = stripCodeFences(text);
+      let parsed;
+      try { parsed = JSON.parse(raw); }
+      catch { return { success: false, error: 'LLM returned invalid JSON', raw: text }; }
+
+      const schema = params.schema;
+      if (schema && typeof schema === 'object') {
+        const validation = validateAgainstSchema(parsed, schema);
+        if (!validation.ok) {
+          return {
+            success: false,
+            error: `JSON did not match schema: ${validation.errors.map(e => e.text).join('; ')}`,
+            raw: text,
+            parsed
+          };
+        }
+      }
+
+      return { success: true, data: parsed, provider, model };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/media_understanding.js

@@ -0,0 +1,128 @@
+const { getConfig } = require('../utils/config');
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  name: 'media_understanding',
+  description: 'Analyze images and media using AI vision models (OpenAI, Anthropic, Gemini, Groq)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      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'] },
+      model: { type: 'string', description: 'Model override' }
+    }
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const prompt = params.prompt || 'Describe this image in detail';
+      const provider = params.provider || config.visionProvider || 'openai';
+
+      if (!params.imagePath && !params.imageUrl) {
+        return { success: false, error: 'imagePath veya imageUrl gerekli' };
+      }
+
+      let imageBase64 = '';
+      let mediaType = 'image/jpeg';
+
+      if (params.imagePath) {
+        const resolvedPath = path.resolve(params.imagePath.replace(/^~/, require('os').homedir()));
+        if (!fs.existsSync(resolvedPath)) {
+          return { success: false, error: `Dosya bulunamadı: ${resolvedPath}` };
+        }
+        const ext = path.extname(resolvedPath).toLowerCase();
+        const mediaMap = { '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png', '.gif': 'image/gif', '.webp': 'image/webp' };
+        mediaType = mediaMap[ext] || 'image/jpeg';
+        imageBase64 = fs.readFileSync(resolvedPath).toString('base64');
+
+        // Check file size
+        const stats = fs.statSync(resolvedPath);
+        if (stats.size > 20 * 1024 * 1024) {
+          return { success: false, error: 'Dosya çok büyük (max 20MB)' };
+        }
+      }
+
+      const dataUrl = params.imageUrl || `data:${mediaType};base64,${imageBase64}`;
+
+      if (provider === 'openai') {
+        const apiKey = params.apiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
+        if (!apiKey) return { success: false, error: 'OpenAI API key gerekli' };
+
+        const response = await fetch('https://api.openai.com/v1/chat/completions', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+          body: JSON.stringify({
+            model: params.model || 'gpt-4o',
+            messages: [{
+              role: 'user',
+              content: [
+                { type: 'text', text: prompt },
+                { type: 'image_url', image_url: { url: dataUrl, detail: 'high' } }
+              ]
+            }],
+            max_tokens: 1000
+          })
+        });
+
+        if (!response.ok) throw new Error(`OpenAI error ${response.status}`);
+        const data = await response.json();
+        return { success: true, provider: 'openai', 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' };
+
+        const content = [{ type: 'text', text: prompt }];
+        if (params.imagePath) {
+          content.push({ type: 'image', source: { type: 'base64', media_type: mediaType, data: imageBase64 } });
+        } else {
+          content.push({ type: 'image', source: { type: 'url', url: params.imageUrl } });
+        }
+
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
+          body: JSON.stringify({ model: params.model || 'claude-3-5-sonnet-20241022', max_tokens: 1000, messages: [{ role: 'user', content }] })
+        });
+
+        if (!response.ok) throw new Error(`Anthropic error ${response.status}`);
+        const data = await response.json();
+        return { success: true, provider: 'anthropic', analysis: data.content?.[0]?.text || '' };
+      }
+
+      if (provider === 'groq') {
+        const apiKey = params.apiKey || config.providerApiKey || process.env.GROQ_API_KEY;
+        if (!apiKey) return { success: false, error: 'Groq API key gerekli' };
+
+        const response = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+          body: JSON.stringify({
+            model: params.model || 'llama-3.2-90b-vision-preview',
+            messages: [{
+              role: 'user',
+              content: [
+                { type: 'text', text: prompt },
+                { type: 'image_url', image_url: { url: params.imagePath ? `data:${mediaType};base64,${imageBase64}` : params.imageUrl } }
+              ]
+            }],
+            max_tokens: 1000
+          })
+        });
+
+        if (!response.ok) throw new Error(`Groq error ${response.status}`);
+        const data = await response.json();
+        return { success: true, provider: 'groq', analysis: data.choices?.[0]?.message?.content || '' };
+      }
+
+      return { success: false, error: `Bilinmeyen provider: ${provider}` };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};