neoagent 3.2.1-beta.2 → 3.2.1-beta.3

package/server/services/integrations/spotify/provider.js

@@ -1,7 +1,8 @@
 'use strict';
 
 const { describeEnvStatus, resolveSpotifyOAuthConfig } = require('../env');
-const { appendQuery, createOAuthProvider } = require('../oauth_provider');
+const { appendQuery, createOAuthProvider, fetchJson } = require('../oauth_provider');
+const { fetchResponseText } = require('../http');
 
 const SPOTIFY_APPS = [
   {
@@ -121,33 +122,32 @@ function spotifyUrl(path, query) {
   return url.toString();
 }
 
-async function refreshSpotifyAccessToken(config, credentials) {
+async function refreshSpotifyAccessToken(config, credentials, signal = null) {
   const refreshToken = String(credentials?.refresh_token || '').trim();
   if (!refreshToken) {
     return credentials;
   }
   const basic = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString('base64');
-  const response = await fetch('https://accounts.spotify.com/api/token', {
-    method: 'POST',
-    headers: {
-      Authorization: `Basic ${basic}`,
-      'Content-Type': 'application/x-www-form-urlencoded',
-      Accept: 'application/json',
+  const data = await fetchJson(
+    'https://accounts.spotify.com/api/token',
+    {
+      method: 'POST',
+      headers: { Authorization: `Basic ${basic}` },
+      form: {
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+      },
+      signal,
     },
-    body: new URLSearchParams({
-      grant_type: 'refresh_token',
-      refresh_token: refreshToken,
-    }).toString(),
-  });
-  const data = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    const message = data?.error_description || data?.error || `${response.status} ${response.statusText}`;
-    throw new Error(`Spotify token refresh failed: ${message}`);
+    { serviceName: 'Spotify token refresh' },
+  );
+  if (!String(data?.access_token || '').trim()) {
+    throw new Error('Spotify token refresh did not return an access token.');
   }
   const expiresIn = Number(data?.expires_in) || 3600;
   return {
     ...credentials,
-    access_token: data?.access_token || credentials.access_token,
+    access_token: data.access_token,
     refresh_token: data?.refresh_token || refreshToken,
     token_type: data?.token_type || credentials.token_type || 'Bearer',
     scope: data?.scope || credentials.scope || '',
@@ -156,7 +156,7 @@ async function refreshSpotifyAccessToken(config, credentials) {
   };
 }
 
-async function ensureSpotifyAccessToken(config, credentials) {
+async function ensureSpotifyAccessToken(config, credentials, signal = null) {
   const accessToken = String(credentials?.access_token || '').trim();
   if (!accessToken) {
     throw new Error('Spotify access token is missing. Reconnect this integration account.');
@@ -165,32 +165,36 @@ async function ensureSpotifyAccessToken(config, credentials) {
   const expiresAt = Date.parse(String(credentials?.expires_at || ''));
   const isNearExpiry = Number.isFinite(expiresAt) && expiresAt <= Date.now() + 60 * 1000;
   if (isNearExpiry && credentials?.refresh_token) {
-    return refreshSpotifyAccessToken(config, credentials);
+    return refreshSpotifyAccessToken(config, credentials, signal);
   }
   return credentials;
 }
 
-async function spotifyRequest(config, credentials, { method = 'GET', path, query, body }) {
-  let nextCredentials = await ensureSpotifyAccessToken(config, credentials);
-  const tokenType = String(nextCredentials?.token_type || 'Bearer').trim() || 'Bearer';
+async function spotifyRequest(config, context, { method = 'GET', path, query, body }) {
+  const { credentials, signal } = context;
+  let nextCredentials = await ensureSpotifyAccessToken(config, credentials, signal);
 
   const performRequest = async (tokenCreds) => {
     const tokenType = String(tokenCreds?.token_type || 'Bearer').trim() || 'Bearer';
-    const response = await fetch(spotifyUrl(path, query), {
-      method: String(method || 'GET').toUpperCase(),
-      headers: {
-        Authorization: `${tokenType} ${tokenCreds.access_token}`,
-        Accept: 'application/json',
-        ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+    const { response, text } = await fetchResponseText(
+      spotifyUrl(path, query),
+      {
+        method: String(method || 'GET').toUpperCase(),
+        headers: {
+          Authorization: `${tokenType} ${tokenCreds.access_token}`,
+          Accept: 'application/json',
+          ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+        },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        signal,
       },
-      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
-    });
+      { serviceName: 'Spotify' },
+    );
 
     if (response.status === 204) {
       return { ok: true, data: null, response };
     }
 
-    const text = await response.text();
     let parsed = null;
     try {
       parsed = text ? JSON.parse(text) : null;
@@ -202,7 +206,7 @@ async function spotifyRequest(config, credentials, { method = 'GET', path, query
 
   let result = await performRequest(nextCredentials);
   if (!result.ok && result.response.status === 401 && nextCredentials.refresh_token) {
-    nextCredentials = await refreshSpotifyAccessToken(config, nextCredentials);
+    nextCredentials = await refreshSpotifyAccessToken(config, nextCredentials, signal);
     result = await performRequest(nextCredentials);
   }
 
@@ -219,18 +223,18 @@ async function spotifyRequest(config, credentials, { method = 'GET', path, query
   };
 }
 
-async function executeSpotifyTool(toolName, args, { credentials }) {
+async function executeSpotifyTool(toolName, args, context) {
   const config = resolveSpotifyOAuthConfig();
   switch (toolName) {
     case 'spotify_get_current_playback': {
-      const { data, credentials: updated } = await spotifyRequest(config, credentials, {
+      const { data, credentials: updated } = await spotifyRequest(config, context, {
         path: '/v1/me/player',
       });
       return { result: data || { is_playing: false }, credentials: updated };
     }
     case 'spotify_get_recently_played': {
       const limit = Math.max(1, Math.min(Number(args.limit) || 20, 50));
-      const { data, credentials: updated } = await spotifyRequest(config, credentials, {
+      const { data, credentials: updated } = await spotifyRequest(config, context, {
         path: '/v1/me/player/recently-played',
         query: { limit },
       });
@@ -246,7 +250,7 @@ async function executeSpotifyTool(toolName, args, { credentials }) {
       const type = types.length > 0 ? types.join(',') : 'track';
       const limit = Math.max(1, Math.min(Number(args.limit) || 10, 50));
       const market = String(args.market || '').trim().toUpperCase();
-      const { data, credentials: updated } = await spotifyRequest(config, credentials, {
+      const { data, credentials: updated } = await spotifyRequest(config, context, {
         path: '/v1/search',
         query: {
           q: queryText,
@@ -348,7 +352,7 @@ async function executeSpotifyTool(toolName, args, { credentials }) {
           throw new Error('Unsupported action. Use play, pause, next, previous, seek, set_volume, shuffle, or repeat.');
       }
 
-      const { data, credentials: updated } = await spotifyRequest(config, credentials, request);
+      const { data, credentials: updated } = await spotifyRequest(config, context, request);
       return {
         result: {
           action,
@@ -359,7 +363,7 @@ async function executeSpotifyTool(toolName, args, { credentials }) {
       };
     }
     case 'spotify_api_request': {
-      const { data, credentials: updated } = await spotifyRequest(config, credentials, {
+      const { data, credentials: updated } = await spotifyRequest(config, context, {
         method: args.method,
         path: requireText(args.path, 'path'),
         query: args.query,
@@ -372,20 +376,16 @@ async function executeSpotifyTool(toolName, args, { credentials }) {
   }
 }
 
-async function fetchSpotifyProfile(accessToken) {
-  const response = await fetch('https://api.spotify.com/v1/me', {
-    method: 'GET',
-    headers: {
-      Authorization: `Bearer ${accessToken}`,
-      Accept: 'application/json',
+async function fetchSpotifyProfile(accessToken, signal = null) {
+  return fetchJson(
+    'https://api.spotify.com/v1/me',
+    {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${accessToken}` },
+      signal,
     },
-  });
-  const payload = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    const message = payload?.error?.message || payload?.error || `${response.status} ${response.statusText}`;
-    throw new Error(`Spotify profile request failed: ${message}`);
-  }
-  return payload;
+    { serviceName: 'Spotify profile' },
+  );
 }
 
 function createSpotifyProvider() {
@@ -418,27 +418,23 @@ function createSpotifyProvider() {
         appId: app.id,
       };
     },
-    async finishOAuth({ code, app }) {
+    async finishOAuth({ code, app, signal }) {
       const config = resolveSpotifyOAuthConfig();
       const basic = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString('base64');
-      const tokenResponse = await fetch('https://accounts.spotify.com/api/token', {
-        method: 'POST',
-        headers: {
-          Authorization: `Basic ${basic}`,
-          'Content-Type': 'application/x-www-form-urlencoded',
-          Accept: 'application/json',
+      const token = await fetchJson(
+        'https://accounts.spotify.com/api/token',
+        {
+          method: 'POST',
+          headers: { Authorization: `Basic ${basic}` },
+          form: {
+            grant_type: 'authorization_code',
+            code,
+            redirect_uri: config.redirectUri,
+          },
+          signal,
         },
-        body: new URLSearchParams({
-          grant_type: 'authorization_code',
-          code,
-          redirect_uri: config.redirectUri,
-        }).toString(),
-      });
-      const token = await tokenResponse.json().catch(() => ({}));
-      if (!tokenResponse.ok) {
-        const message = token?.error_description || token?.error || `${tokenResponse.status} ${tokenResponse.statusText}`;
-        throw new Error(`Spotify OAuth token exchange failed: ${message}`);
-      }
+        { serviceName: 'Spotify OAuth token exchange' },
+      );
 
       const accessToken = String(token?.access_token || '').trim();
       if (!accessToken) {
@@ -449,7 +445,7 @@ function createSpotifyProvider() {
         throw new Error('Spotify OAuth did not return a refresh token.');
       }
 
-      const profile = await fetchSpotifyProfile(accessToken);
+      const profile = await fetchSpotifyProfile(accessToken, signal);
       const accountEmail =
         String(profile?.email || '').trim() ||
         (String(profile?.id || '').trim() ? `spotify:${String(profile.id).trim()}` : 'spotify_user');

package/server/services/integrations/trello/provider.js

@@ -276,7 +276,10 @@ function trelloUrl(path, query = {}, config = {}) {
 async function trelloRequest(config, options = {}) {
   return fetchJson(
     trelloUrl(options.path, options.query, config),
-    { method: String(options.method || 'GET').toUpperCase() },
+    {
+      method: String(options.method || 'GET').toUpperCase(),
+      signal: options.signal || config.signal,
+    },
     { serviceName: 'Trello' },
   );
 }
@@ -492,8 +495,15 @@ function resolveTrelloCredentials(connection, credentials = {}) {
   return { apiKey, token };
 }
 
-async function executeTrelloTool(toolName, args, { connection, credentials }) {
-  const config = resolveTrelloCredentials(connection, credentials);
+async function executeTrelloTool(
+  toolName,
+  args,
+  { connection, credentials, signal },
+) {
+  const config = {
+    ...resolveTrelloCredentials(connection, credentials),
+    signal,
+  };
 
   switch (toolName) {
     case 'trello_get_me': {
@@ -731,14 +741,18 @@ function createTrelloProvider() {
       }
       return 'Trello: native Trello access is connected in this run with one Trello account for board, list, card, comment, and search tools.';
     },
-    async executeTool(toolName, args, connection) {
+    async executeTool(toolName, args, connection, executionOptions = {}) {
       let credentials = {};
       try {
         credentials = JSON.parse(decryptValue(connection.credentials_json || '{}') || '{}');
       } catch {
         credentials = {};
       }
-      return executeTrelloTool(toolName, args, { connection, credentials });
+      return executeTrelloTool(toolName, args, {
+        connection,
+        credentials,
+        signal: executionOptions.signal || null,
+      });
     },
     getUserConfig({ userId, agentId }) {
       const normalizedUserId = Number(userId);
@@ -757,7 +771,7 @@ function createTrelloProvider() {
         hasConnectedAccount: accountCount > 0,
       };
     },
-    async saveUserConfig({ userId, agentId, config }) {
+    async saveUserConfig({ userId, agentId, config, signal }) {
       const normalizedUserId = Number(userId);
       if (!Number.isInteger(normalizedUserId) || normalizedUserId <= 0) {
         throw new Error('A valid user is required to save Trello configuration.');
@@ -796,7 +810,7 @@ function createTrelloProvider() {
 
       let profile;
       try {
-        profile = await fetchTrelloMemberProfile({ apiKey, token });
+        profile = await fetchTrelloMemberProfile({ apiKey, token, signal });
       } catch (error) {
         const message = String(error?.message || '').toLowerCase();
         if (

package/server/services/integrations/weather/provider.js

@@ -152,14 +152,14 @@ function cleanLocationResult(item = {}) {
   };
 }
 
-async function geocodeLocation(locationQuery, limit = 1) {
+async function geocodeLocation(locationQuery, limit = 1, signal = null) {
   const query = String(locationQuery || '').trim();
   if (!query) {
     throw new Error('location is required when latitude/longitude are not provided.');
   }
   const result = await fetchJson(
     `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(query)}&count=${Math.max(1, Math.min(Number(limit) || 1, 10))}&language=en&format=json`,
-    { method: 'GET' },
+    { method: 'GET', signal },
     { serviceName: 'Open-Meteo geocoding' },
   );
   const matches = Array.isArray(result?.results) ? result.results : [];
@@ -169,7 +169,7 @@ async function geocodeLocation(locationQuery, limit = 1) {
   return matches.map(cleanLocationResult);
 }
 
-async function resolveLocation(args = {}, connection = null) {
+async function resolveLocation(args = {}, connection = null, signal = null) {
   const latitude = toNumber(args.latitude, null);
   const longitude = toNumber(args.longitude, null);
   if (latitude !== null && longitude !== null) {
@@ -183,7 +183,7 @@ async function resolveLocation(args = {}, connection = null) {
 
   const location = String(args.location || '').trim();
   if (location) {
-    const [best] = await geocodeLocation(location, 1);
+    const [best] = await geocodeLocation(location, 1, signal);
     return {
       latitude: best.latitude,
       longitude: best.longitude,
@@ -221,7 +221,7 @@ function enrichCurrent(current = {}) {
   };
 }
 
-async function fetchForecastForLocation(location, forecastHours = 24) {
+async function fetchForecastForLocation(location, forecastHours = 24, signal = null) {
   const horizon = Math.max(1, Math.min(Number(forecastHours) || 24, 72));
   const url = new URL('https://api.open-meteo.com/v1/forecast');
   url.searchParams.set('latitude', String(location.latitude));
@@ -259,7 +259,11 @@ async function fetchForecastForLocation(location, forecastHours = 24) {
   url.searchParams.set('forecast_hours', String(horizon));
   url.searchParams.set('timezone', location.timezone || 'auto');
 
-  const result = await fetchJson(url.toString(), { method: 'GET' }, { serviceName: 'Open-Meteo forecast' });
+  const result = await fetchJson(
+    url.toString(),
+    { method: 'GET', signal },
+    { serviceName: 'Open-Meteo forecast' },
+  );
   const hourly = result?.hourly || {};
   const times = Array.isArray(hourly.time) ? hourly.time : [];
   const rows = times.map((time, index) => {
@@ -304,6 +308,7 @@ class WeatherProvider {
     this.sessions = new Map();
     this.sessionTTL = 30 * 60 * 1000;
     this.#pruneTimer = setInterval(() => this.pruneExpiredSessions(), this.sessionTTL);
+    this.#pruneTimer.unref?.();
   }
 
   #pruneTimer = null;
@@ -504,7 +509,8 @@ class WeatherProvider {
     }
   }
 
-  async executeTool(toolName, args, connection) {
+  async executeTool(toolName, args, connection, executionOptions = {}) {
+    const signal = executionOptions.signal || null;
     switch (toolName) {
       case 'weather_search_locations': {
         const query = String(args.query || '').trim();
@@ -512,7 +518,7 @@ class WeatherProvider {
           throw new Error('query is required.');
         }
         const limit = Math.max(1, Math.min(Number(args.limit) || 5, 10));
-        const results = await geocodeLocation(query, limit);
+        const results = await geocodeLocation(query, limit, signal);
         return {
           result: {
             query,
@@ -522,8 +528,8 @@ class WeatherProvider {
         };
       }
       case 'weather_get_current': {
-        const location = await resolveLocation(args, connection);
-        const forecast = await fetchForecastForLocation(location, 1);
+        const location = await resolveLocation(args, connection, signal);
+        const forecast = await fetchForecastForLocation(location, 1, signal);
         return {
           result: {
             location: forecast.location,
@@ -532,9 +538,9 @@ class WeatherProvider {
         };
       }
       case 'weather_get_forecast': {
-        const location = await resolveLocation(args, connection);
+        const location = await resolveLocation(args, connection, signal);
         const forecastHours = Math.max(1, Math.min(Number(args.forecast_hours) || 24, 72));
-        const forecast = await fetchForecastForLocation(location, forecastHours);
+        const forecast = await fetchForecastForLocation(location, forecastHours, signal);
         return {
           result: {
             location: forecast.location,

package/server/services/integrations/whatsapp/provider.js

@@ -9,6 +9,10 @@ const { AGENT_DATA_DIR } = require('../../../../runtime/paths');
 const { encryptValue, decryptValue } = require('../secrets');
 const { withConnectionAccessMode } = require('../access');
 const { normalizeWhatsAppId, toWhatsAppJid } = require('../../../utils/whatsapp');
+const {
+  waitForAbortableResult,
+  waitForBoundedResult,
+} = require('../http');
 
 const WHATSAPP_APP = {
   id: 'personal',
@@ -222,6 +226,7 @@ class WhatsAppPersonalProvider extends EventEmitter {
     this.reconnectTimers = new Map();
     this.sessionReconnectTimers = new Map();
     this.io = options.io || null;
+    this.shuttingDown = false;
   }
 
   _clearReconnectTimer(connectionId) {
@@ -241,7 +246,7 @@ class WhatsAppPersonalProvider extends EventEmitter {
   }
 
   _scheduleReconnect(client, attempt = 1) {
-    if (!client?.connectionId || client.manualDisconnect) {
+    if (this.shuttingDown || !client?.connectionId || client.manualDisconnect) {
       return;
     }
     this._clearReconnectTimer(client.connectionId);
@@ -267,11 +272,17 @@ class WhatsAppPersonalProvider extends EventEmitter {
         }
       }
     }, delayMs);
+    timer.unref?.();
     this.reconnectTimers.set(client.connectionId, timer);
   }
 
   _scheduleSessionReconnect(session, attempt = 1) {
-    if (!session?.id || session.status === 'connected' || session.status === 'logged_out') {
+    if (
+      this.shuttingDown ||
+      !session?.id ||
+      session.status === 'connected' ||
+      session.status === 'logged_out'
+    ) {
       return;
     }
     this._clearSessionReconnectTimer(session.id);
@@ -290,6 +301,7 @@ class WhatsAppPersonalProvider extends EventEmitter {
         current.error = err?.message || 'connection_failed';
       });
     }, delayMs);
+    timer.unref?.();
     this.sessionReconnectTimers.set(session.id, timer);
   }
 
@@ -451,6 +463,9 @@ class WhatsAppPersonalProvider extends EventEmitter {
   }
 
   async beginConnection({ userId, agentId, appKey }) {
+    if (this.shuttingDown) {
+      throw new Error('WhatsApp integration is shutting down.');
+    }
     if (!this.getApp(appKey)) {
       throw new Error(`Unknown ${this.label} app: ${appKey || 'missing app key'}`);
     }
@@ -533,8 +548,9 @@ class WhatsAppPersonalProvider extends EventEmitter {
     }
   }
 
-  async executeTool(toolName, args, connection) {
-    const client = await this._ensureClient(connection);
+  async executeTool(toolName, args, connection, executionOptions = {}) {
+    const signal = executionOptions.signal || null;
+    const client = await this._ensureClient(connection, { signal });
 
     switch (toolName) {
       case 'whatsapp_personal_get_profile':
@@ -584,9 +600,16 @@ class WhatsAppPersonalProvider extends EventEmitter {
       }
       case 'whatsapp_personal_send_message': {
         const jid = this._normalizeChatId(requireText(args.to, 'to'));
-        await client.socket.sendMessage(jid, {
-          text: requireText(args.text, 'text'),
-        });
+        await waitForBoundedResult(
+          client.socket.sendMessage(jid, {
+            text: requireText(args.text, 'text'),
+          }),
+          {
+            signal,
+            timeoutMs: 60000,
+            serviceName: 'WhatsApp send',
+          },
+        );
         return {
           result: {
             sent: true,
@@ -900,13 +923,13 @@ class WhatsAppPersonalProvider extends EventEmitter {
     return row?.id;
   }
 
-  async _ensureClient(connection) {
+  async _ensureClient(connection, options = {}) {
     const existing = this.clients.get(connection.id);
     if (existing?.status === 'connected' && existing.socket) {
       return existing;
     }
     if (existing?.connectPromise) {
-      await existing.connectPromise;
+      await waitForAbortableResult(existing.connectPromise, options.signal);
       const ready = this.clients.get(connection.id);
       if (ready?.status === 'connected' && ready.socket) {
         return ready;
@@ -935,16 +958,16 @@ class WhatsAppPersonalProvider extends EventEmitter {
       logger: createSilentLogger(),
       connectPromise: null,
     };
-    client.connectPromise = this._connectClient(client);
+    const connectPromise = this._connectClient(client);
+    client.connectPromise = connectPromise;
     this.clients.set(connection.id, client);
-    try {
-      await client.connectPromise;
-    } finally {
+    void connectPromise.finally(() => {
       const current = this.clients.get(connection.id);
-      if (current) {
+      if (current?.connectPromise === connectPromise) {
         current.connectPromise = null;
       }
-    }
+    }).catch(() => {});
+    await waitForAbortableResult(connectPromise, options.signal);
     const ready = this.clients.get(connection.id);
     if (!ready?.socket || ready.status !== 'connected') {
       throw new Error('WhatsApp personal account is not connected.');
@@ -953,6 +976,9 @@ class WhatsAppPersonalProvider extends EventEmitter {
   }
 
   async _connectClient(client) {
+    if (this.shuttingDown) {
+      throw new Error('WhatsApp integration is shutting down.');
+    }
     ensureDir(client.authDir);
     client.manualDisconnect = false;
     const {
@@ -981,6 +1007,9 @@ class WhatsAppPersonalProvider extends EventEmitter {
     if (Array.isArray(version) && version.length > 0) {
       socketConfig.version = version;
     }
+    try {
+      client.socket?.end(new Error('client_reconnect'));
+    } catch {}
     const sock = makeWASocket(socketConfig);
 
     client.socket = sock;
@@ -989,6 +1018,10 @@ class WhatsAppPersonalProvider extends EventEmitter {
 
     await new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
+        client.status = 'disconnected';
+        try {
+          sock.end(new Error('connection_timeout'));
+        } catch {}
         reject(new Error('WhatsApp connection timed out.'));
       }, 60000);
 
@@ -1017,7 +1050,10 @@ class WhatsAppPersonalProvider extends EventEmitter {
 
   async _resolveBaileysVersion(fetchLatestBaileysVersion) {
     try {
-      const result = await fetchLatestBaileysVersion();
+      const result = await waitForBoundedResult(fetchLatestBaileysVersion(), {
+        timeoutMs: 15000,
+        serviceName: 'WhatsApp version discovery',
+      });
       if (Array.isArray(result?.version) && result.version.length > 0) {
         return result.version;
       }
@@ -1026,6 +1062,30 @@ class WhatsAppPersonalProvider extends EventEmitter {
     }
     return null;
   }
+
+  async shutdown() {
+    this.shuttingDown = true;
+    for (const timer of this.reconnectTimers.values()) clearTimeout(timer);
+    for (const timer of this.sessionReconnectTimers.values()) clearTimeout(timer);
+    this.reconnectTimers.clear();
+    this.sessionReconnectTimers.clear();
+
+    const sockets = new Set();
+    for (const client of this.clients.values()) {
+      client.manualDisconnect = true;
+      if (client.socket) sockets.add(client.socket);
+    }
+    for (const session of this.sessions.values()) {
+      if (session.socket) sockets.add(session.socket);
+    }
+    for (const socket of sockets) {
+      try {
+        socket.end(new Error('server_shutdown'));
+      } catch {}
+    }
+    this.clients.clear();
+    this.sessions.clear();
+  }
 }
 
 function createWhatsAppPersonalProvider(options = {}) {