neoagent 3.2.1-beta.1 → 3.2.1-beta.10

package/server/services/manager.js

@@ -34,6 +34,8 @@ const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
 const { TimelineService } = require('./timeline/service');
 const { WearableService } = require('./wearable/service');
+const { BitwardenCli } = require('./credentials/bitwarden_cli');
+const { CredentialBroker } = require('./credentials/broker');
 const { getRuntimeValidation } = require('./runtime/validation');
 const {
   getErrorMessage,
@@ -142,6 +144,17 @@ function createIntegrationManager(app) {
   return integrationManager;
 }
 
+function createCredentialBroker(app) {
+  const bitwardenCli = registerLocal(app, 'bitwardenCli', new BitwardenCli());
+  const credentialBroker = registerLocal(
+    app,
+    'credentialBroker',
+    new CredentialBroker({ bitwarden: bitwardenCli }),
+  );
+  logServiceReady('Credential broker ready');
+  return credentialBroker;
+}
+
 function createMemoryIngestionService(app, { memoryManager, integrationManager }) {
   const memoryIngestionService = registerLocal(
     app,
@@ -469,10 +482,12 @@ async function startServices(app, io) {
     const memoryManager = createMemoryManager(app);
     const mcpClient = createMcpClient(app);
     createAuthProviderManager(app);
+    const credentialBroker = createCredentialBroker(app);
     const integrationManager = createIntegrationManager(app);
     createMemoryIngestionService(app, { memoryManager, integrationManager });
     const browserController = createBrowserController(app, artifactStore);
     const runtimeManager = createRuntimeManager(app);
+    credentialBroker.setRuntimeManager(runtimeManager);
     const runtimeValidation = getRuntimeValidation(runtimeManager);
     registerLocal(app, 'runtimeValidation', runtimeValidation);
     if (!runtimeValidation.ready) {
@@ -566,7 +581,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 +630,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 +669,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 +709,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 +743,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) => {
@@ -667,6 +768,14 @@ async function stopServices(app) {
     );
   }
 
+  if (app.locals.bitwardenCli) {
+    tasks.push(
+      app.locals.bitwardenCli.shutdown().catch((err) => {
+        console.error('[Bitwarden] Shutdown error:', getErrorMessage(err));
+      }),
+    );
+  }
+
   if (app.locals.widgetService) {
     const widgetService = app.locals.widgetService;
     const cleanupMethod = ['shutdown', 'close', 'stop', 'dispose'].find(

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,
 };