neoagent 2.3.1-beta.0 → 2.3.1-beta.3

package/server/services/skills/base_catalog.js

@@ -1161,6 +1161,39 @@ Auto-orients and arranges the STL, applies settings from JSON files, slices all
 3. Build the command from the flags above
 4. Run it and check for errors in the output (debug level 2 is a good default)
 5. Report the output file location and any warnings`
+  },
+
+  {
+    id: 'package-tracker',
+    name: 'Package Tracker',
+    description: 'Track packages by automatically detecting the carrier and fetching the tracking link.',
+    category: 'info',
+    icon: '📦',
+    content: `---
+name: package-tracker
+description: Track packages by automatically detecting the carrier and fetching the tracking link.
+category: info
+icon: 📦
+enabled: true
+---
+
+You are a package tracking assistant. When the user gives you a tracking number, you should:
+
+1. Identify the carrier using common regex patterns:
+   - UPS: \`\\b(1Z[0-9A-Z]{16})\\b\`
+   - FedEx: \`\\b([0-9]{12,15})\\b\` (usually 12 or 15 digits)
+   - USPS: \`\\b(94[0-9]{20})\\b\` or \`\\b([A-Z]{2}[0-9]{9}US)\\b\`
+   - DHL: \`\\b([0-9]{10})\\b\` or \`\\b([0-9]{20})\\b\`
+
+2. Generate the direct tracking link for the user:
+   - UPS: \`https://www.ups.com/track?tracknum={number}\`
+   - FedEx: \`https://www.fedex.com/fedextrack/?trknbr={number}\`
+   - USPS: \`https://tools.usps.com/go/TrackConfirmAction?tLabels={number}\`
+   - DHL: \`https://www.dhl.com/global-en/home/tracking/tracking-express.html?submit=1&tracking-id={number}\`
+
+3. If the carrier is not obvious, use \`web_search\` with the query "track package {number}" to identify the carrier.
+4. Present the carrier and the direct tracking link to the user clearly.
+5. Optionally use \`browser_navigate\` or \`http_request\` to fetch the current status from the tracking link, but note that many carriers block automated scraping. The direct link is the most important output.`
   }
 ];
 

package/server/services/tasks/adapters/index.js

@@ -2,9 +2,11 @@
 
 module.exports = [
   require('./schedule'),
+  require('./manual'),
   require('./gmail_message_received'),
   require('./outlook_email_received'),
   require('./slack_message_received'),
   require('./teams_message_received'),
+  require('./weather_event'),
   require('./whatsapp_personal_message_received'),
 ];

package/server/services/tasks/adapters/manual.js

@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = {
+  type: 'manual',
+  label: 'Manual Trigger',
+  async validateConfig() {
+    return {};
+  },
+  summarize() {
+    return 'Manual run only';
+  },
+};

package/server/services/tasks/adapters/schedule.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const cron = require('node-cron');
-const { findNextRun } = require('../schedule_utils');
+const { findNextRun, parseCronExpression } = require('../schedule_utils');
 
 function normalizeRunAt(value) {
   if (!value) return null;
@@ -12,6 +12,37 @@ function normalizeRunAt(value) {
   return date.toISOString();
 }
 
+function normalizeCronExpression(value) {
+  const raw = String(value || '').trim();
+  if (!raw) {
+    throw new Error('A valid cron expression is required.');
+  }
+
+  const fields = raw.split(/\s+/);
+  if (fields.length === 6) {
+    const seconds = String(fields[0] || '').trim();
+    if (seconds !== '0' && seconds !== '*') {
+      throw new Error('Cron expressions with seconds are not supported. Use a 5-field expression.');
+    }
+    fields.shift();
+  }
+
+  if (fields.length !== 5) {
+    throw new Error('A valid cron expression is required.');
+  }
+
+  // Quartz-style "?" means "no specific value"; convert to standard wildcard.
+  if (fields[2] === '?') fields[2] = '*';
+  if (fields[4] === '?') fields[4] = '*';
+
+  const normalized = fields.join(' ');
+  parseCronExpression(normalized);
+  if (!cron.validate(normalized)) {
+    throw new Error('A valid cron expression is required.');
+  }
+  return normalized;
+}
+
 module.exports = {
   type: 'schedule',
   label: 'Schedule',
@@ -31,10 +62,7 @@ module.exports = {
       };
     }
 
-    const cronExpression = String(config.cronExpression || config.cron_expression || '').trim();
-    if (!cronExpression || !cron.validate(cronExpression)) {
-      throw new Error('A valid cron expression is required.');
-    }
+    const cronExpression = normalizeCronExpression(config.cronExpression || config.cron_expression);
     return {
       mode,
       cronExpression,

package/server/services/tasks/adapters/weather_event.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const {
+  ensureOwnedIntegrationConnection,
+  normalizeTrimmedText,
+} = require('../security');
+
+const WEATHER_EVENT_TYPES = new Set([
+  'rain_start',
+  'snow_start',
+  'wind_alert',
+  'temperature_above',
+  'temperature_below',
+]);
+
+function normalizeNumber(value, fallback) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function normalizeEventTypes(value) {
+  const raw = Array.isArray(value)
+    ? value
+    : String(value || '')
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+  const normalized = raw
+    .map((entry) => String(entry || '').trim().toLowerCase())
+    .filter((entry) => WEATHER_EVENT_TYPES.has(entry));
+  return Array.from(new Set(normalized));
+}
+
+module.exports = {
+  type: 'weather_event',
+  label: 'Weather Event',
+  providerKey: 'weather',
+  appKey: 'forecast',
+  async validateConfig(config = {}, context = {}) {
+    const connection = ensureOwnedIntegrationConnection(context.integrationManager, {
+      userId: context.userId,
+      agentId: context.agentId,
+      connectionId: config.connectionId || config.connection_id,
+      providerKey: 'weather',
+      appKey: 'forecast',
+    });
+
+    const eventTypes = normalizeEventTypes(config.eventTypes || config.event_types);
+    if (eventTypes.length === 0) {
+      throw new Error(
+        'At least one weather event type is required: rain_start, snow_start, wind_alert, temperature_above, temperature_below.',
+      );
+    }
+
+    const location = normalizeTrimmedText(
+      config.location || config.locationQuery || config.query,
+      180,
+    );
+    if (!location) {
+      throw new Error('Weather event location is required (for example: Berlin, DE).');
+    }
+
+    return {
+      connectionId: connection.id,
+      accountEmail: connection.account_email || null,
+      location,
+      eventTypes,
+      minPrecipitationMm: normalizeNumber(config.minPrecipitationMm ?? config.min_precipitation_mm, 0.4),
+      minSnowfallCm: normalizeNumber(config.minSnowfallCm ?? config.min_snowfall_cm, 0.2),
+      windAlertKph: normalizeNumber(config.windAlertKph ?? config.wind_alert_kph, 40),
+      temperatureAboveC: normalizeNumber(config.temperatureAboveC ?? config.temperature_above_c, 32),
+      temperatureBelowC: normalizeNumber(config.temperatureBelowC ?? config.temperature_below_c, 0),
+      horizonHours: Math.max(1, Math.min(Number(config.horizonHours || config.horizon_hours) || 12, 48)),
+    };
+  },
+  summarize(config = {}) {
+    const parts = ['Weather'];
+    if (config.location) parts.push(config.location);
+    if (Array.isArray(config.eventTypes) && config.eventTypes.length > 0) {
+      parts.push(config.eventTypes.join(', '));
+    }
+    return parts.join(' · ');
+  },
+};

package/server/services/tasks/integration_runtime.js

@@ -8,6 +8,7 @@ const POLLED_TRIGGER_TYPES = Object.freeze([
   'outlook_email_received',
   'slack_message_received',
   'teams_message_received',
+  'weather_event',
   'whatsapp_personal_message_received',
 ]);
 
@@ -166,6 +167,90 @@ async function fetchTriggerRows({ integrationManager, userId, agentId, triggerTy
       .sort(sortByTimestamp);
   }
 
+  if (triggerType === 'weather_event') {
+    const forecast = await integrationManager.executeTool(userId, 'weather_get_forecast', {
+      ...connectionArg,
+      ...(config.location ? { location: config.location } : {}),
+      forecast_hours: Math.max(1, Math.min(Number(config.horizonHours) || 12, 48)),
+    }, scopedAgentId);
+    const hourly = Array.isArray(forecast?.hourly) ? forecast.hourly : [];
+    const eventTypes = Array.isArray(config.eventTypes) ? config.eventTypes : [];
+    const rows = [];
+
+    for (let index = 0; index < hourly.length; index += 1) {
+      const row = hourly[index] || {};
+      const previous = index > 0 ? (hourly[index - 1] || {}) : null;
+      const time = String(row.time || '').trim();
+      if (!time) continue;
+
+      const rain = Number(row.rain || row.precipitation || 0);
+      const prevRain = Number(previous?.rain || previous?.precipitation || 0);
+      const snowfall = Number(row.snowfall || 0);
+      const prevSnow = Number(previous?.snowfall || 0);
+      const windSpeed = Number(row.windSpeed || 0);
+      const temperature = Number(row.temperature);
+
+      const candidates = [
+        {
+          type: 'rain_start',
+          active:
+            eventTypes.includes('rain_start')
+            && rain >= Number(config.minPrecipitationMm || 0.4)
+            && prevRain < Number(config.minPrecipitationMm || 0.4),
+        },
+        {
+          type: 'snow_start',
+          active:
+            eventTypes.includes('snow_start')
+            && snowfall >= Number(config.minSnowfallCm || 0.2)
+            && prevSnow < Number(config.minSnowfallCm || 0.2),
+        },
+        {
+          type: 'wind_alert',
+          active:
+            eventTypes.includes('wind_alert')
+            && windSpeed >= Number(config.windAlertKph || 40),
+        },
+        {
+          type: 'temperature_above',
+          active:
+            eventTypes.includes('temperature_above')
+            && Number.isFinite(temperature)
+            && temperature >= Number(config.temperatureAboveC || 32),
+        },
+        {
+          type: 'temperature_below',
+          active:
+            eventTypes.includes('temperature_below')
+            && Number.isFinite(temperature)
+            && temperature <= Number(config.temperatureBelowC || 0),
+        },
+      ];
+
+      for (const candidate of candidates) {
+        if (!candidate.active) continue;
+        rows.push({
+          fingerprint: `weather:${config.connectionId}:${candidate.type}:${time}`,
+          timestamp: time,
+          context: {
+            triggerEvent: {
+              provider: 'weather',
+              eventType: candidate.type,
+              location: forecast?.location?.label || config.location || null,
+              time,
+              rain,
+              snowfall,
+              windSpeed,
+              temperature,
+            },
+          },
+        });
+      }
+    }
+
+    return rows.sort(sortByTimestamp);
+  }
+
   return [];
 }
 

package/server/services/tasks/runtime.js

@@ -66,7 +66,7 @@ class TaskRuntime {
       label: adapter.label,
       providerKey: adapter.providerKey || null,
       appKey: adapter.appKey || null,
-      available: adapter.type === 'schedule'
+      available: adapter.type === 'schedule' || adapter.type === 'manual'
         ? true
         : this._hasConnectedApp(userId, agentId, adapter.providerKey, adapter.appKey),
     }));
@@ -222,8 +222,8 @@ class TaskRuntime {
     const existing = this.scheduleJobs.get(taskId);
     if (existing) {
       existing.task.stop();
-      this.scheduleJobs.delete(taskId);
     }
+    this.scheduleJobs.delete(taskId);
   }
 
   async _executeTask(taskId, userId, executionMeta = {}) {

package/server/services/voice/agentBridge.js

@@ -23,6 +23,7 @@ class VoiceAgentBridge {
     session.currentRunId = runId;
 
     try {
+      const deferredFollowUp = await this.runtimeManager.prepareDeferredVoiceFollowUp(session);
       const result = await runVoiceTranscriptTurn({
         userId: session.userId,
         agentId: session.agentId,
@@ -41,10 +42,25 @@ class VoiceAgentBridge {
         runId,
       });
       session.currentRunId = result.runId || runId;
-      if (String(result.replyText || '').trim()) {
-        await this.runtimeManager.deliverAssistantMessage(session, result.replyText, {
-          kind: 'final',
-        });
+      const replyText = String(result.replyText || '').trim();
+      if (replyText) {
+        if (deferredFollowUp) {
+          const followUp = await this.runtimeManager.deliverDeferredVoiceFollowUp(
+            session,
+            deferredFollowUp,
+            replyText,
+            result.runId || runId,
+          );
+          if (!followUp?.sent) {
+            await this.runtimeManager.deliverAssistantMessage(session, replyText, {
+              kind: 'final',
+            });
+          }
+        } else {
+          await this.runtimeManager.deliverAssistantMessage(session, replyText, {
+            kind: 'final',
+          });
+        }
       }
       await session.setState('idle');
       session.currentRunId = null;

package/server/services/voice/message.js

@@ -61,6 +61,9 @@ function buildDirectVoiceContext({
     allowInterimUpdates
       ? 'Do not use send_message. Use send_interim_update only for short spoken progress updates when silence would otherwise be noticeable.'
       : 'Do not use send_message or send_interim_update.',
+    allowInterimUpdates
+      ? 'You decide when a task is taking long. If so, send a natural deferral via send_interim_update and set defer_follow_up=true.'
+      : 'Keep the spoken response direct and concise.',
     'Return only the assistant reply.',
   ];
 

package/server/services/voice/runtimeManager.js

@@ -1,8 +1,10 @@
 'use strict';
 
 const { randomUUID } = require('crypto');
+const db = require('../../db/database');
 
 const { getProviderRuntimeConfig } = require('../ai/models');
+const { isMainAgent, resolveAgentId } = require('../agents/manager');
 const { getVoiceRuntimeSettings } = require('./liveSettings');
 const { VoiceLiveSession } = require('./liveSession');
 const { OpenAiLiveRelayAdapter } = require('./openaiLiveRelayAdapter');
@@ -180,11 +182,14 @@ class VoiceRuntimeManager {
     await session.setState('idle');
   }
 
-  async publishInterimUpdate({ sessionId, content, kind = 'progress' } = {}) {
+  async publishInterimUpdate({ sessionId, content, kind = 'progress', deferFollowUp = false } = {}) {
     const session = this.getSession(sessionId);
     if (!session || session.closed) {
       return { sent: false, skipped: true, reason: 'Voice session is not active.' };
     }
+    if (deferFollowUp === true) {
+      session.deferFollowUpRequested = true;
+    }
     await this.deliverAssistantMessage(session, content, { kind });
     return { sent: true };
   }
@@ -196,6 +201,88 @@ class VoiceRuntimeManager {
     await session.publishAssistantOutput(normalized, options);
   }
 
+  async prepareDeferredVoiceFollowUp(session) {
+    if (!session || session.closed) return null;
+    if (String(session.platform || '').trim() !== 'voice_live') return null;
+
+    const target = this.#resolvePreferredMessagingTarget(session.userId, session.agentId);
+    if (!target) return null;
+    return {
+      target,
+    };
+  }
+
+  async deliverDeferredVoiceFollowUp(session, followUpPlan, replyText, runId = null) {
+    if (!session || session.closed || !followUpPlan || session.deferFollowUpRequested !== true) {
+      return { sent: false, skipped: true };
+    }
+    const manager = this.#messagingManager();
+    if (!manager || typeof manager.sendMessage !== 'function') {
+      return { sent: false, skipped: true, reason: 'Messaging manager unavailable.' };
+    }
+
+    const target = followUpPlan.target;
+    if (!target?.platform || !target?.to) {
+      return { sent: false, skipped: true, reason: 'No deferred follow-up target.' };
+    }
+
+    const status = typeof manager.getPlatformStatus === 'function'
+      ? manager.getPlatformStatus(session.userId, target.platform, { agentId: session.agentId })
+      : null;
+    if (status && status.status !== 'connected') {
+      return { sent: false, skipped: true, reason: `Platform ${target.platform} is not connected.` };
+    }
+
+    const body = String(replyText || '').trim();
+    if (!body) {
+      return { sent: false, skipped: true, reason: 'Reply text is empty.' };
+    }
+
+    const followUpContent = [
+      'Update from your voice request:',
+      '',
+      body,
+    ].join('\n');
+
+    let sendResult;
+    try {
+      sendResult = await manager.sendMessage(
+        session.userId,
+        target.platform,
+        target.to,
+        followUpContent,
+        {
+          agentId: session.agentId,
+          runId,
+          persistConversation: true,
+        },
+      );
+    } catch (err) {
+      console.error('Failed to send deferred voice follow-up:', err);
+      return {
+        sent: false,
+        skipped: false,
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        runId,
+      };
+    }
+
+    session.deferFollowUpRequested = false;
+    const label = this.#platformLabel(target.platform);
+    await this.deliverAssistantMessage(
+      session,
+      `I sent the full result to your ${label} chat.`,
+      { kind: 'final' },
+    );
+
+    return {
+      sent: true,
+      target,
+      result: sendResult,
+    };
+  }
+
   async startTelnyxTurn({
     userId,
     agentId = null,
@@ -284,6 +371,54 @@ class VoiceRuntimeManager {
     }
   }
 
+  #messagingManager() {
+    return this.agentEngine?.messagingManager || this.agentEngine?.app?.locals?.messagingManager || null;
+  }
+
+  #readScopedSetting(userId, agentId, key) {
+    const row = db.prepare(
+      'SELECT value FROM agent_settings WHERE user_id = ? AND agent_id = ? AND key = ?'
+    ).get(userId, agentId, key);
+    if (row) {
+      try {
+        return JSON.parse(row.value);
+      } catch {
+        return row.value;
+      }
+    }
+    if (!isMainAgent(userId, agentId)) return null;
+    const userRow = db.prepare(
+      'SELECT value FROM user_settings WHERE user_id = ? AND key = ?'
+    ).get(userId, key);
+    if (!userRow) return null;
+    try {
+      return JSON.parse(userRow.value);
+    } catch {
+      return userRow.value;
+    }
+  }
+
+  #resolvePreferredMessagingTarget(userId, agentId = null) {
+    const manager = this.#messagingManager();
+    if (!manager) return null;
+    const scopedAgentId = resolveAgentId(userId, agentId);
+    const platform = String(this.#readScopedSetting(userId, scopedAgentId, 'last_platform') || '').trim();
+    const to = String(this.#readScopedSetting(userId, scopedAgentId, 'last_chat_id') || '').trim();
+    if (!platform || !to) return null;
+
+    const status = typeof manager.getPlatformStatus === 'function'
+      ? manager.getPlatformStatus(userId, platform, { agentId: scopedAgentId })
+      : null;
+    if (!status || status.status !== 'connected') return null;
+    return { platform, to };
+  }
+
+  #platformLabel(platformName) {
+    const raw = String(platformName || '').trim();
+    if (!raw) return 'message';
+    return raw.replace(/[_-]+/g, ' ');
+  }
+
   async #deliverFlutterAssistantOutput(socket, sessionId, session, content, options = {}) {
     const kind = String(options.kind || 'final').trim() || 'final';
     socket.emit('voice:assistant_text', {

package/server/services/widgets/service.js

@@ -243,7 +243,11 @@ class WidgetService {
        WHERE id = ? AND user_id = ?`
     ).get(widgetId, userId);
     if (!row) return null;
-    return this._serializeWidget(row, this._loadLatestSnapshotMap([widgetId]).get(widgetId) || null);
+    return this._serializeWidget(
+      row,
+      this._loadLatestSnapshotMap([widgetId]).get(widgetId) || null,
+      this._loadWidgetTasksMap([widgetId], userId).get(widgetId) || []
+    );
   }
 
   listWidgets(userId, { agentId = null } = {}) {
@@ -262,7 +266,8 @@ class WidgetService {
          ORDER BY updated_at DESC, created_at DESC`
       ).all(userId);
     const snapshotMap = this._loadLatestSnapshotMap(rows.map((row) => row.id));
-    return rows.map((row) => this._serializeWidget(row, snapshotMap.get(row.id) || null));
+    const tasksMap = this._loadWidgetTasksMap(rows.map((row) => row.id), userId);
+    return rows.map((row) => this._serializeWidget(row, snapshotMap.get(row.id) || null, tasksMap.get(row.id) || []));
   }
 
   listLatestSnapshots(userId, { agentId = null } = {}) {
@@ -343,7 +348,7 @@ class WidgetService {
       throw new Error('Widget not found.');
     }
 
-    const current = this._serializeWidget(existingRow, null);
+    const current = this._serializeWidget(existingRow, null, []);
     const normalized = normalizeWidgetInput({
       name: input.name ?? current.name,
       template: input.template ?? current.template,
@@ -581,7 +586,46 @@ class WidgetService {
     return map;
   }
 
-  _serializeWidget(row, latestSnapshot) {
+  _loadWidgetTasksMap(widgetIds, userId) {
+    const ids = Array.from(new Set(widgetIds.filter(Boolean)));
+    const map = new Map();
+    if (!ids.length) return map;
+    
+    const placeholders = ids.map(() => '?').join(', ');
+    const params = [userId, ...ids];
+    
+    // We filter tasks where task_type is NOT 'widget_refresh' 
+    // and where the task_config contains the widgetId.
+    const rows = db.prepare(
+      `SELECT id, name, trigger_type, enabled, task_config
+       FROM scheduled_tasks
+       WHERE user_id = ?
+         AND task_type != 'widget_refresh'
+         AND json_extract(task_config, '$.widgetId') IN (${placeholders})
+       ORDER BY created_at ASC`
+    ).all(...params);
+    
+    for (const row of rows) {
+      const config = parseJsonObject(row.task_config, {});
+      const widgetId = config.widgetId;
+      if (!widgetId) continue;
+      
+      const task = {
+        id: row.id,
+        name: row.name,
+        triggerType: row.trigger_type,
+        enabled: row.enabled !== 0 && row.enabled !== false,
+      };
+      
+      if (!map.has(widgetId)) {
+        map.set(widgetId, []);
+      }
+      map.get(widgetId).push(task);
+    }
+    return map;
+  }
+
+  _serializeWidget(row, latestSnapshot, tasks = []) {
     const definition = parseJsonObject(row.definition_json, {});
     return {
       id: row.id,
@@ -600,6 +644,7 @@ class WidgetService {
       updatedAt: row.updated_at || null,
       nextRefresh: row.refresh_cron ? findNextRun(row.refresh_cron)?.toISOString() || null : null,
       latestSnapshot,
+      tasks,
     };
   }
 }