@agfpd/voicetalk-runtime 0.2.0 → 0.2.1

package/docs/README.md

@@ -63,8 +63,10 @@ Everything is tunable by env: `VOICETALK_AUDIO=0` (text-only, no microphone),
 ## Requirements
 
 - `ffmpeg` (microphone capture) and `ffplay` (playback) on `PATH`.
-- The voice-connect HTTP service running locally — it is discovered through
-  `<IAPEER_ROOT>/voice-provider.json` (override with `VOICETALK_VOICE_ENDPOINT`).
+- The voice-connect HTTP service running locally (**≥0.4.0** — replies are voiced by
+  sender identity, `peer`, so an agent keeps its own voice on every fallback rung) — it
+  is discovered through `<IAPEER_ROOT>/voice-provider.json` (override with
+  `VOICETALK_VOICE_ENDPOINT`).
 - Microphone permission (TCC) granted once to the process that runs the runtime.
 
 These pages are written as each phase lands. Russian translation lives in

package/docs/ru/README.md

@@ -62,8 +62,10 @@ Earcon'ы размечают состояния: восходящий — мик
 ## Требования
 
 - `ffmpeg` (захват микрофона) и `ffplay` (воспроизведение) на `PATH`.
-- Локально запущенный HTTP-сервис voice-connect — обнаруживается через
-  `<IAPEER_ROOT>/voice-provider.json` (переопределяется `VOICETALK_VOICE_ENDPOINT`).
+- Локально запущенный HTTP-сервис voice-connect (**≥0.4.0** — ответы озвучиваются по
+  идентичности отправителя, параметр `peer`, поэтому агент сохраняет свой голос на любой
+  ступени каскада) — обнаруживается через `<IAPEER_ROOT>/voice-provider.json`
+  (переопределяется `VOICETALK_VOICE_ENDPOINT`).
 - Разрешение на микрофон (TCC), выданное один раз процессу рантайма.
 
 Страницы пишутся по мере прохождения фаз.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/voicetalk-runtime",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Voice runtime-router for IAP peers.",
   "license": "Apache-2.0",
   "type": "module",

package/src/voiceConnect.ts

@@ -6,7 +6,7 @@
 // CONSUMER of its OpenAI-compatible routes:
 //
 //   POST /v1/audio/transcriptions   multipart(file, language?, engine?)  → { text }
-//   POST /v1/audio/speech           json(input, voice?, lang?, engine?)  → ogg/opus bytes
+//   POST /v1/audio/speech           json(input, peer?, lang?, engine?)   → ogg/opus bytes
 //   GET  /health                                                          → { status }
 //
 // Engine selection, provider cascade and fallbacks live INSIDE that service — never
@@ -143,7 +143,14 @@ export async function transcribe(audioPath: string, opts: TranscribeOptions = {}
 }
 
 export type SynthesizeOptions = {
-  /** Per-peer voice (the sender's `interfaces.voice` entry) — so agents sound distinct. */
+  /** The SPEAKER's identity (voice-connect ≥0.4.0). The service resolves that peer's
+   *  voice from `interfaces.voice` AFTER the serving engine is known, so the identity
+   *  survives every rung of the cascade — including the F5 reference. Always prefer this
+   *  over `voice`: a voice NAME belongs to one engine's namespace, so it only applies to
+   *  the engine tried first and means nothing on the rung that actually serves. */
+  peer?: string
+  /** Legacy voice-name override — covers the PRIMARY engine only. Kept for callers with
+   *  no peer identity to offer; `peer` is what a runtime should send. */
   voice?: string
   lang?: string
   style?: string
@@ -155,6 +162,8 @@ export type SynthesizeResult = {
   path: string
   engine?: string
   voice?: string
+  /** The identity the service voiced this as (echo of `peer`). */
+  peer?: string
   fallbackFrom?: string
   bytes: number
 }
@@ -168,6 +177,7 @@ export async function synthesize(text: string, outPath: string, opts: Synthesize
     headers: { 'content-type': 'application/json' },
     body: JSON.stringify({
       input: text,
+      ...(opts.peer ? { peer: opts.peer } : {}),
       ...(opts.voice ? { voice: opts.voice } : {}),
       ...(opts.lang ? { lang: opts.lang } : {}),
       ...(opts.style ? { style: opts.style } : {}),
@@ -185,6 +195,7 @@ export async function synthesize(text: string, outPath: string, opts: Synthesize
     path: outPath,
     engine: res.headers.get('x-voice-engine') ?? undefined,
     voice: res.headers.get('x-voice-voice') ?? undefined,
+    peer: res.headers.get('x-voice-peer') ?? undefined,
     fallbackFrom: res.headers.get('x-voice-fallback-from') ?? undefined,
     bytes: buf.length,
   }

package/src/voiceSession.ts

@@ -268,15 +268,6 @@ export class VoiceSession {
     }
   }
 
-  /** Voice of the SENDER — each agent keeps the voice configured in its own passport
-   *  (`interfaces.voice`), so the owner hears who is talking. */
-  private voiceFor(personality: string): string | undefined {
-    const peers = this.opts.peers ?? readFleetPeers()
-    const voice = peers.find(p => p.personality === personality)?.voice
-    if (!voice) return undefined
-    return voice['gemini-3.1-flash-tts-preview'] ?? Object.values(voice)[0]
-  }
-
   /** Speak an agent's answer on the owner's speaker, then hold the follow-up window
    *  open — the conversational turn passes back to the human. */
   async speak(from: string, message: string): Promise<void> {
@@ -285,7 +276,12 @@ export class VoiceSession {
       this.opts.log('tts.skip', { from, reason: 'nothing speakable' })
       return
     }
-    await this.say(text, { from, voice: this.voiceFor(from) })
+    // Voice by IDENTITY, not by voice name: voice-connect resolves the sender's voice
+    // after picking the engine, so the owner hears WHO is talking even when the primary
+    // engine is down and a fallback rung serves. Sending a voice name instead would only
+    // bind to the primary engine — the very defect seen live on 22.07 (boris answered in
+    // a stranger's voice once gemini was unavailable).
+    await this.say(text, { from })
     this.followTarget = from
     this.followUntil = Date.now() + FOLLOWUP_MS
     // The turn passes back to the human: the mic is open for a follow-up without a
@@ -293,11 +289,11 @@ export class VoiceSession {
     await this.earcon('open')
   }
 
-  private async say(text: string, opts: { from?: string; voice?: string } = {}): Promise<void> {
+  private async say(text: string, opts: { from?: string } = {}): Promise<void> {
     const out = join(this.opts.tmpDir, `say-${randomUUID()}.ogg`)
     const started = Date.now()
     try {
-      const result = await synthesize(text, out, { voice: opts.voice })
+      const result = await synthesize(text, out, { peer: opts.from })
       const ttsMs = Date.now() - started
       // Gate the mic for the whole playback: the runtime must not hear itself.
       this.muteUntil = Date.now() + 3_600_000
@@ -313,6 +309,7 @@ export class VoiceSession {
         chars: text.length,
         engine: result.engine,
         voice: result.voice,
+        voicedAs: result.peer,
         fallbackFrom: result.fallbackFrom,
         ttsMs,
         totalMs: Date.now() - started,

package/src/wake.ts

@@ -7,8 +7,7 @@
 // was explicitly REJECTED — it couples the spoken vocabulary to the roster and multiplies
 // false triggers — so nothing here ever sweeps the fleet registry for addressable names.
 // The registry is consulted only for peers the operator ALREADY named in the map, to
-// enrich them with their own human name («наталья» → «наталья вячеславовна») and their
-// voice.
+// enrich them with their own human name («наталья» → «наталья вячеславовна»).
 //
 // Why the address is matched on the TRANSCRIPT rather than by an acoustic wake-word model
 // (openWakeWord et al.): an acoustic detector needs a trained model per phrase, and Фаза 3
@@ -29,8 +28,6 @@ export type FleetPeer = {
   personality: string
   intelligence?: string
   description?: string
-  /** Per-peer TTS voice from `interfaces.voice` — so each agent answers in its own voice. */
-  voice?: Record<string, string>
 }
 
 export type Address = {
@@ -109,10 +106,6 @@ export function readFleetPeers(path = join(iapeerRoot(), 'peers-profiles.json'))
         personality: String(p.personality ?? ''),
         intelligence: typeof p.intelligence === 'string' ? p.intelligence : undefined,
         description: typeof p.description === 'string' ? p.description : undefined,
-        voice:
-          p.interfaces && typeof p.interfaces === 'object' && (p.interfaces as any).voice
-            ? ((p.interfaces as any).voice as Record<string, string>)
-            : undefined,
       }))
       .filter(p => p.personality)
   } catch {