neoagent 1.4.1 → 1.4.3

package/server/services/ai/toolResult.js

@@ -0,0 +1,151 @@
+function clampText(text, maxChars) {
+  const str = String(text || '');
+  if (str.length <= maxChars) return str;
+  return `${str.slice(0, maxChars)}\n...[truncated, ${str.length} chars total]`;
+}
+
+function lineExcerpt(text, maxLines = 12, maxChars = 700) {
+  const str = String(text || '').trim();
+  if (!str) return '';
+  return clampText(str.split('\n').slice(0, maxLines).join('\n'), maxChars);
+}
+
+function toJsonText(value, maxChars) {
+  const raw = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+  return clampText(raw, maxChars);
+}
+
+function trimObject(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined && value !== null && value !== ''));
+}
+
+function clampEnvelope(envelope, hardLimit) {
+  const raw = JSON.stringify(envelope);
+  if (raw.length <= hardLimit) return raw;
+
+  const trimmed = { ...envelope };
+  if (trimmed.summary) trimmed.summary = clampText(trimmed.summary, Math.max(200, hardLimit - 300));
+  if (trimmed.stdout) trimmed.stdout = clampText(trimmed.stdout, Math.max(160, hardLimit - 400));
+  if (trimmed.stderr) trimmed.stderr = clampText(trimmed.stderr, Math.max(120, hardLimit - 400));
+  if (trimmed.content) trimmed.content = clampText(trimmed.content, Math.max(160, hardLimit - 400));
+  if (trimmed.excerpt) trimmed.excerpt = clampText(trimmed.excerpt, Math.max(160, hardLimit - 400));
+  if (trimmed.result) trimmed.result = clampText(trimmed.result, Math.max(160, hardLimit - 400));
+
+  const fallback = JSON.stringify(trimmed);
+  if (fallback.length <= hardLimit) return fallback;
+  return clampText(fallback, hardLimit);
+}
+
+function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
+  const softLimit = Math.max(400, Math.min(Number(options.softLimit) || 1200, 2000));
+  const hardLimit = Math.max(softLimit, Math.min(Number(options.hardLimit) || 2000, 3000));
+
+  let envelope;
+
+  switch (toolName) {
+    case 'execute_command':
+      envelope = trimObject({
+        tool: toolName,
+        exitCode: toolResult?.exitCode,
+        cwd: toolResult?.cwd || toolArgs.cwd,
+        killed: toolResult?.killed || false,
+        stdout: lineExcerpt(toolResult?.stdout, 12, Math.floor(softLimit * 0.45)),
+        stderr: lineExcerpt(toolResult?.stderr, 8, Math.floor(softLimit * 0.25))
+      });
+      break;
+
+    case 'read_file':
+      envelope = trimObject({
+        tool: toolName,
+        path: toolArgs.path,
+        startLine: toolArgs.start_line,
+        endLine: toolArgs.end_line,
+        content: lineExcerpt(toolResult?.content || toolResult, 20, Math.floor(softLimit * 0.7))
+      });
+      break;
+
+    case 'search_files':
+      envelope = trimObject({
+        tool: toolName,
+        count: toolResult?.count || toolResult?.matches?.length || 0,
+        matches: (toolResult?.matches || []).slice(0, 6).map((match) => trimObject({
+          file: match.file,
+          line: match.line,
+          content: clampText(match.content, 160)
+        }))
+      });
+      break;
+
+    case 'browser_extract':
+      envelope = trimObject({
+        tool: toolName,
+        selector: toolArgs.selector || 'body',
+        attribute: toolArgs.attribute || 'innerText',
+        excerpt: lineExcerpt(toolResult?.result || toolResult?.content || toolResult, 18, Math.floor(softLimit * 0.7))
+      });
+      break;
+
+    case 'http_request':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.status,
+        headers: trimObject({
+          contentType: toolResult?.headers?.['content-type'] || toolResult?.headers?.['Content-Type'],
+          contentLength: toolResult?.headers?.['content-length'] || toolResult?.headers?.['Content-Length']
+        }),
+        excerpt: lineExcerpt(toolResult?.body || toolResult, 18, Math.floor(softLimit * 0.65))
+      });
+      break;
+
+    case 'send_message':
+    case 'make_call':
+    case 'memory_save':
+    case 'memory_recall':
+    case 'memory_update_core':
+    case 'memory_read':
+    case 'memory_write':
+    case 'create_scheduled_task':
+    case 'schedule_run':
+    case 'list_scheduled_tasks':
+    case 'delete_scheduled_task':
+    case 'update_scheduled_task':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.success === false || toolResult?.error ? 'error' : 'ok',
+        message: clampText(toolResult?.message || toolResult?.error || '', Math.floor(softLimit * 0.45)),
+        result: clampText(JSON.stringify(trimObject({
+          id: toolResult?.id,
+          key: toolResult?.key,
+          deleted: toolResult?.deleted,
+          sent: toolResult?.sent,
+          count: Array.isArray(toolResult?.results) ? toolResult.results.length : undefined
+        })), Math.floor(softLimit * 0.35))
+      });
+      break;
+
+    case 'spawn_subagent':
+      envelope = trimObject({
+        tool: toolName,
+        iterations: toolResult?.iterations,
+        tokens: toolResult?.tokens,
+        runId: toolResult?.runId,
+        summary: clampText(toolResult?.subagent_result || toolResult?.error || '', Math.floor(softLimit * 0.55))
+      });
+      break;
+
+    default:
+      envelope = trimObject({
+        tool: toolName,
+        summary: toJsonText(toolResult, Math.floor(softLimit * 0.75))
+      });
+      break;
+  }
+
+  return clampEnvelope(envelope, hardLimit);
+}
+
+module.exports = {
+  compactToolResult,
+  clampText,
+  lineExcerpt
+};

package/server/services/ai/toolRunner.js

@@ -87,7 +87,7 @@ class SkillRunner {
   }
 
   getSkillsForPrompt() {
-    const skills = Array.from(this.skills.values());
+    const skills = Array.from(this.skills.values()).filter((skill) => skill.metadata.enabled !== false);
     if (skills.length === 0) return '';
 
     let prompt = '\n## Available Skills\n';
@@ -103,7 +103,7 @@ class SkillRunner {
   getToolDefinitions() {
     const tools = [];
     for (const skill of this.skills.values()) {
-      if (skill.metadata.tool) {
+      if (skill.metadata.enabled !== false && skill.metadata.tool) {
         tools.push({
           name: skill.name,
           description: skill.description,
@@ -117,6 +117,9 @@ class SkillRunner {
   async executeTool(toolName, args) {
     const skill = this.skills.get(toolName);
     if (!skill) return null;
+    if (skill.metadata.enabled === false) {
+      return { error: `Skill '${toolName}' is disabled` };
+    }
 
     if (skill.metadata.command) {
       const { CLIExecutor } = require('../cli/executor');
@@ -140,8 +143,10 @@ class SkillRunner {
     const filePath = path.join(skillDir, 'SKILL.md');
     fs.writeFileSync(filePath, frontmatter + `\n\n${instructions}`);
 
-    db.prepare('INSERT OR REPLACE INTO skills (name, description, file_path, metadata, auto_created, updated_at) VALUES (?, ?, ?, ?, 1, datetime(\'now\'))')
-      .run(safeName, description, filePath, JSON.stringify(metadata));
+    db.prepare(`
+      INSERT OR REPLACE INTO skills (name, description, file_path, metadata, enabled, auto_created, updated_at)
+      VALUES (?, ?, ?, ?, ?, 1, datetime('now'))
+    `).run(safeName, description, filePath, JSON.stringify(metadata), metadata.enabled === false ? 0 : 1);
 
     this.loadSkillFile(filePath);
 
@@ -167,12 +172,24 @@ class SkillRunner {
 
     const frontmatter = this._buildFrontmatter(name, newDesc, metaToWrite);
     fs.writeFileSync(skill.filePath, frontmatter + `\n\n${newInstructions}`);
-    db.prepare('UPDATE skills SET description = ?, updated_at = datetime(\'now\') WHERE name = ?').run(newDesc, name);
+    db.prepare('UPDATE skills SET description = ?, metadata = ?, enabled = ?, updated_at = datetime(\'now\') WHERE name = ?')
+      .run(newDesc, JSON.stringify(metaToWrite || {}), metaToWrite?.enabled === false ? 0 : 1, name);
     this.loadSkillFile(skill.filePath);
 
     return { success: true, name, path: skill.filePath };
   }
 
+  getSkill(name) {
+    return this.skills.get(name) || null;
+  }
+
+  setSkillEnabled(name, enabled) {
+    const skill = this.skills.get(name);
+    if (!skill) return { error: `Skill '${name}' not found` };
+    const metadata = { ...skill.metadata, enabled: !!enabled };
+    return this.updateSkill(name, { metadata });
+  }
+
   deleteSkill(name) {
     const skill = this.skills.get(name);
     if (!skill) return { error: `Skill '${name}' not found` };
@@ -211,7 +228,8 @@ class SkillRunner {
       name: s.name,
       description: s.description,
       metadata: s.metadata,
-      filePath: s.filePath
+      filePath: s.filePath,
+      enabled: s.metadata.enabled !== false
     }));
   }
 }

package/server/services/ai/toolSelector.js

@@ -0,0 +1,140 @@
+const ALWAYS_ON_TOOLS = ['notify_user'];
+
+const PACKS = {
+  code: ['execute_command', 'read_file', 'list_directory', 'search_files'],
+  web: ['web_search', 'http_request', 'browser_navigate', 'browser_extract', 'browser_click', 'browser_type', 'browser_screenshot'],
+  messaging: ['send_message', 'make_call'],
+  memory: ['memory_recall', 'session_search', 'memory_save', 'memory_update_core', 'memory_read', 'memory_write'],
+  scheduling: ['create_scheduled_task', 'schedule_run', 'list_scheduled_tasks', 'update_scheduled_task', 'delete_scheduled_task'],
+  protocols: ['manage_protocols'],
+  skills: ['create_skill', 'list_skills', 'update_skill', 'delete_skill'],
+  images: ['generate_image', 'analyze_image'],
+  tables: ['generate_table', 'generate_graph'],
+  subagents: ['spawn_subagent'],
+  mcpAdmin: ['mcp_add_server', 'mcp_list_servers', 'mcp_remove_server']
+};
+
+function containsAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function detectRequestedPacks(task = '', options = {}) {
+  const text = String(task || '').toLowerCase();
+  const packs = new Set();
+
+  if (containsAny(text, [
+    /\b(run|execute|command|shell|terminal|bash|zsh|npm|node|python|script|repo|code|bug|fix|patch|test|build|file|folder|directory|grep|search files?)\b/,
+    /\b(read|open|inspect)\s+(the\s+)?(file|repo|code)\b/
+  ])) {
+    packs.add('code');
+  }
+
+  if (containsAny(text, [
+    /\b(web|website|url|page|browser|click|navigate|scrape|search|google|lookup|http|fetch|api request|screenshot)\b/,
+    /\bopen\b.*\bsite\b/
+  ])) {
+    packs.add('web');
+  }
+
+  if (containsAny(text, [
+    /\b(message|reply|respond|text|whatsapp|telegram|discord|dm|email|call|phone|notify|send to)\b/,
+    /\[no response\]/,
+    /\bsend_message\b/,
+    /\bmake_call\b/
+  ])) {
+    packs.add('messaging');
+  }
+
+  if (containsAny(text, [
+    /\bmemory\b/,
+    /\bremember\b/,
+    /\brecall\b/,
+    /\bprevious chat\b/,
+    /\blast time\b/,
+    /\bpast conversation\b/,
+    /\bpreference\b/,
+    /\bprofile\b/,
+    /\bsoul\b/
+  ])) {
+    packs.add('memory');
+  }
+
+  if (containsAny(text, [
+    /\bschedule\b/,
+    /\bcron\b/,
+    /\bremind\b/,
+    /\brecurring\b/,
+    /\bweekly\b/,
+    /\bdaily\b/,
+    /\bone-time\b/,
+    /\btask\b.*\blater\b/
+  ])) {
+    packs.add('scheduling');
+  }
+
+  if (containsAny(text, [/\bprotocol\b/, /\bplaybook\b/])) {
+    packs.add('protocols');
+  }
+
+  if (containsAny(text, [/\bskill\b/, /\binstall skill\b/, /\bcreate skill\b/])) {
+    packs.add('skills');
+  }
+
+  if (containsAny(text, [/\bimage\b/, /\bpicture\b/, /\bphoto\b/, /\bgraph\b/, /\bchart\b/, /\btable\b/, /\bqr\b/, /\bocr\b/])) {
+    packs.add('images');
+  }
+
+  if (containsAny(text, [/\btable\b/, /\bspreadsheet\b/, /\bgraph\b/, /\bchart\b/])) {
+    packs.add('tables');
+  }
+
+  if (containsAny(text, [/\bsub-?agent\b/, /\bdelegate\b/, /\bparallel\b/, /\bbackground worker\b/])) {
+    packs.add('subagents');
+  }
+
+  if (containsAny(text, [/\bmcp\b/, /\bmodel context protocol\b/, /\bserver tool\b/])) {
+    packs.add('mcpAdmin');
+  }
+
+  if (options.mediaAttachments?.length) {
+    packs.add('images');
+  }
+
+  return packs;
+}
+
+function maybeSelectMcpTools(text, mcpTools = []) {
+  const normalized = String(text || '').toLowerCase();
+  if (!normalized || !mcpTools.length) return [];
+
+  const explicitMcp = /\bmcp\b|\bmodel context protocol\b/.test(normalized);
+  return mcpTools.filter((tool) => {
+    const name = String(tool.name || '').toLowerCase();
+    const original = String(tool.originalName || '').toLowerCase();
+    const server = String(tool.serverId || '').toLowerCase();
+    return explicitMcp || normalized.includes(name) || normalized.includes(original) || (server && normalized.includes(server));
+  });
+}
+
+function selectToolsForTask(task, builtInTools = [], mcpTools = [], options = {}) {
+  const packs = detectRequestedPacks(task, options);
+  const allowNames = new Set(ALWAYS_ON_TOOLS);
+
+  for (const pack of packs) {
+    for (const toolName of PACKS[pack] || []) {
+      allowNames.add(toolName);
+    }
+  }
+
+  const selectedBuiltIns = builtInTools.filter((tool) => allowNames.has(tool.name));
+  const selectedMcp = maybeSelectMcpTools(task, mcpTools);
+
+  return [...selectedBuiltIns, ...selectedMcp];
+}
+
+module.exports = {
+  ALWAYS_ON_TOOLS,
+  PACKS,
+  detectRequestedPacks,
+  selectToolsForTask
+};

package/server/services/ai/tools.js

@@ -3,12 +3,54 @@ const path = require('path');
 const db = require('../../db/database');
 const { DATA_DIR } = require('../../../runtime/paths');
 
+function compactText(text, maxChars = 120) {
+  const str = String(text || '').replace(/\s+/g, ' ').trim();
+  if (str.length <= maxChars) return str;
+  const trimmed = str.slice(0, maxChars);
+  const sentenceBreak = Math.max(trimmed.lastIndexOf('. '), trimmed.lastIndexOf('; '), trimmed.lastIndexOf(', '));
+  if (sentenceBreak > 40) return trimmed.slice(0, sentenceBreak + 1).trim();
+  return `${trimmed.trim()}...`;
+}
+
+function compactToolDefinition(tool, options = {}) {
+  const compact = {
+    name: tool.name,
+    parameters: {
+      ...(tool.parameters || { type: 'object', properties: {} }),
+      properties: {}
+    }
+  };
+
+  if (options.includeDescriptions) {
+    compact.description = compactText(tool.description, 120);
+  }
+
+  if (tool.parameters?.properties) {
+    const properties = {};
+    for (const [key, value] of Object.entries(tool.parameters.properties)) {
+      properties[key] = { ...value };
+      if (options.includeDescriptions && value.description) {
+        properties[key].description = compactText(value.description, 70);
+      } else {
+        delete properties[key].description;
+      }
+    }
+    compact.parameters = {
+      ...compact.parameters,
+      properties
+    };
+  }
+
+  return compact;
+}
+
 /**
  * Returns the list of available tools for the agent.
  * @param {object} app - Express app instance.
+ * @param {object} options - Tool filtering options.
  * @returns {Array} List of tool definitions.
  */
-function getAvailableTools(app) {
+function getAvailableTools(app, options = {}) {
     const tools = [
         {
             name: 'execute_command',
@@ -154,6 +196,18 @@ function getAvailableTools(app) {
                 required: ['query']
             }
         },
+        {
+            name: 'session_search',
+            description: 'Search past runs and message threads for commands, decisions, file paths, or context from earlier conversations.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'What to search for in prior sessions.' },
+                    limit: { type: 'number', description: 'How many matching sessions to return (default 6).' }
+                },
+                required: ['query']
+            }
+        },
         {
             name: 'memory_update_core',
             description: 'Update core memory — always-injected facts that appear in every prompt. Use for critical always-relevant info: user\'s name, their main job, key standing preferences, how they want you to behave. Keep each entry concise.',
@@ -530,7 +584,12 @@ function getAvailableTools(app) {
         }
     ];
 
-    return tools;
+    const compacted = tools.map((tool) => compactToolDefinition(tool, options));
+    if (options.names && Array.isArray(options.names)) {
+        const allow = new Set(options.names);
+        return compacted.filter((tool) => allow.has(tool.name));
+    }
+    return compacted;
 }
 
 /**
@@ -725,6 +784,16 @@ async function executeTool(toolName, args, context, engine) {
             return { results };
         }
 
+        case 'session_search': {
+            const { MemoryManager } = require('../memory/manager');
+            const mm = new MemoryManager();
+            const results = mm.searchConversations(userId, args.query, {
+                sessions: args.limit || 6
+            });
+            if (!results.length) return { results: [], message: 'No matching sessions found' };
+            return { results };
+        }
+
         case 'memory_update_core': {
             const { MemoryManager } = require('../memory/manager');
             const mm = new MemoryManager();

package/server/services/manager.js

@@ -5,7 +5,9 @@ const { MemoryManager } = require('./memory/manager');
 const { MCPClient } = require('./mcp/client');
 const { BrowserController } = require('./browser/controller');
 const { AgentEngine } = require('./ai/engine');
+const { LearningManager } = require('./ai/learning');
 const { MultiStepOrchestrator } = require('./ai/multiStep');
+const { SkillRunner } = require('./ai/toolRunner');
 const { MessagingManager } = require('./messaging/manager');
 const { Scheduler } = require('./scheduler/cron');
 const { setupWebSocket } = require('./websocket');
@@ -29,7 +31,21 @@ async function startServices(app, io) {
         }
         app.locals.browserController = browserController;
 
-        const agentEngine = new AgentEngine(io, { memoryManager, mcpClient, browserController, messagingManager: null });
+        const skillRunner = new SkillRunner();
+        await skillRunner.loadSkills();
+        app.locals.skillRunner = skillRunner;
+
+        const learningManager = new LearningManager(skillRunner, io);
+        app.locals.learningManager = learningManager;
+
+        const agentEngine = new AgentEngine(io, {
+            memoryManager,
+            mcpClient,
+            browserController,
+            messagingManager: null,
+            skillRunner,
+            learningManager
+        });
         app.locals.agentEngine = agentEngine;
 
         const multiStep = new MultiStepOrchestrator(agentEngine, io);
@@ -167,7 +183,14 @@ async function startServices(app, io) {
         agentEngine.scheduler = scheduler;
         scheduler.start();
 
-        setupWebSocket(io, { agentEngine, messagingManager, mcpClient, scheduler, memoryManager, app });
+        setupWebSocket(io, {
+            agentEngine,
+            messagingManager,
+            mcpClient,
+            scheduler,
+            memoryManager,
+            app
+        });
         app.locals.io = io;
 
         console.log('All services initialized');

package/server/services/memory/embeddings.js

@@ -2,30 +2,80 @@
 
 /**
  * Embedding helpers for the semantic memory system.
- * Uses OpenAI text-embedding-3-small (1536 dims) when available.
- * Gracefully degrades to keyword search if OPENAI_API_KEY is missing.
+ *
+ * Provider selection (in priority order):
+ *   1. Google (text-embedding-004, 768 dims) — when provider hint is 'google' and GOOGLE_AI_KEY is set
+ *   2. OpenAI (text-embedding-3-small, 1536 dims) — when OPENAI_API_KEY is set
+ *   3. Keyword fallback — when no API key is available
  */
 
 const https = require('https');
 
-const EMBEDDING_MODEL = 'text-embedding-3-small';
-const EMBED_DIM = 1536;
+const OPENAI_MODEL = 'text-embedding-3-small';
+const OPENAI_DIM = 1536;
+const GOOGLE_MODEL = 'text-embedding-004';
+const GOOGLE_DIM = 768;
 
-/**
- * Get an embedding vector for a piece of text.
- * Returns a Float32Array of length EMBED_DIM, or null if unavailable.
- */
-async function getEmbedding(text) {
+// Exported so callers can sanity-check stored vector dimensions if needed
+const EMBED_DIM = OPENAI_DIM;
+const EMBED_DIM_GOOGLE = GOOGLE_DIM;
+
+async function getGeminiEmbedding(text) {
+  const apiKey = process.env.GOOGLE_AI_KEY;
+  if (!apiKey) return null;
+  if (!text || !text.trim()) return null;
+
+  const truncated = text.slice(0, 25000);
+
+  return new Promise((resolve) => {
+    const body = JSON.stringify({
+      model: `models/${GOOGLE_MODEL}`,
+      content: { parts: [{ text: truncated }] }
+    });
+
+    const path = `/v1beta/models/${GOOGLE_MODEL}:embedContent?key=${apiKey}`;
+    const options = {
+      hostname: 'generativelanguage.googleapis.com',
+      path,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body)
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          const vec = parsed.embedding?.values;
+          if (!vec) return resolve(null);
+          resolve(new Float32Array(vec));
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.setTimeout(15000, () => { req.destroy(); resolve(null); });
+    req.write(body);
+    req.end();
+  });
+}
+
+async function getOpenAIEmbedding(text) {
   const apiKey = process.env.OPENAI_API_KEY;
   if (!apiKey) return null;
   if (!text || !text.trim()) return null;
 
-  // Truncate very long text to stay within token limits (~8k tokens)
   const truncated = text.slice(0, 25000);
 
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => {
     const body = JSON.stringify({
-      model: EMBEDDING_MODEL,
+      model: OPENAI_MODEL,
       input: truncated,
       encoding_format: 'float'
     });
@@ -64,6 +114,21 @@ async function getEmbedding(text) {
   });
 }
 
+/**
+ * Get an embedding vector for a piece of text.
+ * @param {string} text
+ * @param {string} [provider] - 'google' to prefer Gemini embeddings
+ * @returns {Float32Array|null}
+ */
+async function getEmbedding(text, provider) {
+  if (!text || !text.trim()) return null;
+  if (provider === 'google' && process.env.GOOGLE_AI_KEY) {
+    const vec = await getGeminiEmbedding(text);
+    if (vec) return vec;
+  }
+  return getOpenAIEmbedding(text);
+}
+
 /**
  * Cosine similarity between two Float32Arrays.
  * Returns a value in [-1, 1]; higher = more similar.
@@ -72,7 +137,7 @@ function cosineSimilarity(a, b) {
   if (!a || !b || a.length !== b.length) return 0;
   let dot = 0, magA = 0, magB = 0;
   for (let i = 0; i < a.length; i++) {
-    dot  += a[i] * b[i];
+    dot += a[i] * b[i];
     magA += a[i] * a[i];
     magB += b[i] * b[i];
   }
@@ -122,5 +187,6 @@ module.exports = {
   serializeEmbedding,
   deserializeEmbedding,
   keywordSimilarity,
-  EMBED_DIM
+  EMBED_DIM,
+  EMBED_DIM_GOOGLE
 };