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

package/server/services/manager.js

@@ -566,7 +566,27 @@ async function stopServices(app) {
       console.error('[ApprovalGate] Shutdown error:', getErrorMessage(err));
     }
   }
-  if (app.locals.agentEngine && typeof app.locals.agentEngine.interruptAllActiveRuns === 'function') {
+  if (app.locals.agentEngine && typeof app.locals.agentEngine.shutdown === 'function') {
+    try {
+      tasks.push(
+        app.locals.agentEngine.shutdown().then((status) => {
+          if (status.timedOut) {
+            console.warn(
+              `[AgentEngine] Shutdown timed out with ${status.pendingCount} operation(s) still settling`,
+            );
+          } else {
+            logServiceReady('Agent engine shutdown complete');
+          }
+        }),
+      );
+      logServiceReady('Active runs and background work marked interrupted');
+    } catch (err) {
+      console.error('[AgentEngine] Shutdown error:', getErrorMessage(err));
+    }
+  } else if (
+    app.locals.agentEngine
+    && typeof app.locals.agentEngine.interruptAllActiveRuns === 'function'
+  ) {
     try {
       app.locals.agentEngine.interruptAllActiveRuns();
       logServiceReady('Active runs marked interrupted');
@@ -595,6 +615,23 @@ async function stopServices(app) {
     );
   }
 
+  if (app.locals.messagingAutomationRuntime) {
+    tasks.push(
+      Promise.resolve()
+        .then(() => app.locals.messagingAutomationRuntime.shutdown())
+        .then((status) => {
+          if (status.timedOut) {
+            console.warn('[MessagingAutomation] Shutdown timed out while work was settling');
+          } else {
+            logServiceReady('Messaging automation shutdown complete');
+          }
+        })
+        .catch((err) => {
+          console.error('[MessagingAutomation] Shutdown error:', getErrorMessage(err));
+        }),
+    );
+  }
+
   if (app.locals.streamHub) {
     try {
       await app.locals.streamHub.shutdown();
@@ -617,6 +654,22 @@ async function stopServices(app) {
     );
   }
 
+  if (
+    app.locals.integrationManager &&
+    typeof app.locals.integrationManager.shutdown === 'function'
+  ) {
+    tasks.push(
+      Promise.resolve()
+        .then(() => app.locals.integrationManager.shutdown())
+        .then((status) => {
+          logServiceReady(`Official integrations shutdown complete (${status.state})`);
+        })
+        .catch((err) => {
+          console.error('[Integrations] Shutdown error:', getErrorMessage(err));
+        }),
+    );
+  }
+
   if (app.locals.mcpClient) {
     tasks.push(
       app.locals.mcpClient.shutdown().catch((err) => {
@@ -641,6 +694,22 @@ async function stopServices(app) {
     );
   }
 
+  if (app.locals.browserExtensionGateway?.close) {
+    tasks.push(
+      app.locals.browserExtensionGateway.close().catch((err) => {
+        console.error('[BrowserExtensionGateway] Shutdown error:', getErrorMessage(err));
+      }),
+    );
+  }
+
+  if (app.locals.desktopCompanionGateway?.close) {
+    tasks.push(
+      app.locals.desktopCompanionGateway.close().catch((err) => {
+        console.error('[DesktopCompanionGateway] Shutdown error:', getErrorMessage(err));
+      }),
+    );
+  }
+
   if (app.locals.browserControllers instanceof Map) {
     for (const controller of app.locals.browserControllers.values()) {
       tasks.push(
@@ -659,6 +728,23 @@ async function stopServices(app) {
     );
   }
 
+  if (
+    app.locals.voiceRuntimeManager
+    && typeof app.locals.voiceRuntimeManager.shutdown === 'function'
+  ) {
+    tasks.push(
+      app.locals.voiceRuntimeManager.shutdown().then((status) => {
+        if (status.timedOut) {
+          console.warn('[VoiceRuntime] Shutdown timed out while sessions were closing');
+        } else {
+          logServiceReady('Voice runtime shutdown complete');
+        }
+      }).catch((err) => {
+        console.error('[VoiceRuntime] Shutdown error:', getErrorMessage(err));
+      }),
+    );
+  }
+
   if (app.locals.runtimeManager) {
     tasks.push(
       app.locals.runtimeManager.shutdown().catch((err) => {

package/server/services/memory/embedding_index.js

@@ -95,6 +95,8 @@ function findEmbeddingCandidates(db, {
   userId,
   agentId,
   embedding,
+  embeddingProvider = null,
+  embeddingModel = null,
   limit = DEFAULT_CANDIDATE_LIMIT,
 }) {
   const vector = typeof embedding === 'string'
@@ -104,17 +106,25 @@ function findEmbeddingCandidates(db, {
   if (!probesByBand.length) return [];
 
   const matches = new Map();
+  const embeddingSpace = embeddingProvider && embeddingModel
+    ? `${embeddingProvider}:${embeddingModel}`
+    : '';
   for (const band of probesByBand) {
     const placeholders = band.values.map(() => '?').join(', ');
     const rows = db.prepare(
-      `SELECT memory_id
-       FROM memory_embedding_bands
-       WHERE user_id = ?
-         AND agent_id = ?
-         AND dimension = ?
-         AND index_version = ?
-         AND band_index = ?
-         AND band_value IN (${placeholders})`
+      `SELECT bands.memory_id
+       FROM memory_embedding_bands bands
+       JOIN memories memory ON memory.id = bands.memory_id
+       WHERE bands.user_id = ?
+         AND bands.agent_id = ?
+         AND bands.dimension = ?
+         AND bands.index_version = ?
+         AND bands.band_index = ?
+         AND bands.band_value IN (${placeholders})
+         AND (
+           ? = ''
+           OR (memory.embedding_provider || ':' || memory.embedding_model) = ?
+         )`
     ).all(
       userId,
       agentId || '',
@@ -122,6 +132,8 @@ function findEmbeddingCandidates(db, {
       INDEX_VERSION,
       band.bandIndex,
       ...band.values,
+      embeddingSpace,
+      embeddingSpace,
     );
     for (const row of rows) {
       matches.set(row.memory_id, (matches.get(row.memory_id) || 0) + 1);

package/server/services/memory/embeddings.js

@@ -4,134 +4,192 @@
  * Embedding helpers for the semantic memory system.
  *
  * Provider selection (in priority order):
- *   1. Google (text-embedding-004, 768 dims) — when provider hint is 'google' and GOOGLE_AI_KEY is set
+ *   1. Google (gemini-embedding-2, 768 dims) — when provider hint is 'google' and GOOGLE_AI_KEY is set
  *   2. OpenAI (text-embedding-3-small, 1536 dims) — when OPENAI_API_KEY is set
  *   3. Keyword fallback — when no API key is available
  */
 
 const https = require('https');
+const {
+  createAbortError,
+  isAbortError,
+  throwIfAborted,
+} = require('../../utils/abort');
 
 const OPENAI_MODEL = 'text-embedding-3-small';
 const OPENAI_DIM = 1536;
-const GOOGLE_MODEL = 'text-embedding-004';
+const GOOGLE_MODEL = 'gemini-embedding-2';
 const GOOGLE_DIM = 768;
+const EMBEDDING_TIMEOUT_MS = 15000;
+const MAX_EMBEDDING_RESPONSE_BYTES = 2 * 1024 * 1024;
 
 // Exported so callers can sanity-check stored vector dimensions if needed
 const EMBED_DIM = OPENAI_DIM;
 const EMBED_DIM_GOOGLE = GOOGLE_DIM;
 
-async function getGeminiEmbedding(text) {
-  const apiKey = process.env.GOOGLE_AI_KEY;
-  if (!apiKey) return null;
-  if (!text || !text.trim()) return null;
-
-  const truncated = text.slice(0, 25000);
+function toEmbeddingVector(value, expectedDimensions) {
+  if (!Array.isArray(value) || value.length !== expectedDimensions) return null;
+  const vector = new Float32Array(value.length);
+  for (let index = 0; index < value.length; index += 1) {
+    const number = Number(value[index]);
+    if (!Number.isFinite(number)) return null;
+    vector[index] = number;
+  }
+  return vector;
+}
 
-  return new Promise((resolve) => {
+function requestEmbeddingJson({ hostname, path, headers, body, signal }) {
+  throwIfAborted(signal, 'Embedding request aborted.');
+  return new Promise((resolve, reject) => {
     let settled = false;
-    const done = (value) => {
+    let request = null;
+    let response = null;
+    let timer = null;
+
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+    };
+    const finish = (error, value = null) => {
       if (settled) return;
       settled = true;
-      resolve(value);
+      cleanup();
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const onAbort = () => {
+      const error = createAbortError(signal, 'Embedding request aborted.');
+      response?.destroy(error);
+      request?.destroy(error);
+      finish(error);
     };
+    signal?.addEventListener('abort', onAbort, { once: true });
 
-    const body = JSON.stringify({
-      model: `models/${GOOGLE_MODEL}`,
-      content: { parts: [{ text: truncated }] }
-    });
+    timer = setTimeout(() => {
+      request?.destroy();
+      response?.destroy();
+      finish(null, null);
+    }, EMBEDDING_TIMEOUT_MS);
 
-    const path = `/v1beta/models/${GOOGLE_MODEL}:embedContent?key=${apiKey}`;
-    const options = {
-      hostname: 'generativelanguage.googleapis.com',
+    request = https.request({
+      hostname,
       path,
       method: 'POST',
       headers: {
+        ...headers,
         'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(body)
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (incoming) => {
+      response = incoming;
+      if (settled) {
+        incoming.destroy();
+        return;
+      }
+      if (incoming.statusCode < 200 || incoming.statusCode >= 300) {
+        incoming.destroy();
+        finish(null, null);
+        return;
+      }
+      const contentLength = Number(incoming.headers?.['content-length']);
+      if (
+        Number.isFinite(contentLength)
+        && contentLength > MAX_EMBEDDING_RESPONSE_BYTES
+      ) {
+        incoming.destroy();
+        finish(null, null);
+        return;
       }
-    };
 
-    const req = https.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => { data += chunk; });
-      res.on('end', () => {
+      const chunks = [];
+      let totalBytes = 0;
+      incoming.on('data', (chunk) => {
+        if (settled) return;
+        const buffer = Buffer.from(chunk);
+        totalBytes += buffer.byteLength;
+        if (totalBytes > MAX_EMBEDDING_RESPONSE_BYTES) {
+          incoming.destroy();
+          finish(null, null);
+          return;
+        }
+        chunks.push(buffer);
+      });
+      incoming.on('end', () => {
+        if (settled) return;
         try {
-          const parsed = JSON.parse(data);
-          const vec = parsed.embedding?.values;
-          if (!vec) return done(null);
-          done(new Float32Array(vec));
+          finish(null, JSON.parse(Buffer.concat(chunks, totalBytes).toString('utf8')));
         } catch {
-          done(null);
+          finish(null, null);
         }
       });
+      incoming.on('error', (error) => {
+        if (isAbortError(error, signal)) finish(createAbortError(signal));
+        else finish(null, null);
+      });
+      incoming.on('aborted', () => {
+        if (signal?.aborted) finish(createAbortError(signal));
+        else finish(null, null);
+      });
     });
 
-    req.on('error', () => done(null));
-    req.setTimeout(15000, () => {
-      req.destroy();
-      done(null);
+    request.on('error', (error) => {
+      if (isAbortError(error, signal)) finish(createAbortError(signal));
+      else finish(null, null);
     });
-    req.write(body);
-    req.end();
+    request.end(body);
   });
 }
 
-async function getOpenAIEmbedding(text) {
-  const apiKey = process.env.OPENAI_API_KEY;
+function formatGoogleEmbeddingInput(text, inputType) {
+  if (inputType === 'query') return `task: search result | query: ${text}`;
+  if (inputType === 'document') return `title: none | text: ${text}`;
+  return `task: sentence similarity | query: ${text}`;
+}
+
+async function getGeminiEmbedding(text, options = {}) {
+  const apiKey = process.env.GOOGLE_AI_KEY;
   if (!apiKey) return null;
   if (!text || !text.trim()) return null;
 
-  const truncated = text.slice(0, 25000);
-
-  return new Promise((resolve) => {
-    let settled = false;
-    const done = (value) => {
-      if (settled) return;
-      settled = true;
-      resolve(value);
-    };
-
-    const body = JSON.stringify({
-      model: OPENAI_MODEL,
-      input: truncated,
-      encoding_format: 'float'
-    });
+  const truncated = formatGoogleEmbeddingInput(
+    text.slice(0, 25000),
+    options.inputType,
+  );
+  const body = JSON.stringify({
+    model: `models/${GOOGLE_MODEL}`,
+    content: { parts: [{ text: truncated }] },
+    output_dimensionality: GOOGLE_DIM,
+  });
+  const data = await requestEmbeddingJson({
+    hostname: 'generativelanguage.googleapis.com',
+    path: `/v1beta/models/${GOOGLE_MODEL}:embedContent`,
+    headers: { 'x-goog-api-key': apiKey },
+    body,
+    signal: options.signal,
+  });
+  return toEmbeddingVector(data?.embedding?.values, GOOGLE_DIM);
+}
 
-    const options = {
-      hostname: 'api.openai.com',
-      path: '/v1/embeddings',
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(body)
-      }
-    };
+async function getOpenAIEmbedding(text, options = {}) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) return null;
+  if (!text || !text.trim()) return null;
 
-    const req = https.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => { data += chunk; });
-      res.on('end', () => {
-        try {
-          const parsed = JSON.parse(data);
-          if (parsed.error) return done(null);
-          const vec = parsed.data?.[0]?.embedding;
-          if (!vec) return done(null);
-          done(new Float32Array(vec));
-        } catch {
-          done(null);
-        }
-      });
-    });
+  const truncated = text.slice(0, 25000);
 
-    req.on('error', () => done(null));
-    req.setTimeout(15000, () => {
-      req.destroy();
-      done(null);
-    });
-    req.write(body);
-    req.end();
+  const body = JSON.stringify({
+    model: OPENAI_MODEL,
+    input: truncated,
+    encoding_format: 'float',
+  });
+  const data = await requestEmbeddingJson({
+    hostname: 'api.openai.com',
+    path: '/v1/embeddings',
+    headers: { Authorization: `Bearer ${apiKey}` },
+    body,
+    signal: options.signal,
   });
+  return toEmbeddingVector(data?.data?.[0]?.embedding, OPENAI_DIM);
 }
 
 /**
@@ -140,15 +198,16 @@ async function getOpenAIEmbedding(text) {
  * @param {string} [provider] - 'google' to prefer Gemini embeddings
  * @returns {Float32Array|null}
  */
-async function getEmbedding(text, provider) {
-  const result = await getEmbeddingWithMetadata(text, provider);
+async function getEmbedding(text, provider, options = {}) {
+  const result = await getEmbeddingWithMetadata(text, provider, options);
   return result?.vector || null;
 }
 
-async function getEmbeddingWithMetadata(text, provider) {
+async function getEmbeddingWithMetadata(text, provider, options = {}) {
   if (!text || !text.trim()) return null;
+  throwIfAborted(options.signal, 'Embedding request aborted.');
   if (provider === 'google' && process.env.GOOGLE_AI_KEY) {
-    const vec = await getGeminiEmbedding(text);
+    const vec = await getGeminiEmbedding(text, options);
     if (vec) {
       return {
         vector: vec,
@@ -158,7 +217,7 @@ async function getEmbeddingWithMetadata(text, provider) {
       };
     }
   }
-  const vec = await getOpenAIEmbedding(text);
+  const vec = await getOpenAIEmbedding(text, options);
   if (!vec) return null;
   return {
     vector: vec,
@@ -228,5 +287,7 @@ module.exports = {
   deserializeEmbedding,
   keywordSimilarity,
   EMBED_DIM,
-  EMBED_DIM_GOOGLE
+  EMBED_DIM_GOOGLE,
+  GOOGLE_MODEL,
+  OPENAI_MODEL,
 };

package/server/services/memory/ingestion.js

@@ -4,6 +4,11 @@ const { v4: uuidv4 } = require('uuid');
 const db = require('../../db/database');
 const { resolveAgentId } = require('../agents/manager');
 const { getErrorMessage } = require('../bootstrap_helpers');
+const {
+  createLinkedAbortController,
+  isAbortError,
+  throwIfAborted,
+} = require('../../utils/abort');
 const { ingestDocuments } = require('./ingestion_documents');
 const {
   decorateProviderSnapshot,
@@ -39,6 +44,7 @@ class MemoryIngestionService {
     this.setInterval = setIntervalFn;
     this.clearInterval = clearIntervalFn;
     this.timer = null;
+    this.abortController = new AbortController();
     this.activeBatches = new Map();
     this.activeConnections = new Map();
     this.stopping = false;
@@ -67,6 +73,9 @@ class MemoryIngestionService {
       throw new Error('Memory ingestion cannot start while shutdown is in progress.');
     }
 
+    if (this.abortController.signal.aborted) {
+      this.abortController = new AbortController();
+    }
     this.stopping = false;
     this.state = 'running';
     this.lastError = null;
@@ -82,6 +91,7 @@ class MemoryIngestionService {
     try {
       await this.refreshDueConnections();
     } catch (err) {
+      if (isAbortError(err, this.abortController.signal) && this.stopping) return;
       this.lastError = getErrorMessage(err);
       console.warn('[MemoryIngestion] Background refresh failed:', this.lastError);
     }
@@ -91,6 +101,7 @@ class MemoryIngestionService {
     if (this.stopPromise) return this.stopPromise;
     this.stopping = true;
     this.state = 'stopping';
+    this.abortController.abort('Memory ingestion service is stopping.');
     if (this.timer) this.clearInterval(this.timer);
     this.timer = null;
 
@@ -111,13 +122,27 @@ class MemoryIngestionService {
   }
 
   async ingestDocuments(userId, documents = [], options = {}) {
-    return ingestDocuments(this, userId, documents, options);
+    const linked = createLinkedAbortController([
+      this.abortController.signal,
+      options.signal,
+    ]);
+    try {
+      return await ingestDocuments(this, userId, documents, {
+        ...options,
+        signal: linked.signal,
+      });
+    } finally {
+      linked.cleanup();
+    }
   }
 
   refreshDueConnections(userId = null) {
     const scopeKey = userId == null ? 'all' : `user:${userId}`;
-    if (this.stopping) {
-      return Promise.resolve({ skipped: true, reason: 'service_stopping' });
+    if (this.stopping || this.abortController.signal.aborted) {
+      return Promise.resolve({
+        skipped: true,
+        reason: this.stopping ? 'service_stopping' : 'service_stopped',
+      });
     }
     const active = this.activeBatches.get(scopeKey);
     if (active) return active;
@@ -132,6 +157,7 @@ class MemoryIngestionService {
   }
 
   async _refreshDueConnections(userId = null) {
+    const signal = this.abortController.signal;
     this.lastRunAt = new Date().toISOString();
     try {
       const params = [];
@@ -145,8 +171,8 @@ class MemoryIngestionService {
       const connections = this.db.prepare(sql).all(...params);
       const results = [];
       for (const connection of connections) {
-        if (this.stopping) break;
-        results.push(await this._refreshConnectionSafely(connection));
+        if (this.stopping || signal.aborted) break;
+        results.push(await this._refreshConnectionSafely(connection, { signal }));
       }
       if (!results.some((result) => result?.status === 'failed')) {
         this.lastError = null;
@@ -154,19 +180,28 @@ class MemoryIngestionService {
       this.lastCompletedAt = new Date().toISOString();
       return { refreshed: results.length, results };
     } catch (err) {
+      if (isAbortError(err, signal) && this.stopping) {
+        return { refreshed: 0, results: [], cancelled: true };
+      }
       this.lastError = getErrorMessage(err);
       throw err;
     }
   }
 
-  _refreshConnectionSafely(connection) {
+  _refreshConnectionSafely(connection, options = {}) {
     const connectionKey = `${connection.user_id}:${connection.id}`;
     const active = this.activeConnections.get(connectionKey);
     if (active) return active;
 
     const promise = Promise.resolve()
-      .then(() => this.refreshConnection(connection))
+      .then(() => this.refreshConnection(connection, options))
       .catch((err) => {
+        if (isAbortError(err, options.signal) && this.stopping) {
+          return {
+            connectionId: connection.id,
+            status: 'cancelled',
+          };
+        }
         const error = getErrorMessage(err);
         this.lastError = error;
         console.warn(
@@ -214,7 +249,9 @@ class MemoryIngestionService {
     }
   }
 
-  async refreshConnection(connection) {
+  async refreshConnection(connection, options = {}) {
+    const signal = options.signal || this.abortController.signal;
+    throwIfAborted(signal, 'Memory ingestion refresh aborted.');
     const sourceTypes = sourceTypesForConnection(connection.provider_key, connection.app_key);
     if (sourceTypes.length === 0) {
       return { connectionId: connection.id, status: 'not_supported' };
@@ -242,9 +279,12 @@ class MemoryIngestionService {
           connection,
           sourceTypes,
           cursor: latestJob?.cursor || {},
+          signal,
         });
       } catch (err) {
-        this._recordCollectorFailure(connection, primarySource, policy, agentId, err);
+        if (!isAbortError(err, signal)) {
+          this._recordCollectorFailure(connection, primarySource, policy, agentId, err);
+        }
         throw err;
       }
       return this.ingestDocuments(connection.user_id, collected.documents || [], {
@@ -258,6 +298,7 @@ class MemoryIngestionService {
           sourceTypes,
           cursor: collected.cursor || null,
         },
+        signal,
       });
     }