neoagent 3.2.1-beta.0 → 3.2.1-beta.10

package/server/services/voice/runtimeManager.js

@@ -16,6 +16,15 @@ const {
   sanitizeSpeechText,
 } = require('./providers');
 const { VoiceAgentBridge } = require('./agentBridge');
+const { waitForBoundedResult } = require('../network/http');
+const { createAbortError, throwIfAborted } = require('../../utils/abort');
+
+function voiceRuntimeStoppedError() {
+  const error = new Error('Voice runtime is shutting down.');
+  error.name = 'AbortError';
+  error.code = 'VOICE_RUNTIME_SHUTDOWN';
+  return error;
+}
 
 class VoiceRuntimeManager {
   constructor({ io, agentEngine, memoryManager }) {
@@ -23,6 +32,8 @@ class VoiceRuntimeManager {
     this.agentEngine = agentEngine;
     this.memoryManager = memoryManager;
     this.sessions = new Map();
+    this.shuttingDown = false;
+    this.shutdownPromise = null;
     this.agentBridge = new VoiceAgentBridge({
       agentEngine,
       memoryManager,
@@ -34,6 +45,10 @@ class VoiceRuntimeManager {
     return this.sessions.get(String(sessionId || '').trim()) || null;
   }
 
+  #assertRunning() {
+    if (this.shuttingDown) throw voiceRuntimeStoppedError();
+  }
+
   async openSession({
     userId,
     agentId = null,
@@ -42,6 +57,7 @@ class VoiceRuntimeManager {
     sink,
     outputMode = 'audio_and_text',
   } = {}) {
+    this.#assertRunning();
     if (!sink) {
       throw new Error('A voice session sink is required.');
     }
@@ -57,6 +73,14 @@ class VoiceRuntimeManager {
     }
     const adapter = this.#createAdapter(voiceSettings.liveProvider);
     await adapter.open();
+    if (this.shuttingDown) {
+      await adapter.close?.(resolvedSessionId).catch(() => {});
+      throw voiceRuntimeStoppedError();
+    }
+    if (this.sessions.has(resolvedSessionId)) {
+      await adapter.close?.(resolvedSessionId).catch(() => {});
+      throw new Error('Voice session ID collision: a session with this ID already exists.');
+    }
 
     const session = new VoiceLiveSession({
       id: resolvedSessionId,
@@ -74,8 +98,15 @@ class VoiceRuntimeManager {
 
     session.adapter = adapter;
     this.sessions.set(resolvedSessionId, session);
-    await session.publishReady();
-    return session;
+    try {
+      await session.publishReady();
+      return session;
+    } catch (error) {
+      this.sessions.delete(resolvedSessionId);
+      await session.close('startup_failed').catch(() => {});
+      await adapter.close?.(resolvedSessionId).catch(() => {});
+      throw error;
+    }
   }
 
   async openFlutterSession({ userId, agentId = null, socket, sessionId = null } = {}) {
@@ -162,12 +193,12 @@ class VoiceRuntimeManager {
     if (userId != null && session.userId != null && String(session.userId) !== String(userId)) {
       throw new Error('Voice session access denied.');
     }
-    if (reason === 'socket_disconnected') {
-      await this.abortActiveRun(session.id, 'voice_disconnect');
-    }
+    await this.abortActiveRun(session.id, reason === 'socket_disconnected'
+      ? 'voice_disconnect'
+      : 'voice_session_closed');
     this.sessions.delete(session.id);
-    await session.adapter?.close?.(session.id);
     await session.close(reason);
+    await session.adapter?.close?.(session.id);
   }
 
   async beginInput(sessionId, options = {}, userId = null) {
@@ -255,7 +286,13 @@ class VoiceRuntimeManager {
     };
   }
 
-  async deliverDeferredVoiceFollowUp(session, followUpPlan, replyText, runId = null) {
+  async deliverDeferredVoiceFollowUp(
+    session,
+    followUpPlan,
+    replyText,
+    runId = null,
+    options = {},
+  ) {
     if (!session || session.closed || !followUpPlan || session.deferFollowUpRequested !== true) {
       return { sent: false, skipped: true };
     }
@@ -298,9 +335,11 @@ class VoiceRuntimeManager {
           agentId: session.agentId,
           runId,
           persistConversation: true,
+          signal: options.signal,
         },
       );
     } catch (err) {
+      if (options.signal?.aborted) throw createAbortError(options.signal);
       console.error('Failed to send deferred voice follow-up:', err);
       return {
         sent: false,
@@ -334,6 +373,7 @@ class VoiceRuntimeManager {
     sink,
     metadata = null,
   } = {}) {
+    this.#assertRunning();
     const sessionId = `telnyx:${userId}:${callId}`;
     let session = this.getSession(sessionId);
     if (!session) {
@@ -358,10 +398,18 @@ class VoiceRuntimeManager {
       });
       session.adapter = this.#createAdapter(voiceSettings.liveProvider);
       await session.adapter.open();
+      if (this.shuttingDown) {
+        await session.close('server_shutdown').catch(() => {});
+        await session.adapter.close?.(sessionId).catch(() => {});
+        throw voiceRuntimeStoppedError();
+      }
       this.sessions.set(sessionId, session);
     }
 
     await session.interruptOutput();
+    await this.abortActiveRun(session.id, 'voice_interrupt');
+    session.resetTurnState();
+    const turnSignal = session.signal;
     await session.setState('thinking');
 
     try {
@@ -370,7 +418,9 @@ class VoiceRuntimeManager {
       });
       return result;
     } finally {
-      await session.setState('idle');
+      if (!session.closed && session.signal === turnSignal && !turnSignal.aborted) {
+        await session.setState('idle');
+      }
     }
   }
 
@@ -378,7 +428,29 @@ class VoiceRuntimeManager {
     const session = this.getSession(sessionId);
     const runId = session?.currentRunId;
     if (!runId || !this.agentEngine) return;
-    this.agentEngine.abort(runId, reason);
+    this.agentEngine.abort(runId, { userId: session.userId, reason });
+  }
+
+  shutdown() {
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.shuttingDown = true;
+    const sessionIds = Array.from(this.sessions.keys());
+    const closing = Promise.allSettled(
+      sessionIds.map((sessionId) => this.closeSession(sessionId, 'server_shutdown')),
+    );
+    this.shutdownPromise = waitForBoundedResult(closing, {
+      serviceName: 'Voice runtime shutdown',
+      timeoutMs: 10000,
+    }).then((results) => ({
+      state: 'stopped',
+      timedOut: false,
+      failedSessionCount: results.filter((result) => result.status === 'rejected').length,
+    })).catch((error) => ({
+      state: 'timeout',
+      timedOut: error?.code === 'HTTP_TIMEOUT',
+      error: error?.message || String(error),
+    }));
+    return this.shutdownPromise;
   }
 
   #createAdapter(provider) {
@@ -389,6 +461,7 @@ class VoiceRuntimeManager {
   }
 
   #requireSession(sessionId, userId = null) {
+    this.#assertRunning();
     const session = this.getSession(sessionId);
     if (!session) {
       throw new Error('Voice session was not found.');
@@ -466,6 +539,8 @@ class VoiceRuntimeManager {
   }
 
   async #deliverFlutterAssistantOutput(socket, sessionId, session, content, options = {}) {
+    const turnSignal = session.signal;
+    throwIfAborted(turnSignal, 'Voice output was interrupted.');
     const kind = String(options.kind || 'final').trim() || 'final';
     socket.emit('voice:assistant_text', {
       sessionId,
@@ -486,7 +561,7 @@ class VoiceRuntimeManager {
 
     let index = 0;
     let streamError = null;
-    const ttsAttempts = this.#buildTtsAttemptOrder(session, voiceOptions);
+    const ttsAttempts = this.#buildTtsAttemptOrder(session, voiceOptions, turnSignal);
     if (spokenContent) {
       try {
       for (const attempt of ttsAttempts) {
@@ -498,7 +573,12 @@ class VoiceRuntimeManager {
             spokenContent,
             attempt,
             async ({ audioBytes, mimeType }) => {
-              if (session.closed || session.interrupted) return;
+              if (
+                session.closed
+                || session.interrupted
+                || turnSignal.aborted
+                || session.signal !== turnSignal
+              ) return;
               socket.emit('voice:audio_chunk', {
                 sessionId,
                 kind,
@@ -516,6 +596,7 @@ class VoiceRuntimeManager {
           streamError = null;
           break;
         } catch (error) {
+          if (turnSignal.aborted || session.signal !== turnSignal) return;
           streamError = String(error?.message || error || 'Voice playback failed.');
           console.warn(`[VoiceRuntime] ${attempt.provider} TTS failed for flutter session ${sessionId}: ${streamError}`);
           if (attemptChunks > 0) {
@@ -524,13 +605,16 @@ class VoiceRuntimeManager {
         }
       }
       } catch (error) {
+        if (turnSignal.aborted || session.signal !== turnSignal) return;
         streamError = String(error?.message || error || 'Voice playback failed.');
       }
     }
 
-    if (!streamError && !session.closed && !session.interrupted) {
+    if (!streamError && !session.closed && !session.interrupted
+      && !turnSignal.aborted && session.signal === turnSignal) {
       socket.emit('voice:audio_done', { sessionId, kind, totalChunks: index });
-    } else if (kind === 'final' && !session.closed && !session.interrupted) {
+    } else if (kind === 'final' && !session.closed && !session.interrupted
+      && !turnSignal.aborted && session.signal === turnSignal) {
       socket.emit('voice:error', {
         sessionId,
         error: streamError,
@@ -540,7 +624,8 @@ class VoiceRuntimeManager {
       await session.setState('degraded', { kind, phase: 'tts' });
     }
 
-    if (kind === 'final' && !streamError) {
+    if (kind === 'final' && !streamError
+      && !turnSignal.aborted && session.signal === turnSignal) {
       await session.setState('idle');
     }
   }
@@ -550,6 +635,8 @@ class VoiceRuntimeManager {
     if (!session) {
       return;
     }
+    const turnSignal = session.signal;
+    throwIfAborted(turnSignal, 'Voice output was interrupted.');
     const kind = String(options.kind || 'final').trim() || 'final';
     ws.send(JSON.stringify({
       type: 'voice:assistant_text',
@@ -572,7 +659,7 @@ class VoiceRuntimeManager {
     const spokenContent = sanitizeSpeechText(content);
     let index = 0;
     let streamError = null;
-    const ttsAttempts = this.#buildTtsAttemptOrder(session, voiceOptions);
+    const ttsAttempts = this.#buildTtsAttemptOrder(session, voiceOptions, turnSignal);
 
     if (spokenContent) {
       try {
@@ -585,7 +672,12 @@ class VoiceRuntimeManager {
               spokenContent,
               attempt,
               async ({ audioBytes, mimeType }) => {
-                if (session.closed || session.interrupted) return;
+                if (
+                  session.closed
+                  || session.interrupted
+                  || turnSignal.aborted
+                  || session.signal !== turnSignal
+                ) return;
                 ws.send(JSON.stringify({
                   type: 'voice:audio_chunk',
                   sessionId,
@@ -603,6 +695,7 @@ class VoiceRuntimeManager {
             }
             break;
           } catch (error) {
+            if (turnSignal.aborted || session.signal !== turnSignal) return;
             streamError = String(error?.message || error || 'Voice playback failed.');
             console.warn(`[VoiceRuntime] ${attempt.provider} TTS failed for wearable session ${sessionId}: ${streamError}`);
             if (attemptChunks > 0) {
@@ -611,18 +704,21 @@ class VoiceRuntimeManager {
           }
         }
       } catch (error) {
+        if (turnSignal.aborted || session.signal !== turnSignal) return;
         streamError = String(error?.message || error || 'Voice playback failed.');
       }
     }
 
-    if (!streamError && !session.closed && !session.interrupted) {
+    if (!streamError && !session.closed && !session.interrupted
+      && !turnSignal.aborted && session.signal === turnSignal) {
       ws.send(JSON.stringify({
         type: 'voice:audio_done',
         sessionId,
         kind,
         totalChunks: index,
       }));
-    } else if (kind === 'final' && !session.closed && !session.interrupted) {
+    } else if (kind === 'final' && !session.closed && !session.interrupted
+      && !turnSignal.aborted && session.signal === turnSignal) {
       ws.send(JSON.stringify({
         type: 'voice:error',
         sessionId,
@@ -633,12 +729,13 @@ class VoiceRuntimeManager {
       await session.setState('degraded', { kind, phase: 'tts' });
     }
 
-    if (kind === 'final' && !streamError) {
+    if (kind === 'final' && !streamError
+      && !turnSignal.aborted && session.signal === turnSignal) {
       await session.setState('idle');
     }
   }
 
-  #buildTtsAttemptOrder(session, voiceOptions) {
+  #buildTtsAttemptOrder(session, voiceOptions, signal = null) {
     const attempts = [];
     const providers = [
       voiceOptions.provider,
@@ -663,6 +760,7 @@ class VoiceRuntimeManager {
         apiKey: runtime.apiKey,
         baseUrl: runtime.baseUrl,
         timeoutMs: 20000,
+        signal,
       });
     }
     return attempts;

package/server/services/voice/turnRunner.js

@@ -13,6 +13,7 @@ const {
   VOICE_HISTORY_WINDOW,
   buildDirectVoiceRunOptions,
 } = require('./runtime');
+const { createAbortError, throwIfAborted } = require('../../utils/abort');
 
 async function runVoiceTranscriptTurn({
   userId,
@@ -30,10 +31,12 @@ async function runVoiceTranscriptTurn({
   allowInterimUpdates = false,
   voiceSessionId = null,
   runId = null,
+  signal = null,
 }) {
   if (!agentEngine || !memoryManager) {
     throw new Error('Voice turn service is not initialized.');
   }
+  throwIfAborted(signal, 'Voice turn aborted before startup.');
 
   const transcriptText = String(transcript || '').trim();
   if (!transcriptText) {
@@ -83,6 +86,7 @@ async function runVoiceTranscriptTurn({
     priorMessages,
     priorSummary,
     voiceSessionId,
+    signal,
     context: {
       rawUserMessage: storedUserContent,
       additionalContext: directVoiceContext,
@@ -161,6 +165,7 @@ async function runVoiceTranscriptTurn({
           apiKey: runtime.apiKey,
           baseUrl: runtime.baseUrl,
           timeoutMs: 12000,
+          signal,
         });
         providerUsed = normalized.provider;
         modelUsed = normalized.model;
@@ -168,6 +173,7 @@ async function runVoiceTranscriptTurn({
         ttsError = null;
         break;
       } catch (error) {
+        if (signal?.aborted) throw createAbortError(signal);
         lastTtsError = error;
       }
     }

package/server/services/wearable/firmware_manifest.js

@@ -1,8 +1,14 @@
 'use strict';
 
+const { createAbortError } = require('../../utils/abort');
+const { fetchResponseText } = require('../network/http');
+
 const DEFAULT_GITHUB_REPOSITORY = 'NeoLabs-Systems/NeoAgent';
 const DEFAULT_ASSET_NAME = 'neoagent-wearable-firmware.bin';
 const MANIFEST_CACHE_TTL_MS = 5 * 60 * 1000;
+const FIRMWARE_HTTP_TIMEOUT_MS = 15000;
+const RELEASES_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+const CHECKSUM_MAX_RESPONSE_BYTES = 64 * 1024;
 const manifestCache = new Map();
 
 function trimString(value, maxLength = 512) {
@@ -118,36 +124,53 @@ function selectChecksumAsset(release, assetName) {
   }) || null;
 }
 
-async function fetchGithubJson(fetchImpl, url, token) {
-  const response = await fetchImpl(url, {
+async function fetchGithubJson(fetchImpl, url, token, signal) {
+  const { response, text } = await fetchResponseText(url, {
+    fetchImpl,
     headers: {
       Accept: 'application/vnd.github+json',
       ...(token ? { Authorization: `Bearer ${token}` } : {}),
     },
+    signal,
+    timeoutMs: FIRMWARE_HTTP_TIMEOUT_MS,
+    maxResponseBytes: RELEASES_MAX_RESPONSE_BYTES,
+    serviceName: 'GitHub firmware release lookup',
+    timeoutCode: 'FIRMWARE_HTTP_TIMEOUT',
+    tooLargeCode: 'FIRMWARE_RESPONSE_TOO_LARGE',
   });
   if (!response.ok) {
-    const body = await response.text().catch(() => '');
     const error = new Error(`GitHub API request failed with ${response.status}`);
     error.status = response.status;
-    error.body = body;
+    error.body = text.slice(0, 2000);
     throw error;
   }
-  return response.json();
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new Error('GitHub firmware release lookup returned malformed JSON.', { cause });
+  }
 }
 
-async function fetchText(fetchImpl, url, token) {
-  const response = await fetchImpl(url, {
+async function fetchText(fetchImpl, url, token, signal) {
+  const { response, text } = await fetchResponseText(url, {
+    fetchImpl,
     headers: {
       Accept: 'text/plain, application/octet-stream;q=0.9, */*;q=0.1',
       ...(token ? { Authorization: `Bearer ${token}` } : {}),
     },
+    signal,
+    timeoutMs: FIRMWARE_HTTP_TIMEOUT_MS,
+    maxResponseBytes: CHECKSUM_MAX_RESPONSE_BYTES,
+    serviceName: 'Firmware checksum download',
+    timeoutCode: 'FIRMWARE_HTTP_TIMEOUT',
+    tooLargeCode: 'FIRMWARE_RESPONSE_TOO_LARGE',
   });
   if (!response.ok) {
     const error = new Error(`Asset request failed with ${response.status}`);
     error.status = response.status;
     throw error;
   }
-  return response.text();
+  return text;
 }
 
 function parseChecksumBody(body, assetName) {
@@ -168,9 +191,14 @@ function parseChecksumBody(body, assetName) {
   return null;
 }
 
-async function fetchGithubRelease(fetchImpl, repository, channel, token, assetName = null) {
+async function fetchGithubRelease(fetchImpl, repository, channel, token, assetName = null, signal = null) {
   const normalizedChannel = normalizeChannel(channel);
-  const releases = await fetchGithubJson(fetchImpl, `https://api.github.com/repos/${repository}/releases?per_page=100`, token);
+  const releases = await fetchGithubJson(
+    fetchImpl,
+    `https://api.github.com/repos/${repository}/releases?per_page=100`,
+    token,
+    signal,
+  );
   const release = selectGithubRelease(releases, normalizedChannel, assetName);
   if (!release) {
     const error = new Error(`No ${normalizedChannel} firmware release found for ${repository}`);
@@ -212,6 +240,7 @@ async function resolveFirmwareManifest({
   repositoryOverride,
   assetNameOverride,
   fetchImpl = fetch,
+  signal = null,
 } = {}) {
   const normalizedChannel = normalizeChannel(channel);
   const repository = parseRepositorySlug(repositoryOverride) || getGithubRepository();
@@ -264,7 +293,14 @@ async function resolveFirmwareManifest({
 
   try {
     const token = getGithubToken();
-    const release = await fetchGithubRelease(fetchImpl, repository, normalizedChannel, token, assetName);
+    const release = await fetchGithubRelease(
+      fetchImpl,
+      repository,
+      normalizedChannel,
+      token,
+      assetName,
+      signal,
+    );
     const asset = selectReleaseAsset(release, assetName);
     if (!asset || !asset.browser_download_url) {
       return {
@@ -293,10 +329,11 @@ async function resolveFirmwareManifest({
     if (checksumAsset?.browser_download_url) {
       try {
         checksum = parseChecksumBody(
-          await fetchText(fetchImpl, checksumAsset.browser_download_url, token),
+          await fetchText(fetchImpl, checksumAsset.browser_download_url, token, signal),
           asset.name,
         );
-      } catch {
+      } catch (error) {
+        if (signal?.aborted) throw createAbortError(signal);
         checksum = null;
       }
     }
@@ -322,6 +359,7 @@ async function resolveFirmwareManifest({
     setCachedManifest(cacheId, manifest);
     return manifest;
   } catch (error) {
+    if (signal?.aborted) throw createAbortError(signal);
     return {
       configured: false,
       source: 'github',

package/server/services/wearable/service.js

@@ -136,6 +136,7 @@ class WearableService {
       channel,
       repositoryOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_GITHUB_REPOSITORY, 256),
       assetNameOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_ASSET_NAME, 128),
+      signal: req?.signal,
     });
     return {
       ...manifest,

package/server/utils/abort.js

@@ -0,0 +1,96 @@
+'use strict';
+
+function createAbortError(signalOrReason = null, fallback = 'Operation aborted.') {
+  const reason = signalOrReason && typeof signalOrReason === 'object'
+    && 'aborted' in signalOrReason
+    ? signalOrReason.reason
+    : signalOrReason;
+  if (reason instanceof Error) return reason;
+  const error = new Error(
+    String(reason || fallback),
+  );
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  return error;
+}
+
+function isAbortError(error, signal = null) {
+  return signal?.aborted === true
+    || error?.name === 'AbortError'
+    || error?.code === 'ABORT_ERR';
+}
+
+function throwIfAborted(signal, fallback = 'Operation aborted.') {
+  if (signal?.aborted) throw createAbortError(signal, fallback);
+}
+
+function createLinkedAbortController(signals = []) {
+  const controller = new AbortController();
+  const listeners = new Map();
+  for (const signal of new Set(signals.filter(Boolean))) {
+    if (typeof signal.addEventListener !== 'function') continue;
+    const forwardAbort = () => {
+      if (!controller.signal.aborted) controller.abort(signal.reason);
+    };
+    listeners.set(signal, forwardAbort);
+    if (signal.aborted) {
+      forwardAbort();
+      break;
+    }
+    signal.addEventListener('abort', forwardAbort, { once: true });
+  }
+  return {
+    controller,
+    signal: controller.signal,
+    cleanup() {
+      for (const [signal, forwardAbort] of listeners) {
+        signal.removeEventListener('abort', forwardAbort);
+      }
+      listeners.clear();
+    },
+  };
+}
+
+async function runWithAbortTimeout(factory, options = {}) {
+  const timeoutMs = Number(options.timeoutMs);
+  const timeoutController = new AbortController();
+  const linked = createLinkedAbortController([
+    options.signal,
+    timeoutController.signal,
+  ]);
+  throwIfAborted(linked.signal, `${options.label || 'Operation'} aborted.`);
+  let timer = null;
+  let abortListener = null;
+  if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+    timer = setTimeout(() => {
+      const error = new Error(
+        `${options.label || 'Operation'} timed out after ${Math.floor(timeoutMs)}ms.`,
+      );
+      error.code = options.timeoutCode || 'OPERATION_TIMEOUT';
+      timeoutController.abort(error);
+    }, timeoutMs);
+  }
+  const aborted = new Promise((_, reject) => {
+    abortListener = () => reject(createAbortError(linked.signal));
+    linked.signal.addEventListener('abort', abortListener, { once: true });
+  });
+
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => factory(linked.signal)),
+      aborted,
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (abortListener) linked.signal.removeEventListener('abort', abortListener);
+    linked.cleanup();
+  }
+}
+
+module.exports = {
+  createAbortError,
+  createLinkedAbortController,
+  isAbortError,
+  runWithAbortTimeout,
+  throwIfAborted,
+};