natureco-cli 5.63.0 → 5.64.1

package/src/utils/sub-agent.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { getProviderConfig } = require('./api');
+const { AgentWorkspaceManager } = require('./agent-workspace');
 
 const SUB_AGENTS_FILE = path.join(os.homedir(), '.natureco', 'sub-agents.json');
 
@@ -64,12 +65,15 @@ async function spawnSubAgent(type, task, options = {}) {
   saveAgents(agents);
 
   try {
+    const workspaceManager = options.workspaceManager || new AgentWorkspaceManager();
+    const useWorkspace = options.isolatedWorktree !== false && ['general', 'debugger'].includes(type);
+    const executeAgent = async (workspace = null) => {
     const providerConfig = getProviderConfig();
     if (!providerConfig) {
       throw new Error('Provider not configured. Run: natureco configure');
     }
 
-    const systemPrompt = options.systemPrompt || SYSTEM_PROMPTS[type];
+    const systemPrompt = (options.systemPrompt || SYSTEM_PROMPTS[type]) + (workspace ? `\n\nIsolated workspace: ${workspace.cwd}\nOnly operate inside this workspace.` : '');
 
     const baseUrl = providerConfig.url.replace(/\/+$/, '');
     const endpoint = `${baseUrl}/chat/completions`;
@@ -109,7 +113,14 @@ async function spawnSubAgent(type, task, options = {}) {
     const usage = data.usage || {};
     const duration = new Date(entry.completedAt) - new Date(entry.startedAt);
 
-    return { result: content, usage, duration };
+    return { result: content, usage, duration, workspace: workspace?.cwd || null };
+    };
+    if (useWorkspace) {
+      const isolated = await workspaceManager.run(entry.id, executeAgent, { merge: options.mergeWorktree === true });
+      if (!isolated.ok) throw new Error(isolated.error);
+      return isolated.result;
+    }
+    return await executeAgent();
   } catch (err) {
     entry.status = 'failed';
     entry.result = err.message;

package/src/utils/test-failure-analyzer.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const crypto = require('crypto');
+
+function fingerprint(text) {
+  return crypto.createHash('sha256').update(String(text || '').replace(/\d+ms|\d+\.\d+s|\d+/g, '#')).digest('hex').slice(0, 16);
+}
+
+function analyzeTestFailure(output, exitCode = 1) {
+  const text = String(output || '');
+  const findings = [];
+  const patterns = [
+    { type: 'assertion', re: /(?:AssertionError|expected .* (?:to|but)|FAIL\s+)([^\n]*)/gi },
+    { type: 'syntax', re: /(?:SyntaxError|ParseError)[:\s]+([^\n]*)/gi },
+    { type: 'type', re: /(?:TypeError|TS\d{4}:)[:\s]*([^\n]*)/gi },
+    { type: 'module', re: /(?:Cannot find module|ModuleNotFoundError)[:\s]*([^\n]*)/gi },
+    { type: 'timeout', re: /(?:timed out|timeout of \d+ms exceeded|Test timeout)/gi },
+  ];
+  for (const pattern of patterns) {
+    pattern.re.lastIndex = 0;
+    let match;
+    while ((match = pattern.re.exec(text)) && findings.length < 50) {
+      findings.push({ type: pattern.type, message: (match[1] || match[0]).trim().slice(0, 500) });
+    }
+  }
+  const locations = [...text.matchAll(/(?:\(|\s)([^\s():]+\.(?:js|ts|tsx|jsx|py|go|rs|java)):(\d+)(?::(\d+))?/g)]
+    .slice(0, 50).map(match => ({ file: match[1], line: Number(match[2]), column: match[3] ? Number(match[3]) : null }));
+  const summaryMatch = text.match(/(\d+)\s+(?:failed|failing|failures?)/i);
+  return {
+    ok: exitCode === 0,
+    exitCode,
+    framework: /vitest/i.test(text) ? 'vitest' : /jest/i.test(text) ? 'jest' : /pytest|FAILED .*\.py/i.test(text) ? 'pytest' : /TS\d{4}/.test(text) ? 'typescript' : 'unknown',
+    failedCount: summaryMatch ? Number(summaryMatch[1]) : (exitCode === 0 ? 0 : Math.max(1, findings.length)),
+    findings, locations, fingerprint: fingerprint(text), rawTail: text.slice(-6000),
+  };
+}
+
+class AutoFixLoop {
+  constructor(options = {}) { this.maxAttempts = options.maxAttempts || 3; }
+
+  async run({ runTests, proposeFix, onAttempt }) {
+    const attempts = [];
+    let previousFingerprint = null;
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+      const startedAt = Date.now();
+      const testResult = await runTests({ attempt });
+      const analysis = analyzeTestFailure(testResult.output, testResult.exitCode);
+      const record = { attempt, analysis, durationMs: Date.now() - startedAt };
+      attempts.push(record);
+      if (onAttempt) await onAttempt(record);
+      if (analysis.ok) return { ok: true, attempts };
+      if (analysis.fingerprint === previousFingerprint) {
+        return { ok: false, stopped: 'no-progress', attempts, analysis };
+      }
+      previousFingerprint = analysis.fingerprint;
+      const fix = await proposeFix({ attempt, analysis, attempts });
+      record.fix = fix || null;
+      if (!fix || fix.applied === false) return { ok: false, stopped: 'no-fix', attempts, analysis };
+    }
+    return { ok: false, stopped: 'max-attempts', attempts, analysis: attempts.at(-1)?.analysis };
+  }
+}
+
+module.exports = { analyzeTestFailure, AutoFixLoop, fingerprint };

package/src/utils/token-budget.js

@@ -22,6 +22,7 @@ const PRESETS = {
     fileContentMaxChars: 1000,
     conversationOnDisk: 6,
     conversationInContext: 8,
+    workflowHistoryMaxTokens: 1024,
     autoCompact: true,
     compactModel: null,
     reservedTokens: 1024
@@ -42,6 +43,7 @@ const PRESETS = {
     fileContentMaxChars: 2000,
     conversationOnDisk: 10,
     conversationInContext: 12,
+    workflowHistoryMaxTokens: 2048,
     autoCompact: true,
     compactModel: null,
     reservedTokens: 2048
@@ -62,6 +64,7 @@ const PRESETS = {
     fileContentMaxChars: 5000,
     conversationOnDisk: 20,
     conversationInContext: 25,
+    workflowHistoryMaxTokens: 8192,
     autoCompact: false,
     compactModel: null,
     reservedTokens: 4096

package/src/utils/tool-execution-gateway.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { assessToolPath } = require('./tool-path-policy');
+const { validateJsonSchema } = require('./json-schema');
+const { standardToolResult } = require('./tool-result');
+
+// Transport-agnostic pipeline: resolve -> availability -> policy -> execute -> post-process.
+async function executeThroughGateway(options) {
+  const {
+    toolName, args = {}, resolveTool, checkAvailability, policyChecks = [],
+    execute, postProcess, allowSensitivePaths = false, standardResult = false,
+    normalizeSuccess = result => ({ result }),
+    normalizeError = error => ({ error }),
+  } = options || {};
+
+  if (!toolName || typeof resolveTool !== 'function') {
+    return normalizeError('Geçersiz araç çalıştırma isteği');
+  }
+
+  let tool;
+  try { tool = await resolveTool(toolName); }
+  catch (error) { return normalizeError(error?.message || String(error)); }
+
+  if (!tool) return normalizeError(`Tool bulunamadı: ${toolName}`);
+  const executor = execute || tool.execute;
+  if (typeof executor !== 'function') return normalizeError(`Tool execute fonksiyonu yok: ${toolName}`);
+
+  try {
+    const schema = tool.inputSchema || tool.parameters || tool.schema?.parameters;
+    const validation = validateJsonSchema(schema, args);
+    if (!validation.valid) return normalizeError(`Geçersiz araç argümanları: ${validation.errors.join('; ')}`);
+    if (!allowSensitivePaths) {
+      const pathDecision = assessToolPath(toolName, args);
+      if (!pathDecision.allowed) return normalizeError(pathDecision.reason);
+    }
+    if (checkAvailability) {
+      const decision = await checkAvailability({ toolName, args, tool });
+      if (decision === false) return normalizeError(`${toolName} şu anda kullanılamıyor`);
+      if (decision?.allowed === false) return normalizeError(decision.reason || `${toolName} şu anda kullanılamıyor`);
+    }
+    for (const check of policyChecks) {
+      if (typeof check !== 'function') continue;
+      const decision = await check({ toolName, args, tool });
+      if (decision === false) return normalizeError('Araç çalıştırma politikası engelledi');
+      if (decision?.allowed === false) return normalizeError(decision.reason || 'Araç çalıştırma politikası engelledi');
+    }
+    let result = await executor.call(tool, args);
+    if (postProcess) result = await postProcess({ toolName, args, tool, result });
+    if (standardResult) return standardToolResult(result, { tool: toolName });
+    return normalizeSuccess(result);
+  } catch (error) {
+    return normalizeError(error?.message || String(error));
+  }
+}
+
+module.exports = { executeThroughGateway };

package/src/utils/tool-manifest.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+let cache = null;
+
+function loadToolManifest({ toolsDir = path.join(__dirname, '..', 'tools'), refresh = false } = {}) {
+  if (cache && !refresh) return cache;
+  const entries = new Map();
+  if (!fs.existsSync(toolsDir)) return entries;
+  for (const file of fs.readdirSync(toolsDir).filter(name => name.endsWith('.js')).sort()) {
+    try {
+      const mod = require(path.join(toolsDir, file));
+      const name = mod.name || path.basename(file, '.js');
+      const execute = mod.execute || mod.default?.execute;
+      if (!name || typeof execute !== 'function') continue;
+      entries.set(name, {
+        name, description: mod.description || `${name} tool`,
+        inputSchema: mod.inputSchema || mod.parameters || { type: 'object', properties: {} },
+        execute, module: mod, source: file,
+      });
+    } catch { /* unavailable optional tool */ }
+  }
+  cache = entries;
+  return entries;
+}
+
+function clearToolManifestCache() { cache = null; }
+
+module.exports = { loadToolManifest, clearToolManifestCache };

package/src/utils/tool-path-policy.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+
+const SENSITIVE_READ = [
+  /(^|[\\/])\.ssh[\\/]/i, /id_rsa|id_ed25519|id_ecdsa|id_dsa/i,
+  /\.pem$|\.ppk$|\.key$/i, /(^|[\\/])\.aws[\\/]/i,
+  /gcloud[\\/].*(credential|token)/i, /(^|[\\/])\.npmrc$/i,
+  /(^|[\\/])\.git-credentials$/i, /\.natureco[\\/]config\.json$/i,
+  /(^|[\\/])\.netrc$/i,
+];
+const SENSITIVE_WRITE = [
+  ...SENSITIVE_READ,
+  /(^|[\\/])authorized_keys$/i, /System32[\\/]drivers[\\/]etc/i,
+  /\.aws[\\/]credentials/i,
+  /^[/\\](etc|usr|bin|sbin|boot|sys)[\\/]/i,
+  /(^|[\\/])etc[\\/](passwd|shadow|sudoers|hosts|crontab|ssh)/i,
+];
+
+function expandPath(value) {
+  if (typeof value !== 'string' || !value.trim()) return value;
+  const trimmed = value.trim();
+  if (trimmed === '~') return os.homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return path.join(os.homedir(), trimmed.slice(2));
+  }
+  return path.resolve(trimmed);
+}
+
+function assessToolPath(toolName, args = {}) {
+  const rawPath = args.path || args.filePath || args.file_path;
+  if (!rawPath) return { allowed: true };
+  const targetPath = expandPath(rawPath);
+  const write = toolName === 'write_file' || toolName === 'edit_file' || toolName === 'structural_patch';
+  const read = toolName === 'read_file';
+  if (!write && !read) return { allowed: true, path: targetPath };
+  const patterns = write ? SENSITIVE_WRITE : SENSITIVE_READ;
+  if (patterns.some(pattern => pattern.test(targetPath))) {
+    return {
+      allowed: false,
+      path: targetPath,
+      reason: `Hassas dosya yolu güvenlik politikasıyla engellendi: ${targetPath}`,
+    };
+  }
+  return { allowed: true, path: targetPath };
+}
+
+module.exports = { assessToolPath, expandPath, SENSITIVE_READ, SENSITIVE_WRITE };

package/src/utils/tool-result.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function standardToolResult(value, metrics = {}) {
+  if (value && typeof value === 'object' && typeof value.ok === 'boolean' && 'data' in value) return value;
+  const failed = value && typeof value === 'object' && (value.success === false || value.error);
+  const error = failed ? String(value.error || 'Tool execution failed') : null;
+  return {
+    ok: !failed,
+    data: failed ? null : value,
+    error,
+    warnings: Array.isArray(value?.warnings) ? value.warnings : [],
+    artifacts: Array.isArray(value?.artifacts) ? value.artifacts : [],
+    metrics: { ...metrics, ...(value?.metrics || {}) },
+  };
+}
+
+module.exports = { standardToolResult };

package/src/utils/tool-runner.js

@@ -1,7 +1,11 @@
 const fs = require('fs');
 const path = require('path');
-const chalk = require('chalk');
-const inquirer = require('./inquirer-wrapper');
+const chalk = require('chalk');
+const inquirer = require('./inquirer-wrapper');
+const { executeThroughGateway } = require('./tool-execution-gateway');
+const { checkPermission } = require('./permissions');
+const { checkPreHooks, runPostHooks } = require('./tool-hooks');
+const { loadToolManifest } = require('./tool-manifest');
 
 // ── Spinner ───────────────────────────────────────────────────────────────────
 const SPINNER_FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
@@ -12,8 +16,8 @@ function startSpinner(label) {
     process.stdout.write(`\r${chalk.cyan(SPINNER_FRAMES[i++ % SPINNER_FRAMES.length])} ${chalk.gray(label)}`);
   }, 80);
   return timer;
-}
-
+}
+
 function stopSpinner(timer, label, success = true) {
   clearInterval(timer);
   if (success) {
@@ -55,23 +59,15 @@ function resetSessionStats() {
 }
 
 // ── Load tools ────────────────────────────────────────────────────────────────
-function loadTools() {
-  const toolsDir = path.join(__dirname, '..', 'tools');
-  const tools = {};
-
-  if (!fs.existsSync(toolsDir)) return tools;
-
-  const files = fs.readdirSync(toolsDir).filter(f => f.endsWith('.js'));
-  for (const file of files) {
-    try {
-      const tool = require(path.join(toolsDir, file));
-      if (tool.name && tool.execute) tools[tool.name] = tool;
-    } catch (err) {
-      console.error(chalk.red(`Failed to load tool ${file}:`, err.message));
-    }
-  }
-  return tools;
-}
+function loadTools() {
+  return Object.fromEntries([...loadToolManifest()].map(([name, entry]) => [name, {
+    ...entry.module,
+    name: entry.name,
+    description: entry.description,
+    inputSchema: entry.inputSchema,
+    execute: entry.execute,
+  }]));
+}
 
 function getToolDefinitions() {
   const tools = loadTools();
@@ -90,11 +86,12 @@ function getToolDefinitions() {
 // v5.51.1 GÜVENLİK: edit_file eklendi — write_file diff+onay isterken, aynı riski
 // taşıyan hedefli değişiklik (edit_file) onaysız geçiyordu (SELF.md kendini-onarma
 // + Tek Beyin kanal erişimiyle birleşince kritik).
-function needsConfirmation(toolName, params) {
+function needsConfirmation(toolName, params) {
   const p = params || {};
   return (
-    toolName === 'write_file' ||
-    toolName === 'edit_file' ||
+    toolName === 'write_file' ||
+    toolName === 'edit_file' ||
+    toolName === 'structural_patch' ||
     ((toolName === 'bash' || toolName === 'shell_command') && /\b(rm|mv|cp|chmod|chown|dd|mkfs|truncate)\b/.test(p.command || ''))
   );
 }
@@ -103,18 +100,33 @@ function needsConfirmation(toolName, params) {
 async function executeTool(toolName, params, opts = {}) {
   const safeParams = params ?? {};
   const tools = loadTools();
-  const tool = tools[toolName];
-  const agentMode = opts.agentMode || false;
-
-  if (!tool) {
-    return { success: false, error: `Tool '${toolName}' not found` };
-  }
+  const tool = tools[toolName];
+  const agentMode = opts.agentMode || false;
+  if (!tool) {
+    return { success: false, error: `Tool '${toolName}' not found` };
+  }
+
+  // Configured permission rules and pre-hooks are mandatory in every origin.
+  // Interactive callers may approve `ask`; API/headless/channel callers must
+  // fail closed because they cannot prove that a human approved the action.
+  const permission = checkPermission(toolName, safeParams);
+  const hook = checkPreHooks(toolName, safeParams);
+  const policy = evaluatePolicyDecision(permission, hook, opts);
+  const policyAsk = policy.needsApproval ? { reason: policy.reason } : null;
+  if (!policy.allowed) {
+    return {
+      success: false,
+      error: policy.needsApproval
+        ? `Etkileşimsiz çağrıda kullanıcı onayı gerekiyor: ${policy.reason || toolName}`
+        : policy.reason || 'Araç güvenlik politikasıyla engellendi.',
+    };
+  }
 
   const label = `${toolName}${safeParams.path ? ' — ' + safeParams.path : safeParams.command ? ' — ' + safeParams.command : ''}`;
 
   // ── Onay mekanizması (dosya değiştiren araçlar ve tehlikeli bash) ──────────
-  if (agentMode) {
-    if (needsConfirmation(toolName, safeParams)) {
+  if (agentMode) {
+    if (policyAsk || needsConfirmation(toolName, safeParams)) {
       if (toolName === 'write_file') {
         // Diff göster
         let oldContent = '';
@@ -136,8 +148,9 @@ async function executeTool(toolName, params, opts = {}) {
         console.log(chalk.yellow(`\n  🖥️  Komut: ${chalk.white(safeParams.command)}\n`));
       }
 
-      const confirmMsg =
-        toolName === 'write_file' ? `✏️  ${safeParams.path} dosyası değiştirilecek` :
+      const confirmMsg =
+        policyAsk ? `🛡️  ${policyAsk.reason || toolName + ' için izin gerekli'}` :
+        toolName === 'write_file' ? `✏️  ${safeParams.path} dosyası değiştirilecek` :
         toolName === 'edit_file' ? `✏️  ${safeParams.path} dosyasında değişiklik yapılacak` :
         '⚠️  Bu komut çalıştırılacak';
       const { confirm } = await inquirer.prompt([{
@@ -155,23 +168,37 @@ async function executeTool(toolName, params, opts = {}) {
   }
 
   // ── Spinner ile çalıştır ──────────────────────────────────────────────────
-  const spinner = startSpinner(label);
-  try {
-    const result = await tool.execute(safeParams);
-    stopSpinner(spinner, label, result.success !== false);
-
-    // İstatistik güncelle
-    if (result.success !== false) {
-      if (toolName === 'write_file' || toolName === 'edit_file') filesChanged++;
-      if (toolName === 'bash') commandsRun++;
-    }
-
-    return result;
-  } catch (error) {
-    stopSpinner(spinner, label, false);
-    return { success: false, error: error.message };
-  }
-}
+  const spinner = startSpinner(label);
+  const result = await executeThroughGateway({
+    toolName,
+    args: safeParams,
+    resolveTool: () => tool,
+    postProcess: ({ result: value }) => runPostHooks(toolName, safeParams, value),
+    normalizeSuccess: value => value,
+    normalizeError: error => ({ success: false, error }),
+    allowSensitivePaths: !!opts.allowSensitivePaths,
+  });
+  stopSpinner(spinner, label, result.success !== false);
+
+  // İstatistik güncelle
+  if (result.success !== false) {
+    if (toolName === 'write_file' || toolName === 'edit_file' || toolName === 'structural_patch') filesChanged++;
+    if (toolName === 'bash' || toolName === 'shell_command') commandsRun++;
+  }
+
+  return result;
+}
+
+function evaluatePolicyDecision(permission, hook, opts = {}) {
+  const decisions = [permission, hook].filter(Boolean);
+  const denied = decisions.find(decision => decision.action === 'deny');
+  if (denied) return { allowed: false, needsApproval: false, reason: denied.reason };
+  const asked = decisions.find(decision => decision.action === 'ask');
+  if (!asked) return { allowed: true, needsApproval: false };
+  if (opts.agentMode) return { allowed: true, needsApproval: true, reason: asked.reason };
+  if (opts.approvalMode === 'preapproved') return { allowed: true, needsApproval: false };
+  return { allowed: false, needsApproval: true, reason: asked.reason };
+}
 
 // ── Execute multiple tool calls (parallel for independent, sequential for others) ──
 const PARALLEL_SAFE_TOOLS = new Set(['read_file', 'file_search', 'grep_search', 'web_search', 'web_readability', 'duckduckgo_search', 'exa_search', 'searxng_search', 'firecrawl', 'memory_search', 'memory']);
@@ -210,5 +237,6 @@ module.exports = {
   executeToolCalls,
   getSessionStats,
   resetSessionStats,
-  needsConfirmation,
-};
+  needsConfirmation,
+  evaluatePolicyDecision,
+};

package/src/utils/tools.js

@@ -5,18 +5,16 @@
  * v5.7.17: Emoji + toolset + check_fn + registry entegrasyonu.
  */
 
-const fs = require('fs');
-const path = require('path');
-const { globalRegistry } = require('./registry');
-const sandbox = require('./sandbox');
+const { globalRegistry } = require('./registry');
+const sandbox = require('./sandbox');
+const { executeThroughGateway } = require('./tool-execution-gateway');
+const { loadToolManifest } = require('./tool-manifest');
 
 // Lazy config read — avoids circular deps
 function _getSandboxLevel() {
   try { return sandbox.getLevel(require('./config').getConfig()); } catch { return 'none'; }
 }
 
-const TOOLS_DIR = path.join(__dirname, '..', 'tools');
-
 // ── Emoji map (central, tek kaynak) ──────────────────────────────────────
 const EMOJI_MAP = {
   // File operations
@@ -174,7 +172,7 @@ function getToolsForProvider(allTools, providerUrl) {
 
 function loadToolDefinitions() {
   const tools = [];
-  const files = fs.readdirSync(TOOLS_DIR).filter(f => f.endsWith('.js'));
+  const manifest = loadToolManifest();
 
   let isGroq = false;
   try {
@@ -197,20 +195,19 @@ function loadToolDefinitions() {
     'soul', 'memory', 'memory_write', 'memory_search', 'filesystem', 'grep_search'
   ]);
 
-  for (const file of files) {
-    try {
-      const toolPath = path.join(TOOLS_DIR, file);
-      const mod = require(toolPath);
-      const toolName = mod.name || path.basename(file, '.js');
+  for (const entry of manifest.values()) {
+    try {
+      const mod = entry.module;
+      const toolName = entry.name;
 
       if (isGroq && !GROQ_ALLOWED.has(toolName)) continue;
       if (disabledTools.has(toolName)) continue;
 
       const meta = {
         name: toolName,
-        description: mod.description || `${path.basename(file, '.js')} tool`,
-        parameters: mod.parameters || mod.inputSchema || { type: 'object', properties: {} },
-        execute: mod.execute || (mod.default && mod.default.execute) || null,
+        description: entry.description,
+        parameters: entry.inputSchema,
+        execute: entry.execute,
         emoji: EMOJI_MAP[toolName] || '',
         toolset: TOOLSET_MAP[toolName] || 'general',
         checkFn: CHECK_FN_MAP[toolName] || null,
@@ -290,33 +287,24 @@ function toOpenAIFormat(toolDefs) {
     });
 }
 
-async function executeTool(toolName, args, toolDefs) {
-  const tool = toolDefs.find(t => t.name === toolName);
-  if (!tool) return { error: `Tool bulunamadı: ${toolName}` };
-  if (!tool.execute) return { error: `Tool execute fonksiyonu yok: ${toolName}` };
-  // checkFn — tool disabled? (re-check at runtime with cache)
-  if (tool.checkFn) {
-    if (!_cachedCheckFn(tool.checkFn, tool.name)) {
-      return { error: `${toolName} şu anda kullanılamıyor (check_fn engelledi)` };
-    }
-  }
-
-  // Sandbox restrictions for bash/shell_command
-  if (toolName === 'bash' || toolName === 'shell_command') {
-    const level = _getSandboxLevel();
-    const cmd = (args && args.command) || '';
-    if (level === 'strict' && sandbox.isNetworkCommand(cmd)) {
-      return { error: 'strict sandbox: network komutları engellendi. Daha düşük sandbox seviyesi kullanın.' };
-    }
-  }
-
-  try {
-    const result = await tool.execute(args || {});
-    return { result };
-  } catch (e) {
-    return { error: e.message || String(e) };
-  }
-}
+async function executeTool(toolName, args, toolDefs) {
+  return executeThroughGateway({
+    toolName,
+    args: args || {},
+    resolveTool: name => (toolDefs || []).find(tool => tool.name === name),
+    checkAvailability: ({ tool }) => !tool.checkFn || _cachedCheckFn(tool.checkFn, tool.name)
+      ? true
+      : { allowed: false, reason: `${toolName} şu anda kullanılamıyor (check_fn engelledi)` },
+    policyChecks: [({ args: safeArgs }) => {
+      if (toolName !== 'bash' && toolName !== 'shell_command') return true;
+      const level = _getSandboxLevel();
+      if (level === 'strict' && sandbox.isNetworkCommand(safeArgs.command || '')) {
+        return { allowed: false, reason: 'strict sandbox: network komutları engellendi. Daha düşük sandbox seviyesi kullanın.' };
+      }
+      return true;
+    }],
+  });
+}
 
 module.exports = {
   loadToolDefinitions, toOpenAIFormat, executeTool, getToolsForProvider,