natureco-cli 2.23.28 → 2.23.30

package/src/tools/music_generation.js

@@ -0,0 +1,113 @@
+const { getConfig } = require('../utils/config');
+
+const PROVIDERS = {
+  suno: {
+    name: 'Suno AI (via API)',
+    async generate({ prompt, apiKey, model, duration, style }) {
+      const response = await fetch('https://api.sunoa.ai/v1/music/generate', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          prompt,
+          model: model || 'chirp-v3',
+          duration: duration || 30,
+          style: style || '',
+          make_instrumental: false
+        })
+      });
+      if (!response.ok) throw new Error(`Suno error ${response.status}: ${await response.text()}`);
+      return (await response.json()).data?.clips || [];
+    }
+  },
+  udio: {
+    name: 'Udio AI (via API)',
+    async generate({ prompt, apiKey, model, duration }) {
+      const response = await fetch('https://api.udio.ai/v1/music/generate', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          prompt,
+          model: model || 'udio-v1',
+          duration: duration || 30
+        })
+      });
+      if (!response.ok) throw new Error(`Udio error ${response.status}: ${await response.text()}`);
+      const data = await response.json();
+      return data.results || data.songs || [];
+    }
+  },
+  elevenlabs: {
+    name: 'ElevenLabs Sound Effects',
+    async generate({ prompt, apiKey, duration }) {
+      const response = await fetch('https://api.elevenlabs.io/v1/sound-generation', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'xi-api-key': apiKey },
+        body: JSON.stringify({
+          text: prompt,
+          duration_seconds: duration || 10
+        })
+      });
+      if (!response.ok) throw new Error(`ElevenLabs error ${response.status}: ${await response.text()}`);
+      const buffer = await response.arrayBuffer();
+      return [{ url: URL.createObjectURL(new Blob([buffer], { type: 'audio/mpeg' })), provider: 'elevenlabs' }];
+    }
+  }
+};
+
+module.exports = {
+  name: 'music_generation',
+  description: 'Generate music, songs, and sound effects using AI. Supports Suno, Udio, and ElevenLabs.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      prompt: { type: 'string', description: 'Description of the music/song to generate' },
+      provider: { type: 'string', description: 'Music provider: suno, udio, elevenlabs (default: suno)', enum: ['suno', 'udio', 'elevenlabs'] },
+      model: { type: 'string', description: 'Model override' },
+      duration: { type: 'number', description: 'Duration in seconds (default: 30)' },
+      style: { type: 'string', description: 'Style/genre hint (e.g. "pop", "jazz", "electronic")' }
+    },
+    required: ['prompt']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const provider = params.provider || config.musicProvider || 'suno';
+
+      const providerConfig = PROVIDERS[provider];
+      if (!providerConfig) {
+        return { success: false, error: `Unsupported provider: ${provider}. Available: ${Object.keys(PROVIDERS).join(', ')}` };
+      }
+
+      let apiKey;
+      if (provider === 'suno') apiKey = params.apiKey || config.sunoApiKey || process.env.SUNO_API_KEY;
+      else if (provider === 'udio') apiKey = params.apiKey || config.udioApiKey || process.env.UDIO_API_KEY;
+      else if (provider === 'elevenlabs') apiKey = params.apiKey || config.elevenlabsApiKey || process.env.ELEVENLABS_API_KEY;
+
+      if (!apiKey) {
+        return {
+          success: false,
+          error: `${providerConfig.name} API key required.\nSet: natureco config set ${provider}ApiKey <key>`
+        };
+      }
+
+      const music = await providerConfig.generate({
+        prompt: params.prompt,
+        apiKey,
+        model: params.model,
+        duration: params.duration,
+        style: params.style
+      });
+
+      return {
+        success: true,
+        prompt: params.prompt,
+        provider,
+        music: Array.isArray(music) ? music : [music],
+        count: Array.isArray(music) ? music.length : 1
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/parallel_search.js

@@ -0,0 +1,77 @@
+const { getConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'parallel_search',
+  description: 'Free web search using Parallel (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://api.duckduckgo.com/?q=${query}&format=json&no_html=1&skip_disambig=1`,
+        { headers: { 'User-Agent': 'NatureCo-CLI/2.0' } }
+      );
+
+      if (!response.ok) {
+        return { success: false, error: `Parallel search error: ${response.status}` };
+      }
+
+      const data = await response.json();
+      const results = [];
+
+      if (data.AbstractText) {
+        results.push({
+          title: data.Heading || 'Summary',
+          snippet: data.AbstractText,
+          url: data.AbstractURL || ''
+        });
+      }
+
+      if (data.Results && Array.isArray(data.Results)) {
+        for (const r of data.Results) {
+          if (results.length >= maxResults) break;
+          if (r.Text && r.FirstURL) {
+            results.push({ title: r.Text.split(' - ')[0] || r.Text, snippet: r.Text, url: r.FirstURL });
+          }
+        }
+      }
+
+      if (data.RelatedTopics && Array.isArray(data.RelatedTopics)) {
+        for (const r of data.RelatedTopics) {
+          if (results.length >= maxResults) break;
+          if (r.Text && r.FirstURL) {
+            results.push({ title: r.Text.split(' - ')[0] || r.Text, snippet: r.Text, url: r.FirstURL });
+          }
+          if (r.Topics && Array.isArray(r.Topics)) {
+            for (const t of r.Topics) {
+              if (results.length >= maxResults) break;
+              if (t.Text && t.FirstURL) {
+                results.push({ title: t.Text.split(' - ')[0] || t.Text, snippet: t.Text, url: t.FirstURL });
+              }
+            }
+          }
+        }
+      }
+
+      return {
+        success: true,
+        query: params.query,
+        results,
+        count: results.length,
+        source: 'parallel'
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/phone_control.js

@@ -0,0 +1,80 @@
+module.exports = {
+  name: 'phone_control',
+  description: 'Send notifications and control mobile devices via push services (Pushover, ntfy)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'Action: notify (send push notification)', enum: ['notify'] },
+      title: { type: 'string', description: 'Notification title' },
+      message: { type: 'string', description: 'Notification message body' },
+      priority: { type: 'number', description: 'Priority: -2 (lowest) to 2 (emergency)', default: 0 },
+      url: { type: 'string', description: 'Optional URL to open on click' },
+      service: { type: 'string', description: 'Push service: pushover, ntfy (default: pushover)', enum: ['pushover', 'ntfy'] }
+    },
+    required: ['action', 'message']
+  },
+
+  async execute(params) {
+    try {
+      const { getConfig } = require('../utils/config');
+      const config = getConfig();
+
+      if (params.action === 'notify') {
+        const service = params.service || 'pushover';
+
+        if (service === 'pushover') {
+          const token = params.token || config.pushoverToken || process.env.PUSHOVER_TOKEN;
+          const user = params.user || config.pushoverUser || process.env.PUSHOVER_USER;
+
+          if (!token || !user) {
+            return {
+              success: false,
+              error: 'Pushover token ve user gerekli.\nKur: natureco config set pushoverToken <token>\nnatureco config set pushoverUser <user>'
+            };
+          }
+
+          const response = await fetch('https://api.pushover.net/1/messages.json', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              token,
+              user,
+              title: params.title || 'NatureCo',
+              message: params.message,
+              priority: params.priority || 0,
+              url: params.url
+            })
+          });
+
+          if (!response.ok) throw new Error(`Pushover error ${response.status}`);
+          return { success: true, service: 'pushover', status: 'notification sent' };
+        }
+
+        if (service === 'ntfy') {
+          const server = params.server || config.ntfyServer || process.env.NTFY_SERVER || 'https://ntfy.sh';
+          const topic = params.topic || config.ntfyTopic || process.env.NTFY_TOPIC;
+
+          if (!topic) {
+            return {
+              success: false,
+              error: 'ntfy topic gerekli.\nKur: natureco config set ntfyTopic <topic>'
+            };
+          }
+
+          const response = await fetch(`${server}/${topic}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'text/plain' },
+            body: `[${params.title || 'NatureCo'}] ${params.message}`
+          });
+
+          if (!response.ok) throw new Error(`ntfy error ${response.status}`);
+          return { success: true, service: 'ntfy', status: 'notification sent' };
+        }
+      }
+
+      return { success: false, error: `Unknown action: ${params.action}` };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/phone_control_enhanced.js

@@ -0,0 +1,184 @@
+const { getConfig, saveConfig } = require('../utils/config');
+const { execSync } = require('child_process');
+
+function checkAdb() {
+  try {
+    execSync('adb version', { stdio: 'pipe', encoding: 'utf8' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function adbCommand(args) {
+  return execSync(`adb ${args}`, { stdio: 'pipe', encoding: 'utf8', maxBuffer: 1024 * 1024 }).trim();
+}
+
+module.exports = {
+  name: 'phone_control_enhanced',
+  description: 'Full mobile device control — notifications, ADB commands, camera, screen recording, SMS, contacts. Supports Pushover, ntfy, and ADB.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Action',
+        enum: ['notify', 'arm', 'disarm', 'status', 'devices', 'camera.snap', 'camera.clip', 'screen.record', 'sms.send', 'sms.list', 'contacts.list', 'adb']
+      },
+      title: { type: 'string', description: 'Notification title' },
+      message: { type: 'string', description: 'Notification message or SMS text' },
+      service: { type: 'string', description: 'Push service: pushover, ntfy (default: pushover)', enum: ['pushover', 'ntfy'] },
+      priority: { type: 'number', description: 'Priority: -2 to 2' },
+      phoneNumber: { type: 'string', description: 'Phone number for SMS' },
+      duration: { type: 'number', description: 'Duration in seconds for recording' },
+      adbCommand: { type: 'string', description: 'Raw ADB command (for adb action)' },
+      group: { type: 'string', description: 'Group to arm: camera, screen, writes, all' }
+    },
+    required: ['action']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+
+      if (params.action === 'notify') {
+        const service = params.service || 'pushover';
+        if (service === 'pushover') {
+          const token = config.pushoverToken || process.env.PUSHOVER_TOKEN;
+          const user = config.pushoverUser || process.env.PUSHOVER_USER;
+          if (!token || !user) return { success: false, error: 'Pushover token/user gerekli' };
+          const r = await fetch('https://api.pushover.net/1/messages.json', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ token, user, title: params.title || 'NatureCo', message: params.message, priority: params.priority || 0 })
+          });
+          return { success: r.ok, service: 'pushover' };
+        }
+        if (service === 'ntfy') {
+          const topic = config.ntfyTopic || process.env.NTFY_TOPIC;
+          if (!topic) return { success: false, error: 'ntfy topic gerekli' };
+          const server = config.ntfyServer || process.env.NTFY_SERVER || 'https://ntfy.sh';
+          const r = await fetch(`${server}/${topic}`, {
+            method: 'POST', headers: { 'Content-Type': 'text/plain' },
+            body: `[${params.title || 'NatureCo'}] ${params.message}`
+          });
+          return { success: r.ok, service: 'ntfy' };
+        }
+        return { success: false, error: `Unknown service: ${service}` };
+      }
+
+      if (params.action === 'arm') {
+        const group = params.group || 'all';
+        if (!config.phoneControl) config.phoneControl = {};
+        if (!config.phoneControl.armed) config.phoneControl.armed = {};
+        config.phoneControl.armed[group] = { armed: true, at: new Date().toISOString() };
+        saveConfig(config);
+        return { success: true, action: 'arm', group, status: 'armed' };
+      }
+
+      if (params.action === 'disarm') {
+        const group = params.group || 'all';
+        if (!config.phoneControl) config.phoneControl = {};
+        if (!config.phoneControl.armed) config.phoneControl.armed = {};
+        if (group === 'all') config.phoneControl.armed = {};
+        else delete config.phoneControl.armed[group];
+        saveConfig(config);
+        return { success: true, action: 'disarm', group, status: 'disarmed' };
+      }
+
+      if (params.action === 'status') {
+        const pc = config.phoneControl || {};
+        const armed = pc.armed || {};
+        const hasAdb = checkAdb();
+        return {
+          success: true,
+          action: 'status',
+          adbAvailable: hasAdb,
+          armed: Object.keys(armed).length > 0 ? armed : false,
+          pushoverConfigured: !!(config.pushoverToken || process.env.PUSHOVER_TOKEN),
+          ntfyConfigured: !!(config.ntfyTopic || process.env.NTFY_TOPIC)
+        };
+      }
+
+      if (params.action === 'devices') {
+        if (!checkAdb()) return { success: false, error: 'ADB bulunamadı. Android SDK kurulumu gerekli.' };
+        const output = adbCommand('devices -l');
+        const lines = output.split('\n').filter(l => l.trim() && !l.startsWith('List'));
+        const devices = lines.map(l => {
+          const parts = l.trim().split(/\s+/);
+          return { id: parts[0], state: parts[1], info: parts.slice(2).join(' ') };
+        });
+        return { success: true, action: 'devices', devices, count: devices.length };
+      }
+
+      if (params.action.startsWith('camera.')) {
+        if (!checkAdb()) return { success: false, error: 'ADB gerekli' };
+        if (params.action === 'camera.snap') {
+          const output = adbCommand('shell am start -a android.media.action.IMAGE_CAPTURE');
+          adbCommand('shell sleep 2');
+          adbCommand('shell input keyevent 27');
+          return { success: true, action: 'camera.snap', message: 'Camera capture triggered' };
+        }
+        if (params.action === 'camera.clip') {
+          const dur = params.duration || 10;
+          adbCommand(`shell am start -a android.media.action.VIDEO_CAPTURE --ei android.intent.extra.durationLimit ${dur}`);
+          adbCommand(`shell sleep ${dur + 2}`);
+          return { success: true, action: 'camera.clip', duration: dur };
+        }
+      }
+
+      if (params.action === 'screen.record') {
+        if (!checkAdb()) return { success: false, error: 'ADB gerekli' };
+        const dur = params.duration || 30;
+        const outputFile = `/sdcard/screen_${Date.now()}.mp4`;
+        adbCommand(`shell screenrecord --time-limit ${dur} ${outputFile}`);
+        return { success: true, action: 'screen.record', outputFile, duration: dur };
+      }
+
+      if (params.action === 'sms.send') {
+        if (!checkAdb()) {
+          if (!config.twilioSid) return { success: false, error: 'SMS için ADB veya Twilio gerekli' };
+          const sid = config.twilioSid || process.env.TWILIO_SID;
+          const token = config.twilioToken || process.env.TWILIO_TOKEN;
+          const from = config.twilioFrom || process.env.TWILIO_FROM;
+          if (!params.phoneNumber || !params.message) return { success: false, error: 'phoneNumber ve message gerekli' };
+          const r = await fetch(`https://api.twilio.com/2010-04-01/Accounts/${sid}/Messages.json`, {
+            method: 'POST',
+            headers: { 'Authorization': `Basic ${Buffer.from(`${sid}:${token}`).toString('base64')}`, 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({ To: params.phoneNumber, From: from, Body: params.message })
+          });
+          return { success: r.ok, action: 'sms.send', service: 'twilio' };
+        }
+        const output = adbCommand(`shell service call isms 7 i32 0 s16 "com.android.mms" s16 "${params.phoneNumber}" s16 "null" s16 "${params.message}" s16 "null" s16 "null"`);
+        return { success: true, action: 'sms.send', output: output.substring(0, 500) };
+      }
+
+      if (params.action === 'sms.list') {
+        if (!checkAdb()) return { success: false, error: 'ADB gerekli' };
+        const output = adbCommand('shell content query --uri content://sms/inbox --projection address,body,date --limit 20');
+        return { success: true, action: 'sms.list', messages: output.split('\n').filter(Boolean).map(l => l.trim()) };
+      }
+
+      if (params.action === 'contacts.list') {
+        if (!checkAdb()) return { success: false, error: 'ADB gerekli' };
+        const output = adbCommand('shell content query --uri content://contacts/phones --projection display_name,number --limit 50');
+        const contacts = output.split('\n').filter(Boolean).map(l => {
+          const m = l.match(/display_name=(.+?),.*?number=(.+?)(?:,|$)/);
+          return m ? { name: m[1], number: m[2] } : { raw: l.trim() };
+        });
+        return { success: true, action: 'contacts.list', contacts, count: contacts.length };
+      }
+
+      if (params.action === 'adb') {
+        if (!checkAdb()) return { success: false, error: 'ADB gerekli' };
+        if (!params.adbCommand) return { success: false, error: 'adbCommand gerekli' };
+        const output = adbCommand(params.adbCommand);
+        return { success: true, action: 'adb', command: params.adbCommand, output: output.substring(0, 10000) };
+      }
+
+      return { success: false, error: `Unknown action: ${params.action}` };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/searxng.js

@@ -0,0 +1,61 @@
+const { getConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'searxng_search',
+  description: 'Search the web using a SearXNG instance (self-hosted privacy search)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query' },
+      instanceUrl: { type: 'string', description: 'SearXNG instance URL (default: config.searxngInstanceUrl or https://search.sapti.me)' },
+      maxResults: { type: 'number', description: 'Maximum results (default: 5)', default: 5 },
+      categories: { type: 'string', description: 'Search categories: general, news, images, video, files (default: general)' }
+    },
+    required: ['query']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const instanceUrl = (params.instanceUrl || config.searxngInstanceUrl || 'https://search.sapti.me').replace(/\/+$/, '');
+      const maxResults = params.maxResults || 5;
+
+      const searchParams = new URLSearchParams({
+        q: params.query,
+        format: 'json',
+        language: 'en',
+        categories: params.categories || 'general',
+        pageno: 1
+      });
+
+      const response = await fetch(`${instanceUrl}/search?${searchParams}`, {
+        headers: { 'User-Agent': 'NatureCo-CLI/2.0', 'Accept': 'application/json' }
+      });
+
+      if (!response.ok) {
+        return { success: false, error: `SearXNG error: ${response.status}` };
+      }
+
+      const data = await response.json();
+
+      const results = (data.results || []).slice(0, maxResults).map(r => ({
+        title: r.title,
+        snippet: r.content,
+        url: r.url,
+        engine: r.engine,
+        category: r.category
+      }));
+
+      return {
+        success: true,
+        query: params.query,
+        instance: instanceUrl,
+        results,
+        count: results.length,
+        source: 'searxng'
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/speech_to_text.js

@@ -0,0 +1,135 @@
+const { getConfig } = require('../utils/config');
+const fs = require('fs');
+const path = require('path');
+
+const PROVIDERS = {
+  deepgram: {
+    name: 'Deepgram',
+    async transcribe({ audioPath, audioUrl, apiKey, language, model }) {
+      const url = audioPath
+        ? 'https://api.deepgram.com/v1/listen'
+        : `https://api.deepgram.com/v1/listen?url=${encodeURIComponent(audioUrl)}`;
+
+      const options = {
+        method: 'POST',
+        headers: { 'Authorization': `Token ${apiKey}` },
+        params: { model: model || 'nova-2', language: language || 'en', smart_format: 'true' }
+      };
+
+      if (audioPath) {
+        const audioFile = fs.readFileSync(audioPath);
+        options.body = audioFile;
+        options.headers['Content-Type'] = 'audio/wav';
+      }
+
+      const queryString = Object.entries(options.params).map(([k, v]) => `${k}=${v}`).join('&');
+      const response = await fetch(`${url}${audioPath ? '' : '&'}${queryString}`, {
+        method: 'POST',
+        headers: options.headers,
+        body: options.body
+      });
+
+      if (!response.ok) throw new Error(`Deepgram error ${response.status}`);
+      const data = await response.json();
+      return data.results?.channels?.[0]?.alternatives?.[0]?.transcript || '';
+    }
+  },
+  azure: {
+    name: 'Azure Speech',
+    async transcribe({ audioPath, apiKey, region, language }) {
+      const response = await fetch(
+        `https://${region}.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=${language || 'en-US'}`,
+        {
+          method: 'POST',
+          headers: {
+            'Ocp-Apim-Subscription-Key': apiKey,
+            'Content-Type': 'audio/wav; codecs=audio/pcm; samplerate=16000'
+          },
+          body: fs.readFileSync(audioPath)
+        }
+      );
+      if (!response.ok) throw new Error(`Azure error ${response.status}`);
+      const data = await response.json();
+      return data.DisplayText || '';
+    }
+  },
+  whisper: {
+    name: 'OpenAI Whisper',
+    async transcribe({ audioPath, apiKey, language }) {
+      const formData = new (require('form-data'))();
+      formData.append('file', fs.createReadStream(audioPath));
+      formData.append('model', 'whisper-1');
+      if (language) formData.append('language', language);
+
+      const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${apiKey}` },
+        body: formData
+      });
+
+      if (!response.ok) throw new Error(`Whisper error ${response.status}`);
+      const data = await response.json();
+      return data.text || '';
+    }
+  }
+};
+
+module.exports = {
+  name: 'speech_to_text',
+  description: 'Transcribe audio to text using Deepgram, Azure Speech, or OpenAI Whisper',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      audioPath: { type: 'string', description: 'Local audio file path' },
+      audioUrl: { type: 'string', description: 'Remote audio URL (if no local file)' },
+      provider: { type: 'string', description: 'STT provider: deepgram, azure, whisper (default: whisper)', enum: ['deepgram', 'azure', 'whisper'] },
+      language: { type: 'string', description: 'Language code (e.g. en, tr, fr)' }
+    }
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const provider = params.provider || config.sttProvider || 'whisper';
+
+      const providerConfig = PROVIDERS[provider];
+      if (!providerConfig) {
+        return { success: false, error: `Desteklenmeyen provider: ${provider}` };
+      }
+
+      if (!params.audioPath && !params.audioUrl) {
+        return { success: false, error: 'audioPath veya audioUrl gerekli' };
+      }
+
+      if (params.audioPath && !fs.existsSync(path.resolve(params.audioPath))) {
+        return { success: false, error: `Dosya bulunamadı: ${params.audioPath}` };
+      }
+
+      let apiKey;
+      if (provider === 'deepgram') apiKey = params.apiKey || config.deepgramApiKey || process.env.DEEPGRAM_API_KEY;
+      else if (provider === 'azure') apiKey = params.apiKey || config.azureSpeechKey || process.env.AZURE_SPEECH_KEY;
+      else apiKey = params.apiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
+
+      if (!apiKey) {
+        return { success: false, error: `${providerConfig.name} API key gerekli.` };
+      }
+
+      const transcript = await providerConfig.transcribe({
+        audioPath: params.audioPath,
+        audioUrl: params.audioUrl,
+        apiKey,
+        region: config.azureRegion || process.env.AZURE_REGION || 'eastus',
+        language: params.language
+      });
+
+      return {
+        success: true,
+        provider,
+        transcript: transcript || '(boş)',
+        wordCount: transcript ? transcript.split(/\s+/).length : 0
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};