neoagent 2.3.1-beta.42 → 2.3.1-beta.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.3.1-beta.42",
+  "version": "2.3.1-beta.43",
   "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: "555509852" /* 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

@@ -546,6 +546,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;
@@ -618,6 +620,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
   );
 }
 
@@ -359,6 +337,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 {