neoagent 3.2.1-beta.2 → 3.2.1-beta.4

package/server/services/memory/ingestion_documents.js

@@ -12,8 +12,11 @@ const {
   safeTrim,
 } = require('./ingestion_support');
 const { chunkDocument, overlapWindowChunks } = require('./ingestion_chunking');
+const { isAbortError, throwIfAborted } = require('../../utils/abort');
 
 async function ingestDocuments(service, userId, documents = [], options = {}) {
+  const signal = options.signal || null;
+  throwIfAborted(signal, 'Memory ingestion aborted.');
   const agentId = resolveAgentId(userId, options.agentId || options.agent_id || null);
   const normalizedDocs = (Array.isArray(documents) ? documents : [])
     .map((document) => normalizeDocument(document, {
@@ -45,6 +48,7 @@ async function ingestDocuments(service, userId, documents = [], options = {}) {
   const memoryIds = [];
   try {
     for (const document of normalizedDocs) {
+      throwIfAborted(signal, 'Memory ingestion aborted.');
       const documentId = service.memoryManager.upsertIngestionDocument(
         userId,
         document,
@@ -55,6 +59,7 @@ async function ingestDocuments(service, userId, documents = [], options = {}) {
       const chunks = chunkDocument(document);
       const savedChunkMemoryIds = [];
       for (const chunk of chunks) {
+        throwIfAborted(signal, 'Memory ingestion aborted.');
         const memoryId = await service.memoryManager.saveMemory(
           userId,
           `${document.title}\n${chunk.content}`,
@@ -87,6 +92,7 @@ async function ingestDocuments(service, userId, documents = [], options = {}) {
                 charEnd: chunk.charEnd,
               },
             },
+            signal,
           },
         );
         if (!memoryId) continue;
@@ -110,6 +116,7 @@ async function ingestDocuments(service, userId, documents = [], options = {}) {
 
       const overlapChunks = overlapWindowChunks(chunks);
       for (const window of overlapChunks) {
+        throwIfAborted(signal, 'Memory ingestion aborted.');
         const windowMemoryId = await service.memoryManager.saveMemory(
           userId,
           `${document.title}\n${window.content}`,
@@ -143,6 +150,7 @@ async function ingestDocuments(service, userId, documents = [], options = {}) {
               },
               isOverlapWindow: true,
             },
+            signal,
           },
         );
         if (windowMemoryId) savedChunkMemoryIds.push(windowMemoryId);
@@ -151,6 +159,7 @@ async function ingestDocuments(service, userId, documents = [], options = {}) {
       service.memoryManager.pruneSourceChunks(documentId, retainedChunkIds);
     }
 
+    throwIfAborted(signal, 'Memory ingestion aborted.');
     service.memoryManager.recordIngestionJob(userId, {
       id: jobId,
       sourceType,
@@ -174,17 +183,18 @@ async function ingestDocuments(service, userId, documents = [], options = {}) {
       knowledgeViews,
     };
   } catch (err) {
+    const cancelled = isAbortError(err, signal);
     service.memoryManager.recordIngestionJob(userId, {
       id: jobId,
       sourceType,
       providerKey: safeTrim(options.providerKey, 80),
       connectionId,
-      status: 'failed',
+      status: cancelled ? 'cancelled' : 'failed',
       freshnessPolicy: policy,
       documentCount: documentIds.length,
-      error: err.message,
+      error: cancelled ? null : err.message,
       completedAt: new Date().toISOString(),
-      nextSyncAt: nextSyncFromPolicy(policy),
+      nextSyncAt: cancelled ? null : nextSyncFromPolicy(policy),
     }, { agentId });
     throw err;
   }

package/server/services/memory/manager.js

@@ -3,7 +3,6 @@ const path = require('path');
 const { v4: uuidv4 } = require('uuid');
 const db = require('../../db/database');
 const {
-  getEmbedding,
   getEmbeddingWithMetadata,
   cosineSimilarity,
   serializeEmbedding,
@@ -41,11 +40,14 @@ const {
   isLocalEncryptedValue,
 } = require('../../utils/local_secrets');
 
-async function getActiveProvider(userId, agentId = null) {
+async function getActiveProvider(userId, agentId = null, options = {}) {
   try {
     const { getSupportedModels } = require('../ai/models');
+    const { resolveModelSelection } = require('../ai/model_identity');
     const { getAiSettings } = require('../ai/settings');
-    const models = await getSupportedModels(userId, agentId);
+    const models = await getSupportedModels(userId, agentId, {
+      signal: options.signal,
+    });
     const aiSettings = getAiSettings(userId, agentId);
     const defaultChatModel = aiSettings.default_chat_model || null;
     const enabledIds = Array.isArray(aiSettings.enabled_models) ? aiSettings.enabled_models : null;
@@ -55,7 +57,10 @@ async function getActiveProvider(userId, agentId = null) {
       : (Array.isArray(enabledIds) && enabledIds.length > 0 ? enabledIds[0] : null);
 
     if (modelId) {
-      const def = models.find(m => m.id === modelId && m.available !== false);
+      const def = resolveModelSelection(
+        models.filter((model) => model.available !== false),
+        modelId,
+      );
       if (def) return def.provider;
     }
   } catch { }
@@ -1649,29 +1654,32 @@ class MemoryManager {
     const memoryHash = stableHash(`${category}:${content}`);
     const summary = summarizeForPrompt({ content, entities: extractEntities(content) });
 
-    const embeddingResult = await getEmbeddingWithMetadata(
-      content,
-      await getActiveProvider(userId, agentId),
-    );
-    const embedding = embeddingResult?.vector || null;
-
     const exact = this._findExactMemory(userId, agentId, memoryHash, scope);
     if (exact?.id) {
       return this._reinforceExactMemory(exact.id, importance);
     }
 
+    const embeddingResult = await getEmbeddingWithMetadata(
+      content,
+      await getActiveProvider(userId, agentId, options),
+      { signal: options.signal, inputType: 'document' },
+    );
+    const embedding = embeddingResult?.vector || null;
+
     const duplicateCandidateIds = embedding
       ? findEmbeddingCandidates(db, {
         userId,
         agentId,
         embedding,
+        embeddingProvider: embeddingResult.provider,
+        embeddingModel: embeddingResult.model,
         limit: 120,
       }).map((candidate) => candidate.memory_id)
       : this._searchMemoryFts(userId, agentId, content, 120)
         .map((candidate) => candidate.memory_id);
     const existing = duplicateCandidateIds.length
       ? db.prepare(
-        `SELECT id, content, embedding, metadata_json
+        `SELECT id, content, embedding, embedding_provider, embedding_model, metadata_json
          FROM memories
          WHERE id IN (${duplicateCandidateIds.map(() => '?').join(', ')})
            AND user_id = ? AND agent_id = ? AND archived = 0
@@ -1688,7 +1696,12 @@ class MemoryManager {
 
     for (const mem of structuredFacts.length ? [] : existing) {
       let sim = 0;
-      if (embedding && mem.embedding) {
+      if (
+        embedding
+        && mem.embedding
+        && mem.embedding_provider === embeddingResult?.provider
+        && mem.embedding_model === embeddingResult?.model
+      ) {
         const memVec = deserializeEmbedding(mem.embedding);
         if (memVec) sim = cosineSimilarity(embedding, memVec);
       } else {
@@ -1839,6 +1852,7 @@ class MemoryManager {
             conversationId: options.conversationId || null,
             runId: options.runId || null,
           },
+          signal: options.signal,
         },
       );
       if (memoryId) memoryIds.push(memoryId);
@@ -1860,9 +1874,18 @@ class MemoryManager {
     const route = routeMemoryQuery(query);
 
     const suppliedQueryEmbedding = options.queryEmbedding;
-    const queryVec = suppliedQueryEmbedding
-      ? new Float32Array(Array.from(suppliedQueryEmbedding, Number))
-      : await getEmbedding(query, await getActiveProvider(userId, agentId));
+    const queryEmbeddingResult = suppliedQueryEmbedding
+      ? {
+        vector: new Float32Array(Array.from(suppliedQueryEmbedding, Number)),
+        provider: options.queryEmbeddingProvider || null,
+        model: options.queryEmbeddingModel || null,
+      }
+      : await getEmbeddingWithMetadata(
+        query,
+        await getActiveProvider(userId, agentId, options),
+        { signal: options.signal, inputType: 'query' },
+      );
+    const queryVec = queryEmbeddingResult?.vector || null;
     const lexicalHits = this._searchMemoryFts(userId, agentId, query, Math.max(80, limit * 12));
     const entityHits = this._searchEntityMemoryIds(userId, agentId, query, Math.max(80, limit * 12));
     const vectorHits = queryVec
@@ -1870,6 +1893,8 @@ class MemoryManager {
         userId,
         agentId,
         embedding: queryVec,
+        embeddingProvider: queryEmbeddingResult?.provider,
+        embeddingModel: queryEmbeddingResult?.model,
         limit: Math.min(500, Math.max(300, limit * 20)),
       })
       : [];
@@ -1917,7 +1942,8 @@ class MemoryManager {
     let all = db.prepare(
       `SELECT id, category, content, summary, importance, confidence, embedding, access_count,
               memory_strength, last_accessed_at, pinned, created_at, updated_at,
-              scope_type, scope_id, source_type, source_id, source_label, stale_after_days, metadata_json
+              scope_type, scope_id, source_type, source_id, source_label, stale_after_days,
+              embedding_provider, embedding_model, metadata_json
        FROM memories
        WHERE id IN (${candidatePlaceholders})
          AND user_id = ? AND agent_id = ? AND archived = 0
@@ -1997,7 +2023,13 @@ class MemoryManager {
 
     const semanticScored = all.map(mem => {
       let semanticScore = 0;
-      if (queryVec && mem.embedding) {
+      const sameEmbeddingSpace = !queryEmbeddingResult?.provider
+        || !queryEmbeddingResult?.model
+        || (
+          mem.embedding_provider === queryEmbeddingResult.provider
+          && mem.embedding_model === queryEmbeddingResult.model
+        );
+      if (queryVec && mem.embedding && sameEmbeddingSpace) {
         const memVec = deserializeEmbedding(mem.embedding);
         if (memVec) {
           semanticScore = cosineSimilarity(queryVec, memVec);
@@ -2126,7 +2158,7 @@ class MemoryManager {
   /**
    * Update a memory's content and/or importance.
    */
-  async updateMemory(id, { content, importance, category }) {
+  async updateMemory(id, { content, importance, category, signal = null }) {
     const mem = db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id);
     if (!mem) return null;
 
@@ -2141,7 +2173,8 @@ class MemoryManager {
     if (content && content !== mem.content) {
       embeddingResult = await getEmbeddingWithMetadata(
         newContent,
-        await getActiveProvider(mem.user_id, mem.agent_id),
+        await getActiveProvider(mem.user_id, mem.agent_id, { signal }),
+        { signal, inputType: 'document' },
       );
       newEmbed = embeddingResult?.vector
         ? serializeEmbedding(embeddingResult.vector)

package/server/services/messaging/automation.js

@@ -20,17 +20,53 @@ const {
 } = require('../voice/runtime');
 const { getErrorMessage } = require('../bootstrap_helpers');
 const { processInboundQueue } = require('./inbound_queue');
+const { attachRunToInboundJobs } = require('./inbound_store');
 const { startTypingKeepalive } = require('./typing_keepalive');
+const { waitForBoundedResult } = require('../network/http');
+const { createAbortError, throwIfAborted } = require('../../utils/abort');
 
 function registerMessagingAutomation({ app, io, messagingManager, agentEngine }) {
   const userQueues = Object.create(null);
+  const activeHandlers = new Set();
+  const abortController = new AbortController();
+  const runtime = {
+    shuttingDown: false,
+    shutdownPromise: null,
+    shutdown() {
+      if (this.shutdownPromise) return this.shutdownPromise;
+      this.shuttingDown = true;
+      const error = new Error('Messaging automation is shutting down.');
+      error.name = 'AbortError';
+      error.code = 'MESSAGING_AUTOMATION_SHUTDOWN';
+      abortController.abort(error);
+      for (const queue of Object.values(userQueues)) {
+        queue.cancelRequested = true;
+        queue.cancelPending?.();
+      }
+      this.shutdownPromise = waitForBoundedResult(
+        Promise.allSettled(Array.from(activeHandlers)),
+        {
+          serviceName: 'Messaging automation',
+          timeoutMs: 10000,
+        },
+      ).then(() => ({ state: 'stopped', timedOut: false })).catch((error) => ({
+        state: 'timeout',
+        timedOut: error?.code === 'HTTP_TIMEOUT',
+        error: error?.message || String(error),
+      }));
+      return this.shutdownPromise;
+    },
+  };
   app.locals.userQueues = userQueues;
+  app.locals.messagingAutomationRuntime = runtime;
 
-  messagingManager.registerHandler(async (userId, msg) => {
+  const handleMessage = async (userId, msg, signal) => {
+    throwIfAborted(signal, 'Messaging automation stopped before handling the message.');
     const agentId = msg.agentId || null;
     if (!(await isAllowedMessagingSender({ io, userId, msg }))) {
       return;
     }
+    throwIfAborted(signal, 'Messaging automation stopped before handling the message.');
 
     const commandRouter = app?.locals?.commandRouter;
     if (commandRouter) {
@@ -42,9 +78,11 @@ function registerMessagingAutomation({ app, io, messagingManager, agentEngine })
           source: 'messaging',
           platform: msg.platform,
           chatId: msg.chatId,
-          sender: msg.sender
+          sender: msg.sender,
+          signal,
         });
       } catch (err) {
+        if (signal?.aborted) throw createAbortError(signal);
         console.error(`[Messaging] Command dispatch failed on ${msg.platform}:`, err.message);
         io.to(`user:${userId}`).emit('messaging:error', {
           error: `Command dispatch failed on ${msg.platform}: ${err.message}`
@@ -55,9 +93,10 @@ function registerMessagingAutomation({ app, io, messagingManager, agentEngine })
             msg.platform,
             msg.chatId,
             `Command handling failed: ${err.message}`,
-            { runId: null, agentId }
+            { runId: null, agentId, signal }
           );
         } catch (sendErr) {
+          if (signal?.aborted) throw createAbortError(signal);
           console.error(`[Messaging] Failed to report command dispatch error on ${msg.platform}:`, sendErr.message);
           io.to(`user:${userId}`).emit('messaging:error', {
             error: `Command handling failed and the error report could not be sent on ${msg.platform}: ${sendErr.message}`
@@ -78,9 +117,10 @@ function registerMessagingAutomation({ app, io, messagingManager, agentEngine })
             msg.platform,
             msg.chatId,
             commandResult.content || 'Done.',
-            { runId: null, agentId }
+            { runId: null, agentId, signal }
           );
         } catch (err) {
+          if (signal?.aborted) throw createAbortError(signal);
           console.error(`[Messaging] Failed to send command response on ${msg.platform}:`, err.message);
           io.to(`user:${userId}`).emit('messaging:error', {
             error: `Command executed but response could not be sent on ${msg.platform}: ${err.message}`
@@ -98,12 +138,13 @@ function registerMessagingAutomation({ app, io, messagingManager, agentEngine })
     upsertSetting.run(userId, agentId, 'last_platform', msg.platform);
     upsertSetting.run(userId, agentId, 'last_chat_id', msg.chatId);
 
-    await processQueuedMessage({
+    return processQueuedMessage({
       userQueues,
       messagingManager,
       agentEngine,
       userId,
       msg,
+      signal,
       onProcessingError: ({ error, runId, failedMessage }) => {
         const errorMessage = getErrorMessage(error);
         console.error(
@@ -118,7 +159,23 @@ function registerMessagingAutomation({ app, io, messagingManager, agentEngine })
         });
       }
     });
+  };
+  messagingManager.registerHandler((userId, msg) => {
+    if (runtime.shuttingDown) return null;
+    const promise = handleMessage(userId, msg, abortController.signal);
+    activeHandlers.add(promise);
+    const cleanup = () => activeHandlers.delete(promise);
+    promise.then(cleanup, cleanup);
+    return promise;
   });
+  if (typeof messagingManager.recoverPendingInbound === 'function') {
+    void messagingManager.recoverPendingInbound().catch((error) => {
+      if (!runtime.shuttingDown) {
+        console.error('[MessagingAutomation] Inbound recovery failed:', getErrorMessage(error));
+      }
+    });
+  }
+  return runtime;
 }
 
 async function processQueuedMessage({
@@ -127,6 +184,7 @@ async function processQueuedMessage({
   agentEngine,
   userId,
   msg,
+  signal = null,
   onProcessingError = null
 }) {
   return processInboundQueue({
@@ -138,7 +196,8 @@ async function processQueuedMessage({
         messagingManager,
         agentEngine,
         userId,
-        msg: queuedMessage
+        msg: queuedMessage,
+        signal,
       }),
     onProcessingError
   });
@@ -148,10 +207,17 @@ async function executeQueuedMessage({
   messagingManager,
   agentEngine,
   userId,
-  msg
+  msg,
+  signal = null,
 }) {
+  throwIfAborted(signal, 'Messaging request aborted before execution.');
   const agentId = msg.agentId || null;
   const runId = randomUUID();
+  const inboundJobIds = Array.from(new Set([
+    ...(Array.isArray(msg.inboundJobIds) ? msg.inboundJobIds : []),
+    msg.inboundJobId,
+  ].map((value) => String(value || '').trim()).filter(Boolean)));
+  if (inboundJobIds.length) attachRunToInboundJobs(inboundJobIds, runId);
   const reportSideEffectError = (operation, error) => {
     console.warn(
       `[MessagingAutomation] ${operation} failed platform=${msg.platform} user=${userId}:`,
@@ -165,7 +231,7 @@ async function executeQueuedMessage({
       msg.platform,
       msg.chatId,
       msg.messageId,
-      { agentId }
+      { agentId, signal }
     );
   } catch (error) {
     reportSideEffectError('mark read', error);
@@ -178,6 +244,7 @@ async function executeQueuedMessage({
     runId,
     platform: msg.platform,
     chatId: msg.chatId,
+    signal,
     onError: reportSideEffectError
   });
 
@@ -199,6 +266,7 @@ async function executeQueuedMessage({
           conversationId,
           source: msg.platform,
           chatId: msg.chatId,
+          messagingInboundJobId: inboundJobIds[0] || null,
           context: { rawUserMessage: msg.content }
         };
 
@@ -208,10 +276,17 @@ async function executeQueuedMessage({
       ];
     }
 
+    runOptions.messagingInboundJobId = inboundJobIds[0] || null;
+    runOptions.signal = signal;
+
     const result = await agentEngine.run(userId, prompt, runOptions);
     return { runId, result, error: null };
   } catch (error) {
-    return { runId, result: null, error };
+    return {
+      runId,
+      result: null,
+      error: signal?.aborted ? createAbortError(signal) : error,
+    };
   } finally {
     await stopTypingKeepalive();
   }

package/server/services/messaging/http_platforms.js

@@ -4,6 +4,7 @@ const crypto = require('crypto');
 const net = require('net');
 const tls = require('tls');
 const { BasePlatform } = require('./base');
+const { fetchResponseText } = require('../network/http');
 
 function requireText(value, label) {
   const text = String(value || '').trim();
@@ -51,14 +52,18 @@ function parseHeaders(value) {
 }
 
 async function fetchJson(url, options = {}, serviceName = 'Messaging platform') {
-  const response = await fetch(url, {
+  const { response, text } = await fetchResponseText(url, {
     ...options,
     headers: {
       ...(options.body == null ? {} : { 'content-type': 'application/json' }),
       ...(options.headers || {}),
     },
+    maxResponseBytes: Number(options.maxResponseBytes) > 0
+      ? Number(options.maxResponseBytes)
+      : 2 * 1024 * 1024,
+    serviceName,
+    timeoutMs: Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : 15000,
   });
-  const text = await response.text();
   let body = null;
   if (text) {
     try { body = JSON.parse(text); } catch { body = text; }
@@ -71,7 +76,13 @@ async function fetchJson(url, options = {}, serviceName = 'Messaging platform')
       .replace(/https?:\/\/[^\s"'<>]+/gi, '[redacted-url]')
       .replace(/\b(token|access_token|refresh_token|authorization)\b\s*[:=]\s*"[^"]*"/gi, '$1=[redacted]')
       .replace(/\b(token|access_token|refresh_token|authorization)\b\s*[:=]\s*[^,\s;"'}\]]+/gi, '$1=[redacted]');
-    throw new Error(`${serviceName} request failed (${response.status}): ${detail || response.statusText}`);
+    const error = new Error(
+      `${serviceName} request failed (${response.status}): ${detail || response.statusText}`,
+    );
+    error.status = response.status;
+    error.headers = response.headers;
+    error.safeToRetry = response.status === 429;
+    throw error;
   }
   return body;
 }
@@ -173,7 +184,7 @@ class ConfigurableHttpPlatform extends BasePlatform {
     };
   }
 
-  async sendMessage(to, content) {
+  async sendMessage(to, content, options = {}) {
     const urlTemplate = this.config.outboundUrl || this.config.webhookUrl || this.defaults.outboundUrl || this.defaults.webhookUrl;
     if (!urlTemplate) throw new Error(`${this.defaults.label || this.name} outbound URL is not configured`);
 
@@ -209,6 +220,7 @@ class ConfigurableHttpPlatform extends BasePlatform {
       method: this.config.method || this.defaults.method || 'POST',
       headers,
       body: JSON.stringify(body),
+      signal: options.signal,
     }, this.defaults.label || this.name);
     return { success: true };
   }
@@ -284,12 +296,13 @@ class SlackPlatform extends BasePlatform {
     return this._botUserId ? { username: this._botUserId } : null;
   }
 
-  async sendMessage(to, content) {
+  async sendMessage(to, content, options = {}) {
     if (!this.botToken) throw new Error('Slack bot token is required for outbound messages');
     const result = await fetchJson('https://slack.com/api/chat.postMessage', {
       method: 'POST',
       headers: { Authorization: `Bearer ${this.botToken}` },
       body: JSON.stringify({ channel: to, text: content }),
+      signal: options.signal,
     }, 'Slack');
     if (result && result.ok === false) throw new Error(`Slack post failed: ${result.error || 'unknown error'}`);
     return { success: true, ts: result?.ts };
@@ -593,12 +606,13 @@ class MatrixPlatform extends BasePlatform {
     }
   }
 
-  async sendMessage(to, content) {
+  async sendMessage(to, content, options = {}) {
     if (this.status !== 'connected') throw new Error('Matrix not connected');
     const txnId = encodeURIComponent(crypto.randomUUID());
     await this.#matrix(`/rooms/${encodeURIComponent(to)}/send/m.room.message/${txnId}`, {
       method: 'PUT',
       body: JSON.stringify({ msgtype: 'm.text', body: content }),
+      signal: options.signal,
     });
     return { success: true };
   }
@@ -618,9 +632,9 @@ class BlueBubblesPlatform extends ConfigurableHttpPlatform {
     return { status: 'connected' };
   }
 
-  async sendMessage(to, content) {
+  async sendMessage(to, content, options = {}) {
     if (this.config.outboundUrl || this.config.webhookUrl) {
-      return super.sendMessage(to, content);
+      return super.sendMessage(to, content, options);
     }
     const url = new URL(`${this.serverUrl}${this.config.sendPath || '/api/v1/message/text'}`);
     url.searchParams.set('guid', to);
@@ -629,6 +643,7 @@ class BlueBubblesPlatform extends ConfigurableHttpPlatform {
     await fetchJson(url.toString(), {
       method: 'POST',
       body: JSON.stringify({ message: content }),
+      signal: options.signal,
     }, this.defaults.label);
     return { success: true };
   }
@@ -713,9 +728,9 @@ class SignalPlatform extends ConfigurableHttpPlatform {
     }
   }
 
-  async sendMessage(to, content) {
+  async sendMessage(to, content, options = {}) {
     if (this.config.outboundUrl || this.config.webhookUrl) {
-      return super.sendMessage(to, content);
+      return super.sendMessage(to, content, options);
     }
     await fetchJson(`${this.restUrl}/v2/send`, {
       method: 'POST',
@@ -724,6 +739,7 @@ class SignalPlatform extends ConfigurableHttpPlatform {
         number: this.account,
         recipients: [to],
       }),
+      signal: options.signal,
     }, 'Signal');
     return { success: true };
   }
@@ -743,7 +759,7 @@ class LinePlatform extends ConfigurableHttpPlatform {
     return { status: 'connected' };
   }
 
-  async sendMessage(to, content) {
+  async sendMessage(to, content, options = {}) {
     const token = requireText(this.config.channelAccessToken || this.config.token, 'LINE channel access token');
     await fetchJson('https://api.line.me/v2/bot/message/push', {
       method: 'POST',
@@ -752,6 +768,7 @@ class LinePlatform extends ConfigurableHttpPlatform {
         to,
         messages: [{ type: 'text', text: content }],
       }),
+      signal: options.signal,
     }, 'LINE');
     return { success: true };
   }
@@ -815,14 +832,17 @@ class MattermostPlatform extends ConfigurableHttpPlatform {
     return { status: 'connected' };
   }
 
-  async sendMessage(to, content) {
-    if (this.config.webhookUrl || this.config.outboundUrl) return super.sendMessage(to, content);
+  async sendMessage(to, content, options = {}) {
+    if (this.config.webhookUrl || this.config.outboundUrl) {
+      return super.sendMessage(to, content, options);
+    }
     const baseUrl = trimTrailingSlash(this.config.baseUrl);
     const token = requireText(this.config.token, 'Mattermost token');
     await fetchJson(`${baseUrl}/api/v4/posts`, {
       method: 'POST',
       headers: { Authorization: `Bearer ${token}` },
       body: JSON.stringify({ channel_id: to, message: content }),
+      signal: options.signal,
     }, 'Mattermost');
     return { success: true };
   }