natureco-cli 2.23.29 → 2.23.31

package/src/tools/thread_ownership.js

@@ -0,0 +1,88 @@
+const { getConfig, saveConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'thread_ownership',
+  description: 'Manage message thread ownership — assign threads to specific agents/bots',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'Action: assign, release, status, list', enum: ['assign', 'release', 'status', 'list'] },
+      threadId: { type: 'string', description: 'Thread/channel/conversation ID' },
+      agentName: { type: 'string', description: 'Agent name to assign (for assign action)' },
+      channel: { type: 'string', description: 'Channel type: telegram, whatsapp, signal, irc, mattermost, discord, slack' }
+    },
+    required: ['action']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const ownership = config.threadOwnership || {};
+
+      if (params.action === 'list') {
+        const entries = Object.entries(ownership);
+        if (entries.length === 0) {
+          return { success: true, action: 'list', message: 'Atanmış thread yok.', threads: [] };
+        }
+        return {
+          success: true,
+          action: 'list',
+          threads: entries.map(([id, agent]) => ({
+            threadId: id,
+            assignedAgent: agent
+          })),
+          count: entries.length
+        };
+      }
+
+      if (params.action === 'status') {
+        if (!params.threadId) {
+          return { success: false, error: 'threadId gerekli' };
+        }
+        const assigned = ownership[params.threadId];
+        return {
+          success: true,
+          action: 'status',
+          threadId: params.threadId,
+          assignedAgent: assigned || null,
+          isAssigned: !!assigned
+        };
+      }
+
+      if (params.action === 'assign') {
+        if (!params.threadId || !params.agentName) {
+          return { success: false, error: 'threadId ve agentName gerekli' };
+        }
+        ownership[params.threadId] = params.agentName;
+        config.threadOwnership = ownership;
+        saveConfig(config);
+        return {
+          success: true,
+          action: 'assign',
+          threadId: params.threadId,
+          agentName: params.agentName,
+          message: `Thread ${params.threadId} → ${params.agentName}`
+        };
+      }
+
+      if (params.action === 'release') {
+        if (!params.threadId) {
+          return { success: false, error: 'threadId gerekli' };
+        }
+        delete ownership[params.threadId];
+        config.threadOwnership = ownership;
+        saveConfig(config);
+        return {
+          success: true,
+          action: 'release',
+          threadId: params.threadId,
+          message: `Thread ${params.threadId} serbest bırakıldı`
+        };
+      }
+
+      return { success: false, error: `Bilinmeyen aksiyon: ${params.action}` };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/video_generation.js

@@ -0,0 +1,72 @@
+const { getConfig } = require('../utils/config');
+
+const PROVIDERS = {
+  runway: {
+    name: 'RunwayML',
+    async generate({ prompt, apiKey, model }) {
+      const response = await fetch('https://api.runwayml.com/v1/text_to_video', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          model: model || 'gen3a_turbo',
+          prompt_text: prompt,
+          prompt_image: null,
+          duration: 5
+        })
+      });
+      if (!response.ok) throw new Error(`Runway error ${response.status}: ${await response.text()}`);
+      const data = await response.json();
+      return [{ url: data.video?.url || data.url, id: data.id }];
+    }
+  }
+};
+
+module.exports = {
+  name: 'video_generation',
+  description: 'Generate videos using AI. Supports RunwayML provider.',
+  inputSchema: {
+    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'] },
+      model: { type: 'string', description: 'Model override (default: gen3a_turbo)' }
+    },
+    required: ['prompt']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const provider = params.provider || 'runway';
+
+      const providerConfig = PROVIDERS[provider];
+      if (!providerConfig) {
+        return { success: false, error: `Desteklenmeyen provider: ${provider}` };
+      }
+
+      const apiKey = params.apiKey || config.runwayApiKey || process.env.RUNWAY_API_KEY;
+      if (!apiKey) {
+        return {
+          success: false,
+          error: `${providerConfig.name} API key gerekli.\nKur: natureco config set runwayApiKey <key>`
+        };
+      }
+
+      const videos = await providerConfig.generate({
+        prompt: params.prompt,
+        apiKey,
+        model: params.model
+      });
+
+      return {
+        success: true,
+        prompt: params.prompt,
+        provider,
+        videos,
+        count: videos.length
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/web_readability.js

@@ -0,0 +1,104 @@
+const { getConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'web_readability',
+  description: 'Extract readable content from any web page (Mozilla Readability algorithm, no API key needed)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      url: { type: 'string', description: 'URL to extract readable content from' },
+      maxChars: { type: 'number', description: 'Maximum characters to return (default: 10000)', default: 10000 }
+    },
+    required: ['url']
+  },
+
+  async execute(params) {
+    try {
+      const maxChars = params.maxChars || 10000;
+
+      const response = await fetch(params.url, {
+        headers: { 'User-Agent': 'Mozilla/5.0 (compatible; NatureCo-CLI/2.0; +https://natureco.me)' },
+        signal: AbortSignal.timeout(15000)
+      });
+
+      if (!response.ok) {
+        return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+      }
+
+      const html = await response.text();
+      const contentType = response.headers.get('content-type') || '';
+      const isHtml = contentType.includes('text/html') || contentType.includes('text/plain') || html.trim().startsWith('<');
+
+      if (!isHtml) {
+        return { success: false, error: 'URL does not contain HTML content' };
+      }
+
+      // Extract title
+      const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+      const title = titleMatch ? titleMatch[1].trim() : '';
+
+      // Extract meta description
+      const descMatch = html.match(/<meta[^>]+name=["']description["'][^>]+content=["']([^"']*)["']/i);
+      const description = descMatch ? descMatch[1] : '';
+
+      // Strip HTML tags for readable text
+      let text = html
+        // Remove scripts and styles
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, ' ')
+        .replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, ' ')
+        .replace(/<header[^>]*>[\s\S]*?<\/header>/gi, ' ')
+        // Remove all HTML tags
+        .replace(/<[^>]+>/g, ' ')
+        // Decode HTML entities
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&#x2F;/g, '/')
+        .replace(/&#\d+;/g, ' ')
+        // Normalize whitespace
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+
+      // Extract meaningful paragraphs
+      const paragraphs = [];
+      const pRegex = /<p[^>]*>([\s\S]*?)<\/p>/gi;
+      let pMatch;
+      while ((pMatch = pRegex.exec(html)) !== null) {
+        const pText = pMatch[1]
+          .replace(/<[^>]+>/g, '')
+          .replace(/&nbsp;/g, ' ')
+          .replace(/\s+/g, ' ')
+          .trim();
+        if (pText.length > 20) paragraphs.push(pText);
+      }
+
+      // Prefer paragraph extraction, fall back to full text
+      const content = paragraphs.length > 0
+        ? paragraphs.join('\n\n')
+        : text;
+
+      const truncated = content.length > maxChars
+        ? content.slice(0, maxChars) + '...'
+        : content;
+
+      return {
+        success: true,
+        url: params.url,
+        title,
+        description,
+        content: truncated,
+        wordCount: content.split(/\s+/).length,
+        totalChars: content.length,
+        truncated: content.length > maxChars,
+        source: 'readability'
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/utils/agents-md.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+
+const cache = new Map();
+
+const AGENTS_MD_FILENAMES = [
+  'AGENTS.md',
+  '.natureco/AGENTS.md',
+  '.natureco/INSTRUCTIONS.md',
+];
+
+function isRoot(dir) {
+  const parsed = path.parse(dir);
+  return parsed.root === dir;
+}
+
+function hasGit(dir) {
+  return fs.existsSync(path.join(dir, '.git'));
+}
+
+function findAgentsMd(cwd) {
+  let current = path.resolve(cwd || process.cwd());
+
+  while (true) {
+    for (const relPath of AGENTS_MD_FILENAMES) {
+      const candidate = path.join(current, relPath);
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    }
+
+    if (isRoot(current) || hasGit(current)) {
+      break;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return null;
+}
+
+function loadInstructions(cwd) {
+  const resolvedCwd = path.resolve(cwd || process.cwd());
+
+  if (cache.has(resolvedCwd)) {
+    return cache.get(resolvedCwd);
+  }
+
+  const filePath = findAgentsMd(resolvedCwd);
+  if (!filePath) {
+    cache.set(resolvedCwd, null);
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    cache.set(resolvedCwd, content);
+    return content;
+  } catch {
+    cache.set(resolvedCwd, null);
+    return null;
+  }
+}
+
+function injectIntoPrompt(systemPrompt, cwd) {
+  const instructions = loadInstructions(cwd);
+  if (!instructions) {
+    return systemPrompt;
+  }
+
+  const header = '\n\n## Project Instructions (from AGENTS.md)\n\n';
+  return systemPrompt + header + instructions.trim();
+}
+
+function clearCache() {
+  cache.clear();
+}
+
+module.exports = {
+  loadInstructions,
+  injectIntoPrompt,
+  clearCache,
+};

package/src/utils/api.js

@@ -8,6 +8,7 @@ const chalk = require('chalk');
 const { getConfig } = require('./config');
 const { getToolDefinitions, executeToolCalls } = require('./tool-runner');
 const { MCPClient } = require('./mcp-client');
+const TB = require('./token-budget');
 
 // Persistent conversation directory
 const CONV_DIR = path.join(os.homedir(), '.natureco', 'conversations');
@@ -60,7 +61,7 @@ function saveConversation(convId, messages) {
   try {
     fs.mkdirSync(CONV_DIR, { recursive: true });
     // Keep only last 10 messages
-    fs.writeFileSync(file, JSON.stringify(messages.slice(-10), null, 2));
+    fs.writeFileSync(file, JSON.stringify(messages.slice(-(TB.load().conversationOnDisk)), null, 2));
   } catch (e) {
     // Silently fail
   }
@@ -188,7 +189,7 @@ function normalizeMcpToolSchema(tool) {
 function minimizeMcpTool(tool) {
   return {
     name: tool.name,
-    description: (tool.description || '').slice(0, 100),
+    description: TB.capMcpDesc(tool.description),
     inputSchema: {
       type: tool.inputSchema?.type || 'object',
       properties: Object.fromEntries(
@@ -265,9 +266,10 @@ async function executeMcpTool(toolName, toolArgs) {
           if (textContents.length > 0) {
             let output = textContents.join('\n');
             
-            // Truncate MCP result to max 1500 characters
-            if (output.length > 1500) {
-              output = output.slice(0, 1500) + '... (truncated)';
+            // Truncate MCP result
+            const maxChars = TB.load().toolMaxChars;
+            if (output.length > maxChars) {
+              output = output.slice(0, maxChars) + '... (truncated)';
             }
             
             return {
@@ -281,8 +283,9 @@ async function executeMcpTool(toolName, toolArgs) {
         let fallbackOutput = JSON.stringify(result, null, 2);
         
         // Truncate fallback output too
-        if (fallbackOutput.length > 1500) {
-          fallbackOutput = fallbackOutput.slice(0, 1500) + '... (truncated)';
+        const maxChars = TB.load().toolMaxChars;
+        if (fallbackOutput.length > maxChars) {
+          fallbackOutput = fallbackOutput.slice(0, maxChars) + '... (truncated)';
         }
         
         return {
@@ -467,6 +470,7 @@ async function sendMessageOpenAICompatible(providerConfig, messages, tools) {
     role: 'assistant',
     content,
     tool_calls: data.choices?.[0]?.message?.tool_calls || undefined,
+    usage: data.usage || undefined,
   };
 }
 
@@ -519,7 +523,8 @@ async function sendMessageAnthropic(providerConfig, messages, tools) {
   return {
     role: 'assistant',
     content: content,
-    tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+    tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+    usage: data.usage || undefined,
   };
 }
 
@@ -548,18 +553,22 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
   const convId = conversationId || generateDefaultConvId();
   const history = loadConversation(convId);
 
+  // Augment system prompt with project AGENTS.md instructions
+  const agentsMd = require('./agents-md');
+  const augmentedPrompt = agentsMd.injectIntoPrompt(systemPrompt || '', options?.cwd || process.cwd());
+
   // Build messages
   const messages = [];
-  if (systemPrompt) {
-    messages.push({ role: 'system', content: systemPrompt });
+  if (augmentedPrompt) {
+    messages.push({ role: 'system', content: augmentedPrompt });
   }
   messages.push(...history);
   messages.push({ role: 'user', content: message });
 
-  // Get tool definitions (local + MCP)
-  const tools = providerConfig.isAnthropic 
-    ? formatToolsForAnthropic() 
-    : formatToolsForOpenAI();
+  // Get tool definitions (local + MCP) — skip if noTools flag set (chat mode)
+  const tools = options.noTools 
+    ? [] 
+    : (providerConfig.isAnthropic ? formatToolsForAnthropic() : formatToolsForOpenAI());
 
   debugLog('\n[Provider] Sending request...');
   debugLog('[Provider] URL:', providerConfig.url);
@@ -572,7 +581,7 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
   let iteration = 0;
   const maxIterations = 10;
   let finalResponse = null;
-  const stream = options.stream !== false && 
+  const stream = (options.stream ?? options.noStream === undefined) !== false && 
     !providerConfig.url.includes('api.natureco.me');
 
   while (iteration < maxIterations) {
@@ -604,6 +613,14 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
       };
     }
 
+    // Track token usage if available
+    if (assistantMessage.usage) {
+      TB.trackUsage(convId, {
+        input: assistantMessage.usage.prompt_tokens || assistantMessage.usage.input_tokens || 0,
+        output: assistantMessage.usage.completion_tokens || assistantMessage.usage.output_tokens || 0
+      });
+    }
+
     debugLog('[Provider] Response type:', assistantMessage?.tool_calls ? 'tool_calls' : 'text');
 
     // Add assistant message to history
@@ -681,6 +698,9 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
     finalResponse = finalResponse || 'Max tool execution iterations reached.';
   }
 
+  // Apply token budget trimming
+  messages = TB.trimMessages(messages);
+
   // Save to conversation history (only user and final assistant message)
   history.push({ role: 'user', content: message });
   history.push({ role: 'assistant', content: finalResponse });
@@ -755,35 +775,14 @@ async function sendMessage(apiKey, botId, message, conversationId = null, chatSy
     return sendMessageToProvider(apiKey, message, conversationId, prompt, options);
   }
 
-  // Base system prompt — kısa (~3000 token max)
+  // Minimal base prompt (~200 token)
   const toolDefs = getToolDefinitions();
   const toolsDesc = toolDefs.map(t => t.name).join(', ');
-  let baseSystemPrompt = `Terminal assistant. Use tools when needed.
-Home: ${homeDir}
-Tools: ${toolsDesc}`;
+  let systemPrompt = `Assistant. Tools: ${toolsDesc}. Home: ${homeDir}.`;
 
-  // MCP sayı parametresi uyarısı — sadece MCP aktifse
-  if (config.mcpEnabled !== false) {
-    baseSystemPrompt += `\nMCP: send number params as numbers, not strings.`;
-  }
-
-  // Prepend botName
-  if (mem.botName) {
-    baseSystemPrompt = `Adın ${mem.botName}. Sen ${mem.botName}'sun. Adın sorulduğunda her zaman "${mem.botName}" de.\n\n` + baseSystemPrompt;
-  }
-
-  let systemPrompt = baseSystemPrompt;
-
-  // Append chat.js system prompt (memory + skills + agents) — max 3000 chars
+  // Skill prompts only, max 500 chars
   if (chatSystemPrompt) {
-    systemPrompt += '\n\n' + chatSystemPrompt.slice(0, 3000);
-  }
-
-  // Add MCP server names if enabled and loaded
-  const mcpTools = getMcpTools();
-  if (config.mcpEnabled !== false && mcpTools.length > 0) {
-    const mcpServerNames = Object.keys(mcpClients);
-    systemPrompt += `\n\nMCP SERVERS: ${mcpServerNames.join(', ')}`;
+    systemPrompt += '\n' + chatSystemPrompt.slice(0, TB.load().systemPromptMaxChars);
   }
   
   return sendMessageToProvider(apiKey, message, conversationId, systemPrompt, options);

package/src/utils/format.js

@@ -0,0 +1,144 @@
+const chalk = require('chalk');
+
+const W = () => Math.min(process.stdout.columns || 100, 100);
+
+function header(text) {
+  const w = W();
+  const line = chalk.dim('┌' + '─'.repeat(w - 2) + '┐');
+  const padding = Math.max(0, w - text.length - 4);
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+  console.log('');
+  console.log(line);
+  console.log(chalk.dim('│') + ' '.repeat(leftPad) + chalk.bold.cyan(text) + ' '.repeat(rightPad) + chalk.dim('│'));
+  console.log(chalk.dim('└' + '─'.repeat(w - 2) + '┘'));
+}
+
+function section(text) {
+  const w = W();
+  console.log('');
+  console.log(chalk.dim('▔').repeat(Math.min(w - 4, 48)));
+  console.log(chalk.bold.cyan('  ' + text));
+}
+
+function divider() {
+  const w = W();
+  console.log(chalk.dim('─').repeat(Math.min(w - 4, 48)));
+}
+
+function label(key, value, options = {}) {
+  const { indent = 2, keyWidth = 14, valueColor = 'white' } = options;
+  const pad = ' '.repeat(indent);
+  const coloredKey = chalk.dim(key.padEnd(keyWidth));
+  const coloredValue = chalk[valueColor] ? chalk[valueColor](value) : chalk.white(value);
+  console.log(pad + coloredKey + coloredValue);
+}
+
+function kv(key, value) {
+  if (value === undefined || value === null) value = chalk.dim('—');
+  const keyStr = chalk.dim(key.padEnd(14));
+  console.log('  ' + keyStr + chalk.white(value));
+}
+
+function badge(text, color = 'cyan') {
+  const c = chalk[color] || chalk.cyan;
+  return c.bold(' ' + text + ' ');
+}
+
+function cmd(text) {
+  return chalk.cyan(text);
+}
+
+function flag(text) {
+  return chalk.yellow(text);
+}
+
+function success(text) {
+  console.log(chalk.green('  ✓ ' + text));
+}
+
+function error(text) {
+  console.log(chalk.red('  ✗ ' + text));
+}
+
+function warning(text) {
+  console.log(chalk.yellow('  ⚠ ' + text));
+}
+
+function info(text) {
+  console.log(chalk.blue('  ℹ ' + text));
+}
+
+function list(items, options = {}) {
+  const { indent = 2, bullet = '•' } = options;
+  const pad = ' '.repeat(indent);
+  for (const item of items) {
+    if (typeof item === 'string') {
+      console.log(pad + chalk.dim(bullet + ' ') + chalk.white(item));
+    } else if (item.label && item.value) {
+      console.log(pad + chalk.dim(bullet + ' ') + chalk.white(item.label + ': ') + chalk.dim(item.value));
+    } else if (item.label) {
+      console.log(pad + chalk.dim(bullet + ' ') + chalk.white(item.label));
+      if (item.desc) console.log(pad + '  ' + chalk.dim(item.desc));
+    }
+  }
+}
+
+function table(headers, rows, options = {}) {
+  const { indent = 2, headerColor = 'bold.cyan' } = options;
+  const pad = ' '.repeat(indent);
+
+  if (rows.length === 0) {
+    console.log(pad + chalk.dim('(empty)'));
+    return;
+  }
+
+  const colCount = headers.length;
+  const colWidths = headers.map((h, i) => {
+    const maxData = rows.reduce((max, row) => Math.max(max, String(row[i] || '').length), 0);
+    return Math.max(h.length, maxData) + 2;
+  });
+
+  const totalWidth = colWidths.reduce((a, b) => a + b, 0) + colCount - 1;
+  if (totalWidth > W() - indent) {
+    const ratio = (W() - indent - colCount + 1) / (totalWidth - colCount + 1);
+    for (let i = 0; i < colWidths.length; i++) {
+      colWidths[i] = Math.max(3, Math.floor((colWidths[i] - 2) * ratio) + 2);
+    }
+  }
+
+  const hdr = headers.map((h, i) => {
+    const w = colWidths[i];
+    const text = h.length > w - 1 ? h.slice(0, w - 2) + '…' : h.padEnd(w);
+    return chalk.bold.cyan(text);
+  }).join(' ');
+  console.log(pad + chalk.dim('┌' + '─'.repeat(totalWidth) + '┐'));
+  console.log(pad + chalk.dim('│') + hdr + chalk.dim('│'));
+  console.log(pad + chalk.dim('├' + '─'.repeat(totalWidth) + '┤'));
+
+  for (const row of rows) {
+    const cells = row.map((cell, i) => {
+      const w = colWidths[i];
+      const text = String(cell || '');
+      return (text.length > w - 1 ? text.slice(0, w - 2) + '…' : text.padEnd(w));
+    }).join(' ');
+    console.log(pad + chalk.dim('│') + cells + chalk.dim('│'));
+  }
+
+  console.log(pad + chalk.dim('└' + '─'.repeat(totalWidth) + '┘'));
+}
+
+function dot(enabled, label) {
+  const d = enabled ? chalk.green('●') : chalk.dim('○');
+  console.log('  ' + d + ' ' + chalk.white(label));
+}
+
+function meta(text) {
+  console.log(chalk.dim('  ' + text));
+}
+
+function json(obj) {
+  console.log(chalk.dim('  ') + chalk.white(JSON.stringify(obj, null, 2).replace(/\n/g, '\n  ')));
+}
+
+module.exports = { header, section, divider, label, kv, badge, cmd, flag, success, error, warning, info, list, table, dot, meta, json };

package/src/utils/headless.js

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 const { getProviderConfig } = require('./config');
+const TB = require('./token-budget');
 const { getToolDefinitions, executeTool } = require('./tool-runner');
 
 // ── Proje indexing (code.js'den paylaşılan) ───────────────────────────────────
@@ -169,7 +170,7 @@ Dosyalar: ${projectIndex.files.slice(0, 25).join(', ')}`;
         role: 'tool',
         tool_call_id: assistantMsg.tool_calls?.find(tc => tc.function.name === toolCall.name)?.id || toolCall.id,
         name: toolCall.name,
-        content: resultStr.slice(0, 3000),
+        content: resultStr.slice(0, TB.load().toolMaxChars),
       });
     }
   }