neoagent 2.3.0 → 2.3.1-beta.10

package/server/services/ai/tools.js

@@ -91,6 +91,103 @@ function compactToolDefinition(tool, options = {}) {
     return compact;
 }
 
+function normalizeScheduleTriggerConfig(inputConfig = {}) {
+    if (!inputConfig || typeof inputConfig !== 'object' || Array.isArray(inputConfig)) {
+        return inputConfig;
+    }
+
+    const normalized = { ...inputConfig };
+    const schedule = (normalized.schedule && typeof normalized.schedule === 'object' && !Array.isArray(normalized.schedule))
+        ? normalized.schedule
+        : null;
+
+    const modeCandidate = String(
+        normalized.mode
+        || normalized.type
+        || normalized.scheduleType
+        || normalized.schedule_type
+        || (normalized.oneTime || normalized.one_time ? 'one_time' : '')
+        || ''
+    ).trim().toLowerCase();
+    if (modeCandidate === 'once') normalized.mode = 'one_time';
+    else if (modeCandidate === 'one_time' || modeCandidate === 'recurring') normalized.mode = modeCandidate;
+
+    const cronCandidate = normalized.cronExpression
+        || normalized.cron_expression
+        || normalized.cron
+        || schedule?.cronExpression
+        || schedule?.cron_expression
+        || schedule?.cron;
+    if (cronCandidate != null) {
+        normalized.cronExpression = String(cronCandidate).trim();
+    }
+
+    const runAtCandidate = normalized.runAt
+        || normalized.run_at
+        || normalized.at
+        || normalized.when
+        || schedule?.runAt
+        || schedule?.run_at
+        || schedule?.at
+        || schedule?.when;
+    if (runAtCandidate != null) {
+        normalized.runAt = String(runAtCandidate).trim();
+    }
+
+    if (!normalized.mode) {
+        normalized.mode = normalized.runAt ? 'one_time' : 'recurring';
+    }
+
+    delete normalized.schedule;
+    return normalized;
+}
+
+function normalizeTaskTriggerInput(triggerType, triggerConfig) {
+    if (String(triggerType || '').trim() !== 'schedule') {
+        return triggerConfig;
+    }
+    return normalizeScheduleTriggerConfig(triggerConfig || {});
+}
+
+function resolveTaskTriggerArgs(args = {}, fallbackTriggerType = null) {
+    let triggerType = args.trigger_type !== undefined
+        ? String(args.trigger_type || '').trim()
+        : String(fallbackTriggerType || '').trim();
+    let triggerConfig = args.trigger_config;
+    let hasType = args.trigger_type !== undefined;
+    let hasConfig = args.trigger_config !== undefined;
+
+    if (args.trigger && typeof args.trigger === 'object' && !Array.isArray(args.trigger)) {
+        const trigger = args.trigger;
+        const unifiedType = trigger.type ?? trigger.triggerType ?? trigger.trigger_type;
+        const unifiedHasType = unifiedType !== undefined && unifiedType !== null && String(unifiedType).trim().length > 0;
+        if (unifiedHasType) {
+            triggerType = String(unifiedType).trim();
+            hasType = true;
+        }
+
+        const hasUnifiedConfig = Object.prototype.hasOwnProperty.call(trigger, 'config')
+            || Object.prototype.hasOwnProperty.call(trigger, 'triggerConfig')
+            || Object.prototype.hasOwnProperty.call(trigger, 'trigger_config');
+        if (hasUnifiedConfig) {
+            triggerConfig = trigger.config ?? trigger.triggerConfig ?? trigger.trigger_config;
+            hasConfig = true;
+        }
+    }
+
+    const normalizedType = String(triggerType || '').trim() || null;
+    const normalizedConfig = hasConfig
+        ? normalizeTaskTriggerInput(normalizedType || fallbackTriggerType || 'schedule', triggerConfig)
+        : undefined;
+
+    return {
+        triggerType: normalizedType,
+        triggerConfig: normalizedConfig,
+        hasType,
+        hasConfig,
+    };
+}
+
 function isProactiveTrigger(triggerSource) {
     return triggerSource === 'schedule' || triggerSource === 'tasks';
 }
@@ -876,15 +973,16 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     name: { type: 'string', description: 'Short descriptive name for the task.' },
-                    trigger_type: { type: 'string', description: 'Trigger type such as schedule, gmail_message_received, outlook_email_received, slack_message_received, teams_message_received, or whatsapp_personal_message_received.' },
-                    trigger_config: { type: 'object', description: 'Trigger-specific configuration object.' },
+                    trigger: { type: 'object', description: 'Unified trigger object. Prefer { type: "manual" | "schedule" | integration_trigger_type, config: {...} }.' },
+                    trigger_type: { type: 'string', description: 'Trigger type such as manual, schedule, gmail_message_received, outlook_email_received, slack_message_received, teams_message_received, weather_event, or whatsapp_personal_message_received.' },
+                    trigger_config: { type: 'object', description: 'Trigger-specific configuration object. For schedule triggers prefer { mode: "recurring", cronExpression: "m h dom mon dow" } or { mode: "one_time", runAt: ISO datetime }. 5-field cron only (seconds unsupported).' },
                     prompt: { type: 'string', description: 'The instructions the agent will run when the trigger fires.' },
                     enabled: { type: 'boolean', description: 'Whether to activate immediately.' },
                     model: { type: 'string', description: 'Optional model override.' },
                     call_to: { type: 'string', description: 'Optional E.164 phone number to call via Telnyx when this task fires.' },
                     call_greeting: { type: 'string', description: 'Optional spoken greeting hint for make_call.' }
                 },
-                required: ['name', 'trigger_type', 'trigger_config', 'prompt']
+                required: ['name', 'prompt']
             }
         },
         {
@@ -911,8 +1009,9 @@ function getAvailableTools(app, options = {}) {
                 properties: {
                     task_id: { type: 'number', description: 'The numeric ID of the task to update.' },
                     name: { type: 'string', description: 'New name for the task.' },
-                    trigger_type: { type: 'string', description: 'Updated trigger type.' },
-                    trigger_config: { type: 'object', description: 'Updated trigger-specific configuration.' },
+                    trigger: { type: 'object', description: 'Unified trigger object. Use { type, config } to update trigger in one section.' },
+                    trigger_type: { type: 'string', description: 'Updated trigger type, e.g. manual, schedule, or integration trigger type.' },
+                    trigger_config: { type: 'object', description: 'Updated trigger-specific configuration. For schedule triggers use mode+cronExpression (recurring) or mode+runAt (one_time).' },
                     prompt: { type: 'string', description: 'Updated task prompt.' },
                     enabled: { type: 'boolean', description: 'Enable or disable the task.' },
                     model: { type: 'string', description: 'Specific AI model ID for this task. Set to empty string to clear the override.' },
@@ -1053,6 +1152,17 @@ function getAvailableTools(app, options = {}) {
                 required: ['image_path']
             }
         },
+        {
+            name: 'ocr_extract',
+            description: 'Extract raw text from an image locally using Tesseract OCR. This is faster and completely offline compared to analyze_image.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    image_path: { type: 'string', description: 'Absolute path to the image file' }
+                },
+                required: ['image_path']
+            }
+        },
         {
             name: 'read_health_data',
             description: 'Read the user\'s synced mobile health data. Omit metric_type for a summary of all available metrics. With metric_type, returns an aggregate summary (total, avg, min, max over all stored data) plus the most recent individual records. Always report the summary figures — avoid listing every raw record.',
@@ -1123,7 +1233,8 @@ function getAvailableTools(app, options = {}) {
                     properties: {
                         content: { type: 'string', description: 'Natural assistant message derived from the current task state.' },
                         kind: { type: 'string', enum: Array.from(INTERIM_KINDS), description: 'ack, progress, question, or blocker' },
-                        expects_reply: { type: 'boolean', description: 'Set true only when the current run should pause for the user to answer.' }
+                        expects_reply: { type: 'boolean', description: 'Set true only when the current run should pause for the user to answer.' },
+                        defer_follow_up: { type: 'boolean', description: 'Set true when you choose to deliver the final result later via the user\'s last connected chat target.' }
                     },
                     required: ['content', 'kind']
                 }
@@ -1847,6 +1958,7 @@ async function executeTool(toolName, args, context, engine) {
             }
             const interimContent = typeof args.content === 'string' ? args.content : '';
             const expectsReply = args.expects_reply === true;
+            const deferFollowUp = args.defer_follow_up === true;
             return engine.publishInterimUpdate({
                 userId,
                 runId,
@@ -1858,6 +1970,7 @@ async function executeTool(toolName, args, context, engine) {
                 content: interimContent,
                 kind: normalizeInterimKind(args.kind),
                 expectsReply,
+                deferFollowUp,
             });
         }
 
@@ -2205,10 +2318,21 @@ async function executeTool(toolName, args, context, engine) {
             const s = taskRuntime();
             if (!s) return { error: 'Task runtime not available' };
             try {
+                const resolvedTrigger = resolveTaskTriggerArgs(args, 'schedule');
+                if (!resolvedTrigger.hasType || !resolvedTrigger.triggerType) {
+                    return { error: 'Task trigger type is required (use trigger.type or trigger_type).' };
+                }
+                const normalizedTriggerType = String(resolvedTrigger.triggerType || '').trim();
+                const triggerConfig = (!resolvedTrigger.hasConfig || resolvedTrigger.triggerConfig === undefined)
+                    ? (normalizedTriggerType === 'manual' ? {} : undefined)
+                    : resolvedTrigger.triggerConfig;
+                if (triggerConfig === undefined) {
+                    return { error: 'Task trigger config is required (use trigger.config or trigger_config).' };
+                }
                 const task = await s.createTask(userId, {
                     name: args.name,
-                    triggerType: args.trigger_type,
-                    triggerConfig: args.trigger_config,
+                    triggerType: normalizedTriggerType,
+                    triggerConfig,
                     prompt: args.prompt,
                     enabled: args.enabled !== false,
                     model: args.model || null,
@@ -2246,12 +2370,13 @@ async function executeTool(toolName, args, context, engine) {
             const s = taskRuntime();
             if (!s) return { error: 'Task runtime not available' };
             try {
-                const existing = db.prepare('SELECT agent_id FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(args.task_id, userId);
+                const existing = db.prepare('SELECT agent_id, trigger_type FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(args.task_id, userId);
                 if (!existing || existing.agent_id !== agentId) return { error: 'Task not found for this agent.' };
                 const updates = {};
+                const resolvedTrigger = resolveTaskTriggerArgs(args, existing.trigger_type || 'schedule');
                 if (args.name !== undefined) updates.name = args.name;
-                if (args.trigger_type !== undefined) updates.triggerType = args.trigger_type;
-                if (args.trigger_config !== undefined) updates.triggerConfig = args.trigger_config;
+                if (resolvedTrigger.hasType && resolvedTrigger.triggerType) updates.triggerType = resolvedTrigger.triggerType;
+                if (resolvedTrigger.hasConfig && resolvedTrigger.triggerConfig !== undefined) updates.triggerConfig = resolvedTrigger.triggerConfig;
                 if (args.prompt !== undefined) updates.prompt = args.prompt;
                 if (args.enabled !== undefined) updates.enabled = args.enabled;
                 if (args.model !== undefined) updates.model = args.model || null;
@@ -2470,6 +2595,20 @@ async function executeTool(toolName, args, context, engine) {
             }
         }
 
+        case 'ocr_extract': {
+            try {
+                const fs = require('fs');
+                if (!fs.existsSync(args.image_path)) {
+                    return { error: 'File not found: ' + args.image_path };
+                }
+                const Tesseract = require('tesseract.js');
+                const result = await Tesseract.recognize(args.image_path, 'eng');
+                return { text: result.data.text, confidence: result.data.confidence };
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
         case 'spawn_subagent': {
             try {
                 const task = args.context ? `${args.task}\n\nContext: ${args.context}` : args.task;

package/server/services/browser/controller.js

@@ -6,11 +6,11 @@ const SCREENSHOTS_DIR = path.join(DATA_DIR, 'screenshots');
 if (!fs.existsSync(SCREENSHOTS_DIR)) fs.mkdirSync(SCREENSHOTS_DIR, { recursive: true });
 
 const USER_AGENTS = [
-  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
   'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
   'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
-  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
 ];
 
 const VIEWPORTS = [
@@ -148,6 +148,50 @@ class BrowserController {
             return arr;
           }
         });
+
+        // WebGL Spoofing
+        const getParameterProxyHandler = {
+          apply: function(target, ctx, args) {
+            const param = args[0];
+            // UNMASKED_VENDOR_WEBGL
+            if (param === 37445) return 'Google Inc. (Apple)';
+            // UNMASKED_RENDERER_WEBGL
+            if (param === 37446) return 'ANGLE (Apple, Apple M2, OpenGL 4.1)';
+            return Reflect.apply(target, ctx, args);
+          }
+        };
+        const getParam = WebGLRenderingContext.prototype.getParameter;
+        WebGLRenderingContext.prototype.getParameter = new Proxy(getParam, getParameterProxyHandler);
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+          const getParam2 = WebGL2RenderingContext.prototype.getParameter;
+          WebGL2RenderingContext.prototype.getParameter = new Proxy(getParam2, getParameterProxyHandler);
+        }
+
+        // Canvas Spoofing (slight noise)
+        const originalFillText = CanvasRenderingContext2D.prototype.fillText;
+        CanvasRenderingContext2D.prototype.fillText = function(...args) {
+            if (!this._spoofing_applied) {
+                this._spoofing_applied = true;
+                const r = Math.random() * 0.0001;
+                const g = Math.random() * 0.0001;
+                const b = Math.random() * 0.0001;
+                this.fillStyle = \`rgba(\${Math.floor(r * 255)}, \${Math.floor(g * 255)}, \${Math.floor(b * 255)}, 0.01)\`;
+                originalFillText.call(this, "spoof", 0, 0);
+            }
+            return originalFillText.apply(this, args);
+        };
+
+        // Media Devices Spoofing
+        if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+            const originalEnumerateDevices = navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);
+            navigator.mediaDevices.enumerateDevices = async () => {
+                return [
+                    { kind: 'audioinput', deviceId: 'default', groupId: 'a', label: 'MacBook Pro Microphone' },
+                    { kind: 'audiooutput', deviceId: 'default', groupId: 'b', label: 'MacBook Pro Speakers' },
+                    { kind: 'videoinput', deviceId: 'default', groupId: 'c', label: 'FaceTime HD Camera' }
+                ];
+            };
+        }
       })();
     `);
   }

package/server/services/desktop/screenRecorder.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const fs = require('fs/promises');
+const path = require('path');
+const os = require('os');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const tesseract = require('tesseract.js');
+const db = require('../../db/database');
+const { getErrorMessage } = require('../bootstrap_helpers');
+
+const execAsync = promisify(exec);
+
+class ScreenRecorder {
+  constructor() {
+    this.intervalMs = 10000; // 10 seconds
+    this.intervalId = null;
+    this.cleanupIntervalId = null;
+    this.isRecording = false;
+    this.isProcessing = false;
+    this.tempFilePath = path.join(os.tmpdir(), `neoagent-screen-${Date.now()}.png`);
+  }
+
+  start() {
+    if (process.platform !== 'darwin') {
+      console.log('[ScreenRecorder] Not starting: Screen recording is currently macOS only.');
+      return;
+    }
+
+    if (this.isRecording) return;
+    this.isRecording = true;
+
+    console.log('[ScreenRecorder] Starting continuous screen recording (10s interval)');
+    
+    // Start the recording loop
+    this.intervalId = setInterval(() => this.captureAndProcess(), this.intervalMs);
+    
+    // Run an initial capture
+    this.captureAndProcess();
+
+    // Start daily cleanup of old records (7 days)
+    this.cleanupIntervalId = setInterval(() => this.cleanupOldRecords(), 24 * 60 * 60 * 1000);
+    this.cleanupOldRecords();
+  }
+
+  stop() {
+    this.isRecording = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (this.cleanupIntervalId) {
+      clearInterval(this.cleanupIntervalId);
+      this.cleanupIntervalId = null;
+    }
+    console.log('[ScreenRecorder] Stopped continuous screen recording');
+  }
+
+  async captureAndProcess() {
+    if (this.isProcessing || !this.isRecording) return;
+    this.isProcessing = true;
+
+    try {
+      // Capture screen silently (-x) to file
+      await execAsync(`screencapture -x "${this.tempFilePath}"`);
+
+      // Verify file exists
+      await fs.access(this.tempFilePath);
+
+      // Extract text via local OCR
+      const { data } = await tesseract.recognize(this.tempFilePath, 'eng+deu', {
+        logger: () => {} // Silence verbose OCR logs
+      });
+
+      const textContent = data.text.trim();
+
+      // Only store if meaningful text was found
+      if (textContent.length > 5) {
+        // We need a user ID. For the local desktop agent, usually user 1 or we query the active user.
+        const userRow = db.prepare('SELECT id FROM users ORDER BY id ASC LIMIT 1').get();
+        if (userRow) {
+          // Identify the active foreground app via AppleScript
+          let appName = 'Unknown';
+          try {
+            const { stdout } = await execAsync(`osascript -e 'tell application "System Events" to get name of first application process whose frontmost is true'`);
+            appName = stdout.trim();
+          } catch (e) {
+            // Ignore AppleScript errors
+          }
+
+          db.prepare(`
+            INSERT INTO screen_history (user_id, app_name, text_content)
+            VALUES (?, ?, ?)
+          `).run(userRow.id, appName, textContent);
+        }
+      }
+
+    } catch (err) {
+      console.error('[ScreenRecorder] Capture/OCR failed:', getErrorMessage(err));
+    } finally {
+      // Always cleanup the screenshot image immediately
+      try {
+        await fs.unlink(this.tempFilePath);
+      } catch (e) {
+        // Ignore unlink errors if file didn't exist
+      }
+      this.isProcessing = false;
+    }
+  }
+
+  cleanupOldRecords() {
+    try {
+      const result = db.prepare(`
+        DELETE FROM screen_history 
+        WHERE timestamp < datetime('now', '-7 days')
+      `).run();
+      if (result.changes > 0) {
+        console.log(`[ScreenRecorder] Purged ${result.changes} old screen history records.`);
+      }
+    } catch (err) {
+      console.error('[ScreenRecorder] Cleanup failed:', getErrorMessage(err));
+    }
+  }
+}
+
+module.exports = { ScreenRecorder };

package/server/services/integrations/env.js

@@ -56,6 +56,22 @@ function resolveMicrosoftOAuthConfig() {
   };
 }
 
+function resolveHomeAssistantOAuthConfig() {
+  const base = resolveOAuthConfig('HOME_ASSISTANT');
+  return {
+    ...base,
+    baseUrl: trimEnv('HOME_ASSISTANT_BASE_URL').replace(/\/$/, ''),
+  };
+}
+
+function resolveSpotifyOAuthConfig() {
+  return resolveOAuthConfig('SPOTIFY');
+}
+
+function resolveGithubOAuthConfig() {
+  return resolveOAuthConfig('GITHUB');
+}
+
 function describeEnvStatus(config, options = {}) {
   const label = String(options.label || 'This integration').trim() || 'This integration';
   if (config.configured) {
@@ -76,10 +92,13 @@ function describeEnvStatus(config, options = {}) {
 module.exports = {
   describeEnvStatus,
   resolveFigmaOAuthConfig,
+  resolveHomeAssistantOAuthConfig,
   resolveMicrosoftOAuthConfig,
   resolveNotionOAuthConfig,
   resolveOAuthConfig,
   resolveGoogleOAuthConfig,
   resolvePublicBaseUrl,
+  resolveSpotifyOAuthConfig,
   resolveSlackOAuthConfig,
+  resolveGithubOAuthConfig,
 };

package/server/services/integrations/github/common.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const crypto = require('crypto');
+
+function base64UrlSha256(value) {
+  return crypto
+    .createHash('sha256')
+    .update(String(value || ''))
+    .digest('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}
+
+async function githubApiRequest(auth, options = {}) {
+  const {
+    method = 'GET',
+    path,
+    query = null,
+    body = null,
+    baseUrl = 'https://api.github.com',
+    token: overrideToken = '',
+  } = options;
+
+  const token = String(overrideToken || auth?.token || '').trim();
+  if (!token) {
+    throw new Error('GitHub authentication token is required for GitHub API requests.');
+  }
+
+  const url = new URL(path, baseUrl);
+  if (query && typeof query === 'object') {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== undefined && value !== null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+
+  const headers = {
+    'Accept': 'application/vnd.github.v3+json',
+    'Authorization': `Bearer ${token}`,
+    'X-GitHub-Api-Version': '2022-11-28',
+  };
+
+  if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+    headers['Content-Type'] = 'application/json';
+  }
+
+  const response = await fetch(url.toString(), {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  let data = null;
+  if (response.status !== 204 && response.status !== 205) {
+    const rawBody = await response.text();
+    if (rawBody.trim()) {
+      try {
+        data = JSON.parse(rawBody);
+      } catch {
+        if (!response.ok) {
+          const error = new Error(`GitHub API error ${response.status}: ${rawBody}`);
+          error.status = response.status;
+          error.data = rawBody;
+          throw error;
+        }
+        data = rawBody;
+      }
+    }
+  }
+
+  if (!response.ok) {
+    const errorMessage =
+      (data && typeof data === 'object' ? data.message : null) ||
+      `GitHub API error: ${response.status}`;
+    const error = new Error(errorMessage);
+    error.status = response.status;
+    error.data = data;
+    throw error;
+  }
+
+  return data;
+}
+
+function buildPaginationParams(options = {}) {
+  const params = {};
+  if (options.page) params.page = Number(options.page);
+  if (options.per_page) params.per_page = Math.min(Number(options.per_page) || 30, 100);
+  return params;
+}
+
+function parseOwnerRepo(ownerRepo) {
+  const parts = String(ownerRepo || '').split('/');
+  if (parts.length !== 2) {
+    throw new Error('owner_repo must be in format "owner/repo"');
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+
+module.exports = {
+  base64UrlSha256,
+  buildPaginationParams,
+  githubApiRequest,
+  parseOwnerRepo,
+};