neoagent 2.3.1-beta.42 → 2.3.1-beta.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.3.1-beta.42",
+  "version": "2.3.1-beta.44",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"42d3d75a56efe1a2e9902f52dc8006099c45d9
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "380195857" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "705842576" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/services/voice/providers.js

@@ -40,9 +40,17 @@ const EMOJI_SPEECH_REGEX =
 const WEARABLE_SAFE_AUDIO_FORMAT = Object.freeze({
   responseFormat: 'wav',
   mimeType: 'audio/wav',
+  streamResponseFormat: 'pcm',
+  streamMimeType: 'audio/wav',
+  pcmSampleRate: 24000,
+  pcmChannels: 1,
+  pcmBitsPerSample: 16,
   deepgramEncoding: 'linear16',
   deepgramContainer: 'wav',
+  deepgramStreamContainer: 'none',
 });
+const MIN_STREAM_PCM_CHUNK_BYTES = 24000;
+const MAX_STREAM_PCM_CHUNK_BYTES = 48000;
 
 function withTimeout(promise, timeoutMs, label) {
   const normalizedTimeout = Number(timeoutMs);
@@ -198,10 +206,11 @@ async function fetchAudioStreamOrThrow(url, init, errorPrefix, defaultMimeType =
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
-    if (value?.length) chunks.push(Buffer.from(value));
+    if (value?.length) {
+      chunks.push(Buffer.from(value));
+    }
   }
-  const audioBytes = Buffer.concat(chunks);
-  await onChunk({ audioBytes, mimeType });
+  await onChunk({ audioBytes: Buffer.concat(chunks), mimeType });
 }
 
 function guessExtFromMimeType(mimeType) {
@@ -262,6 +271,49 @@ function wrapPcmAsWav(audioBytes, format) {
   return Buffer.concat([header, data]);
 }
 
+async function streamPcmAsWavChunks(readable, format, onChunk) {
+  const source = readable && typeof readable.getReader === 'function'
+    ? readable
+    : null;
+  let pending = Buffer.alloc(0);
+
+  async function flushPending(force = false) {
+    while (pending.length >= MIN_STREAM_PCM_CHUNK_BYTES || (force && pending.length > 0)) {
+      const targetLength = force
+        ? pending.length
+        : Math.min(pending.length, MAX_STREAM_PCM_CHUNK_BYTES);
+      const evenLength = targetLength - (targetLength % 2);
+      if (evenLength <= 0) return;
+      const pcmChunk = pending.subarray(0, evenLength);
+      pending = pending.subarray(evenLength);
+      await onChunk({
+        audioBytes: wrapPcmAsWav(pcmChunk, format),
+        mimeType: WEARABLE_SAFE_AUDIO_FORMAT.streamMimeType,
+      });
+    }
+  }
+
+  if (source) {
+    const reader = source.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value?.length) {
+        pending = Buffer.concat([pending, Buffer.from(value)]);
+        await flushPending(false);
+      }
+    }
+  } else {
+    for await (const chunk of readable) {
+      if (chunk?.length) {
+        pending = Buffer.concat([pending, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+        await flushPending(false);
+      }
+    }
+  }
+  await flushPending(true);
+}
+
 async function transcribeWithOpenAi(filePath, model, options = {}) {
   const client = getOpenAiClient({
     apiKey: typeof options.apiKey === 'string' ? options.apiKey.trim() : '',
@@ -380,8 +432,20 @@ async function streamWithOpenAi(text, model, voice, options = {}, onChunk) {
     model: String(model || 'gpt-4o-mini-tts').trim() || 'gpt-4o-mini-tts',
     voice: String(voice || 'alloy').trim() || 'alloy',
     input: text,
-    response_format: useWearableSafeAudio ? WEARABLE_SAFE_AUDIO_FORMAT.responseFormat : 'mp3',
+    response_format: useWearableSafeAudio ? WEARABLE_SAFE_AUDIO_FORMAT.streamResponseFormat : 'mp3',
   });
+  if (useWearableSafeAudio) {
+    await streamPcmAsWavChunks(
+      response.body,
+      {
+        bitsPerSample: WEARABLE_SAFE_AUDIO_FORMAT.pcmBitsPerSample,
+        sampleRate: WEARABLE_SAFE_AUDIO_FORMAT.pcmSampleRate,
+        channels: WEARABLE_SAFE_AUDIO_FORMAT.pcmChannels,
+      },
+      onChunk,
+    );
+    return;
+  }
   const chunks = [];
   for await (const chunk of response.body) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -427,7 +491,32 @@ async function streamWithDeepgram(text, model, options = {}, onChunk) {
   });
   if (useWearableSafeAudio) {
     searchParams.set('encoding', WEARABLE_SAFE_AUDIO_FORMAT.deepgramEncoding);
-    searchParams.set('container', WEARABLE_SAFE_AUDIO_FORMAT.deepgramContainer);
+    searchParams.set('container', WEARABLE_SAFE_AUDIO_FORMAT.deepgramStreamContainer);
+    searchParams.set('sample_rate', String(WEARABLE_SAFE_AUDIO_FORMAT.pcmSampleRate));
+    const response = await fetch(
+      `https://api.deepgram.com/v1/speak?${searchParams.toString()}`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Token ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ text }),
+      },
+    );
+    if (!response.ok) {
+      await throwResponseError(response, 'Deepgram TTS stream failed');
+    }
+    await streamPcmAsWavChunks(
+      response.body,
+      {
+        bitsPerSample: WEARABLE_SAFE_AUDIO_FORMAT.pcmBitsPerSample,
+        sampleRate: WEARABLE_SAFE_AUDIO_FORMAT.pcmSampleRate,
+        channels: WEARABLE_SAFE_AUDIO_FORMAT.pcmChannels,
+      },
+      onChunk,
+    );
+    return;
   }
   await fetchAudioStreamOrThrow(
     `https://api.deepgram.com/v1/speak?${searchParams.toString()}`,

package/server/services/voice/runtimeManager.js

@@ -468,8 +468,6 @@ class VoiceRuntimeManager {
       provider: session.voiceSettings?.liveProvider,
       model: session.voiceSettings?.liveTtsModel,
       voice: session.voiceSettings?.liveVoice,
-      transport: 'wearable',
-      responseFormat: 'wav',
     });
     const spokenContent = sanitizeSpeechText(content);
 
@@ -481,6 +479,7 @@ class VoiceRuntimeManager {
       for (const attempt of ttsAttempts) {
         index = 0;
         streamError = null;
+        let attemptChunks = 0;
         try {
           await synthesizeVoiceReplyStream(
             spokenContent,
@@ -494,13 +493,21 @@ class VoiceRuntimeManager {
                 audioBase64: audioBytes.toString('base64'),
                 mimeType,
               });
+              attemptChunks += 1;
               index += 1;
             },
           );
+          if (attemptChunks === 0) {
+            throw new Error(`${attempt.provider} TTS produced no audio chunks.`);
+          }
           streamError = null;
           break;
         } catch (error) {
           streamError = String(error?.message || error || 'Voice playback failed.');
+          console.warn(`[VoiceRuntime] ${attempt.provider} TTS failed for flutter session ${sessionId}: ${streamError}`);
+          if (attemptChunks > 0) {
+            break;
+          }
         }
       }
       } catch (error) {
@@ -546,6 +553,8 @@ class VoiceRuntimeManager {
       provider: session.voiceSettings?.liveProvider,
       model: session.voiceSettings?.liveTtsModel,
       voice: session.voiceSettings?.liveVoice,
+      transport: 'wearable',
+      responseFormat: 'wav',
     });
     const spokenContent = sanitizeSpeechText(content);
     let index = 0;
@@ -557,6 +566,7 @@ class VoiceRuntimeManager {
         for (const attempt of ttsAttempts) {
           index = 0;
           streamError = null;
+          let attemptChunks = 0;
           try {
             await synthesizeVoiceReplyStream(
               spokenContent,
@@ -571,12 +581,20 @@ class VoiceRuntimeManager {
                   audioBase64: audioBytes.toString('base64'),
                   mimeType,
                 }));
+                attemptChunks += 1;
                 index += 1;
               },
             );
+            if (attemptChunks === 0) {
+              throw new Error(`${attempt.provider} TTS produced no audio chunks.`);
+            }
             break;
           } catch (error) {
             streamError = String(error?.message || error || 'Voice playback failed.');
+            console.warn(`[VoiceRuntime] ${attempt.provider} TTS failed for wearable session ${sessionId}: ${streamError}`);
+            if (attemptChunks > 0) {
+              break;
+            }
           }
         }
       } catch (error) {
@@ -618,6 +636,8 @@ class VoiceRuntimeManager {
         provider,
         model: provider === voiceOptions.provider ? voiceOptions.model : null,
         voice: provider === voiceOptions.provider ? voiceOptions.voice : null,
+        transport: voiceOptions.transport,
+        responseFormat: voiceOptions.responseFormat,
       });
       const runtime = provider === voiceOptions.provider
         ? {

package/server/services/wearable/firmware_manifest.js

@@ -1,10 +1,6 @@
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
-
-const { APP_DIR } = require('../../../runtime/paths');
-
+const DEFAULT_GITHUB_REPOSITORY = 'NeoLabs-Systems/NeoAgent';
 const DEFAULT_ASSET_NAME = 'neoagent-wearable-firmware.bin';
 const MANIFEST_CACHE_TTL_MS = 5 * 60 * 1000;
 const manifestCache = new Map();
@@ -33,28 +29,10 @@ function parseRepositorySlug(value) {
   return null;
 }
 
-function readPackageRepositorySlug() {
-  try {
-    const packageJsonPath = path.join(APP_DIR, 'package.json');
-    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    const repository = pkg?.repository;
-    if (typeof repository === 'string') {
-      return parseRepositorySlug(repository);
-    }
-    if (repository && typeof repository.url === 'string') {
-      return parseRepositorySlug(repository.url);
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-
 function getGithubRepository() {
   return (
     parseRepositorySlug(process.env.NEOAGENT_WEARABLE_FIRMWARE_GITHUB_REPOSITORY)
-    || parseRepositorySlug(process.env.GITHUB_REPOSITORY)
-    || readPackageRepositorySlug()
+    || DEFAULT_GITHUB_REPOSITORY
   );
 }
 
@@ -86,10 +64,17 @@ function toBoolean(value, fallback = false) {
   return fallback;
 }
 
-function selectGithubRelease(releases, channel) {
+function releaseHasAsset(release, assetName) {
+  return Boolean(selectReleaseAsset(release, assetName));
+}
+
+function selectGithubRelease(releases, channel, assetName = null) {
   const normalizedChannel = normalizeChannel(channel);
   if (normalizedChannel === 'stable') {
-    return Array.isArray(releases) ? releases.find((release) => release && release.prerelease === false && release.draft === false) || null : null;
+    const candidates = Array.isArray(releases)
+      ? releases.filter((release) => release && release.prerelease === false && release.draft === false)
+      : [];
+    return candidates.find((release) => !assetName || releaseHasAsset(release, assetName)) || candidates[0] || null;
   }
 
   const betaPattern = /-beta(?:\.\d+)?$/i;
@@ -101,7 +86,7 @@ function selectGithubRelease(releases, channel) {
     const leftPublished = Date.parse(left?.published_at ?? left?.created_at ?? '') || 0;
     return rightPublished - leftPublished;
   });
-  return candidates[0] || null;
+  return candidates.find((release) => !assetName || releaseHasAsset(release, assetName)) || candidates[0] || null;
 }
 
 function selectReleaseAsset(release, assetName) {
@@ -183,13 +168,10 @@ function parseChecksumBody(body, assetName) {
   return null;
 }
 
-async function fetchGithubRelease(fetchImpl, repository, channel, token) {
+async function fetchGithubRelease(fetchImpl, repository, channel, token, assetName = null) {
   const normalizedChannel = normalizeChannel(channel);
-  if (normalizedChannel === 'stable') {
-    return fetchGithubJson(fetchImpl, `https://api.github.com/repos/${repository}/releases/latest`, token);
-  }
   const releases = await fetchGithubJson(fetchImpl, `https://api.github.com/repos/${repository}/releases?per_page=100`, token);
-  const release = selectGithubRelease(releases, normalizedChannel);
+  const release = selectGithubRelease(releases, normalizedChannel, assetName);
   if (!release) {
     const error = new Error(`No ${normalizedChannel} firmware release found for ${repository}`);
     error.status = 404;
@@ -282,7 +264,7 @@ async function resolveFirmwareManifest({
 
   try {
     const token = getGithubToken();
-    const release = await fetchGithubRelease(fetchImpl, repository, normalizedChannel, token);
+    const release = await fetchGithubRelease(fetchImpl, repository, normalizedChannel, token, assetName);
     const asset = selectReleaseAsset(release, assetName);
     if (!asset || !asset.browser_download_url) {
       return {
@@ -359,6 +341,7 @@ async function resolveFirmwareManifest({
 
 module.exports = {
   DEFAULT_ASSET_NAME,
+  DEFAULT_GITHUB_REPOSITORY,
   getFirmwareAssetName,
   getGithubRepository,
   normalizeChannel,

package/server/services/wearable/service.js

@@ -139,11 +139,7 @@ class WearableService {
     const version = getVersionInfo();
     const manifest = await resolveFirmwareManifest({
       channel,
-      downloadUrlOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_DOWNLOAD_URL, 2000),
-      currentVersionOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_VERSION, 120),
-      releaseNotesUrlOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_RELEASE_NOTES_URL, 2000),
-      sha256Override: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_SHA256, 256),
-      repositoryOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_GITHUB_REPOSITORY || process.env.GITHUB_REPOSITORY, 256),
+      repositoryOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_GITHUB_REPOSITORY, 256),
       assetNameOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_ASSET_NAME, 128),
     });
     return {