neoagent 2.3.0 → 2.3.1-beta.2

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

@@ -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', {