@glyphteck/veyl 0.72.0 → 0.73.0

package/examples/bot-fleet/policy.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { createVoiceRole } from './voice.js';
 
 export const BOT_FLEET_ROLES = new Set([
     'read',
@@ -7,6 +8,7 @@ export const BOT_FLEET_ROLES = new Set([
     'traffic',
     'live',
     'typing',
+    'voice',
 ]);
 const BOT_UNDERFUNDED_TEXT = 'insufficient funds';
 const ATTACHMENT_TYPES = new Set(['img', 'gif', 'm4a', 'mp4', 'file']);
@@ -520,6 +522,7 @@ export function createBotFleetPolicy(options = {}) {
     const echoChatKeys = new Set();
     const claimStates = new Map();
     const liveStates = new Map();
+    const voiceStates = new Map();
 
     function shouldMirror(account, event) {
         if (isFleetGeneratedMessage(event)) return false;
@@ -591,9 +594,22 @@ export function createBotFleetPolicy(options = {}) {
                 if (roles.has('live')) {
                     await startLiveRole(account, client, liveStates);
                 }
+                if (roles.has('voice')) {
+                    const voice = createVoiceRole(client, current.uid);
+                    voiceStates.set(account.profile, voice);
+                    try { await voice.start(); }
+                    catch (error) {
+                        voiceStates.delete(account.profile);
+                        await voice.close();
+                        throw error;
+                    }
+                }
             }
         },
         async stop({ account }) {
+            const voice = voiceStates.get(account.profile);
+            voiceStates.delete(account.profile);
+            await voice?.close();
             await stopLiveRole(account, liveStates);
             await stopClaimLoop(account.profile, claimStates);
             const username = usernameByProfile.get(account.profile);
@@ -605,6 +621,8 @@ export function createBotFleetPolicy(options = {}) {
             if (username) managedUsernames.delete(username);
         },
         async stopFleet() {
+            await Promise.all([...voiceStates.values()].map(voice => voice.close()));
+            voiceStates.clear();
             await Promise.all([...liveStates.keys()].map((profile) =>
                 stopLiveRole({ profile, roles: [] }, liveStates)
             ));

package/examples/bot-fleet/readme.md

@@ -12,6 +12,7 @@ The secret-free version-2 manifest stores account indices, usernames, networks,
 - `traffic` is an eligibility marker for an external local operator policy; it performs no work by itself.
 - `live` holds the account's normal encrypted live-room connection in each chat without advancing read state or sending messages. The concrete host supplies the same realm-matched portable live transport used by graphical clients; startup rejects this role when that client port is absent.
 - `typing` requires `live` and continually renews one stable composition through the same encrypted live state until the policy stops.
+- `voice` starts muted and joins the newest active, foreign-occupied call among the account's watched chats. It uses `client.chat.watch(onChats, { count: 500 })`, `client.calls.observe(chatId, onAvailable)`, and strict `joinExisting(chatId, callId)`; it never creates a call or inherits read/echo behavior. The host must supply real `calls.media` and ephemeral `calls.mls` ports. One shared owner admits the new destination before leaving an old call, supports cancellation, and leaves when no other account remains. A failed unchanged room is not retried on every heartbeat.
 
 Only response-capable fleet peers are loop-suppressed. Incoming transaction events and staggered fallback loops call the public wallet claim method. Startup replays a bounded visible window; an event checkpoint suppresses completed source messages, while the action journal suppresses completed effects and stops ambiguous payments for explicit reconciliation.
 

package/examples/bot-fleet/runtime.js

@@ -24,6 +24,13 @@ export async function resolveBotFleetClientOptions(source, profile) {
     ) {
         throw new Error(`live bot transport required: ${profile.profile}`);
     }
+    if (profile?.roles?.includes('voice') && (
+        typeof options?.calls?.media?.open !== 'function'
+        || typeof options?.calls?.media?.prepare !== 'function'
+        || typeof options?.calls?.mls?.createMember !== 'function'
+    )) {
+        throw new Error(`voice bot media and encryption ports required: ${profile.profile}`);
+    }
     return options;
 }
 
@@ -41,7 +48,7 @@ export async function createExampleBotFleetRuntime(options = {}) {
         policies: [],
         eventOptions: async (profile) => ({
             replay: true,
-            chats: profile.roles.includes('read') || profile.roles.includes('live'),
+            chats: profile.roles.some(role => ['read', 'live', 'voice'].includes(role)),
             persistentChats: true,
             persistentChatIdleMs: options.persistentChatIdleMs || 5 * 60_000,
             transactions: true,

package/examples/bot-fleet/voice.js

@@ -0,0 +1,157 @@
+function sameRoom(left, right) {
+    return !!left && !!right
+        && left.chatId === right.chatId && left.callId === right.callId;
+}
+
+function availableRoom(value, chatId, uid) {
+    if (value?.chatId !== chatId || !value.callId || !Number.isFinite(value.startedAt)) return null;
+    const others = (value.roster || []).filter(peer => peer.uid && peer.uid !== uid);
+    if (!others.length) return null;
+    // Own admission and audio preferences do not constitute a new opportunity
+    // to retry a failed room. Only a new call or changed foreign membership does.
+    const members = others.map(peer => [peer.uid, peer.chatPK, peer.holder]).sort();
+    return {
+        chatId, callId: value.callId, startedAt: value.startedAt,
+        fingerprint: JSON.stringify([value.callId, value.startedAt, members]),
+    };
+}
+
+export function createVoiceRole(client, uid) {
+    if (!uid) throw new Error('voice bot account identity required');
+    const calls = client.calls;
+    const chats = new Map();
+    let closed = false;
+    let dirty = false;
+    let running = null;
+    let startup = null;
+    let stopping = null;
+    let pending = null;
+    let releaseChats = null;
+    let releaseCalls = null;
+    let lastError = null;
+
+    function report(error) {
+        const code = /^[a-z0-9/-]{1,80}$/u.test(error?.code || '') ? error.code : 'calls/failed';
+        client.diag?.('bot.voice.error', { code });
+    }
+
+    function newest() {
+        let selected = null;
+        for (const entry of chats.values()) {
+            const room = entry.room;
+            if (!room || entry.failed === room.fingerprint) continue;
+            if (!selected || room.startedAt > selected.startedAt
+                || (room.startedAt === selected.startedAt && room.chatId > selected.chatId)) selected = room;
+        }
+        return selected;
+    }
+
+    function fail(room, error) {
+        const entry = chats.get(room?.chatId);
+        if (sameRoom(entry?.room, room)) entry.failed = entry.room.fingerprint;
+        if (error?.code !== 'calls/cancelled') report(error);
+    }
+
+    async function reconcile() {
+        const room = newest();
+        const current = calls.getSnapshot();
+        if (!room) {
+            if (current.joiningChatId || !['idle', 'error'].includes(current.phase)) await calls.leave();
+            return;
+        }
+        // callId identifies the admitted instance even while ICE is joining or
+        // waiting. Only joiningChatId represents an unadmitted candidate.
+        if (sameRoom(current, room) && !['idle', 'error'].includes(current.phase)) return;
+        const attempt = { ...room, cancelled: false };
+        pending = attempt;
+        try {
+            // The shared owner admits the destination before retiring an
+            // existing call. A stale discovery can never create a fresh call.
+            await calls.joinExisting(room.chatId, room.callId);
+        } catch (error) {
+            if (!closed && !attempt.cancelled) fail(room, error);
+        } finally {
+            if (pending === attempt) pending = null;
+            dirty = true;
+        }
+    }
+
+    function changed() {
+        if (closed) return;
+        dirty = true;
+        if (pending && !pending.cancelled && !sameRoom(pending, newest())) {
+            pending.cancelled = true;
+            void calls.cancelJoin().catch(report);
+        }
+        if (running) return;
+        running = Promise.resolve().then(async () => {
+            while (dirty && !closed) {
+                dirty = false;
+                await reconcile();
+            }
+        }).catch(report).finally(() => {
+            running = null;
+            if (dirty && !closed) changed();
+        });
+    }
+
+    function syncChats(values) {
+        if (closed) return;
+        const ids = new Set(values.filter(chat => !chat.messageRequest && !chat.membershipRemoved).map(chat => chat.id));
+        for (const [chatId, entry] of chats) {
+            if (ids.has(chatId)) continue;
+            chats.delete(chatId);
+            entry.release();
+        }
+        for (const chatId of ids) {
+            if (chats.has(chatId)) continue;
+            const entry = { room: null, failed: null, release: () => {} };
+            chats.set(chatId, entry);
+            entry.release = calls.observe(chatId, value => {
+                if (closed || chats.get(chatId) !== entry) return;
+                const room = availableRoom(value, chatId, uid);
+                if (entry.room?.fingerprint === room?.fingerprint) return;
+                entry.room = room;
+                entry.failed = null;
+                changed();
+            });
+        }
+        changed();
+    }
+
+    return Object.freeze({
+        start() {
+            startup ||= (async () => {
+                await calls.setMuted(true);
+                if (closed) return;
+                releaseCalls = calls.subscribe(() => {
+                    const { error } = calls.getSnapshot();
+                    if (error && error !== lastError && error.code !== 'calls/cancelled') {
+                        lastError = error;
+                        const entry = chats.get(error.chatId);
+                        if (entry?.room) entry.failed = entry.room.fingerprint;
+                        report(error);
+                    }
+                    changed();
+                });
+                const release = await client.chat.watch(syncChats, { count: 500 });
+                if (closed) release();
+                else releaseChats = release;
+            })();
+            return startup;
+        },
+        close() {
+            if (stopping) return stopping;
+            closed = true;
+            releaseCalls?.();
+            releaseChats?.();
+            for (const entry of chats.values()) entry.release();
+            chats.clear();
+            // leave synchronously revokes local playback/join intent. A late
+            // watch setup or old join completion cannot retain this role.
+            const leaving = calls.leave();
+            stopping = Promise.allSettled([startup, running, leaving]).then(() => undefined);
+            return stopping;
+        },
+    });
+}

package/package.json

@@ -25,6 +25,7 @@
         "examples/bot-fleet/index.js",
         "examples/bot-fleet/policy.js",
         "examples/bot-fleet/runtime.js",
+        "examples/bot-fleet/voice.js",
         "examples/bot-fleet/readme.md",
         "examples/codex-agent/agent-instructions.js",
         "examples/codex-agent/agent-state.js",
@@ -53,5 +54,5 @@
         "start": "node src/cli.js",
         "lint": "eslint src --quiet"
     },
-    "version": "0.72.0"
+    "version": "0.73.0"
 }