@elizaos/plugin-facewear 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/services/smartglasses-service.js

@@ -0,0 +1,821 @@
+import { logger, Service } from "@elizaos/core";
+import {
+  encodeAppWhitelist,
+  encodeBatteryStatusRequest,
+  encodeBmpTransfer,
+  encodeBrightness,
+  encodeClearScreen,
+  encodeConnectionReady,
+  encodeDashboard,
+  encodeDashboardCalendarItem,
+  encodeDashboardLayout,
+  encodeDashboardPosition,
+  encodeDashboardTimeWeather,
+  encodeExitFunction,
+  encodeG1MonochromeBmp,
+  encodeG1Setup,
+  encodeGetSerial,
+  encodeGlassesWear,
+  encodeHeadUpAngle,
+  encodeHeartbeat,
+  encodeMicCommand,
+  encodeNavigationDirections,
+  encodeNavigationEnd,
+  encodeNavigationInit,
+  encodeNavigationPoller,
+  encodeNavigationPrimaryImage,
+  encodeNavigationSecondaryImage,
+  encodeNoteAdd,
+  encodeNoteDelete,
+  encodeNotification,
+  encodeSilentMode,
+  encodeStartAi,
+  encodeTextPackets,
+  encodeTranslateLanguages,
+  encodeTranslateSetup,
+  encodeTranslateStart,
+  encodeTranslateText,
+  encodeVoiceNoteDelete,
+  encodeVoiceNoteDeleteAll,
+  encodeVoiceNoteFetch,
+  encodeVoiceNoteList,
+  G1AiStatus,
+  G1ScreenAction,
+  G1SubCommand,
+  G1TextStatus,
+  microphoneActionForInteractionEvent,
+  paginateDisplayText,
+  parseG1Notification,
+  pcm16ToFloat32
+} from "../protocol/smartglasses.js";
+import { getGlobalEvenBridgeTransport } from "../transport/even-bridge.js";
+import { getNobleG1Transport } from "../transport/noble.js";
+import { getWebBluetoothG1Transport } from "../transport/web-bluetooth.js";
+const SMARTGLASSES_SERVICE_NAME = "smartglasses";
+const SMARTGLASSES_EVENT = "SMARTGLASSES_EVENT";
+const SMARTGLASSES_AUDIO_EVENT = "SMARTGLASSES_AUDIO";
+const SMARTGLASSES_TRANSCRIPT_EVENT = "SMARTGLASSES_TRANSCRIPT";
+const SMARTGLASSES_TRANSPORT_SETTING = "SMARTGLASSES_TRANSPORT";
+const SMARTGLASSES_SCAN_TIMEOUT_SETTING = "SMARTGLASSES_SCAN_TIMEOUT_MS";
+const SMARTGLASSES_AUTO_INIT_SETTING = "SMARTGLASSES_AUTO_INIT";
+const SMARTGLASSES_INIT_MODE_SETTING = "SMARTGLASSES_INIT_MODE";
+const FACEWEAR_SMARTGLASSES_TRANSPORT_SETTING = "FACEWEAR_SMARTGLASSES_TRANSPORT";
+const FACEWEAR_SCAN_TIMEOUT_SETTING = "FACEWEAR_SCAN_TIMEOUT_MS";
+const FACEWEAR_AUTO_INIT_SETTING = "FACEWEAR_AUTO_INIT";
+const FACEWEAR_INIT_MODE_SETTING = "FACEWEAR_INIT_MODE";
+let injectedTransport = null;
+let injectedAudioDecoder = null;
+function setSmartglassesTransportForRuntime(transport) {
+  injectedTransport = transport;
+}
+function setSmartglassesAudioDecoderForRuntime(decoder) {
+  injectedAudioDecoder = decoder;
+}
+class SmartglassesService extends Service {
+  static serviceType = SMARTGLASSES_SERVICE_NAME;
+  capabilityDescription = "Controls Even Realities G1/G2 smartglasses display and microphone input, including side-tap mic toggles";
+  transport = null;
+  microphoneEnabled = false;
+  lastEvent = null;
+  lastTranscript = null;
+  audioChunksReceived = 0;
+  lastAudioEncoding = null;
+  lastAudioSequence = null;
+  audioSequenceGaps = 0;
+  physicalState = null;
+  batteryState = null;
+  batteryLevels = {};
+  batteryVoltagesMv = {};
+  deviceState = null;
+  lastSerialNumber = null;
+  lastWifiStatus = null;
+  displaySeq = 0;
+  heartbeatSeq = 0;
+  dashboardSeq = 0;
+  navigationSeq = 0;
+  navigationPollerSeq = 1;
+  translateSyncId = 0;
+  heartbeatTimer = null;
+  heartbeatIntervalMs = null;
+  lastHeartbeatAt = null;
+  voiceNoteSyncId = 0;
+  transcriptCallbacks = /* @__PURE__ */ new Set();
+  audioCallbacks = /* @__PURE__ */ new Set();
+  rawAudioCallbacks = /* @__PURE__ */ new Set();
+  audioDecoder = injectedAudioDecoder;
+  disposers = [];
+  static async start(runtime) {
+    const service = new SmartglassesService(runtime);
+    service.transport = injectedTransport ?? await chooseTransport(runtime);
+    if (!service.transport) {
+      logger.info(
+        "[plugin-facewear/smartglasses] no transport available; service loaded in offline/mockable mode"
+      );
+      return service;
+    }
+    await service.connect();
+    if (readBooleanSetting(
+      runtime,
+      [FACEWEAR_AUTO_INIT_SETTING, SMARTGLASSES_AUTO_INIT_SETTING],
+      true
+    )) {
+      await service.sendConnectionReady(
+        "both",
+        readConnectionReadyModeSetting(runtime)
+      );
+    }
+    return service;
+  }
+  setTransport(transport) {
+    void this.disconnect();
+    this.transport = transport;
+  }
+  async connect() {
+    if (!this.transport)
+      throw new Error("No smartglasses transport is configured");
+    if (this.transport.isConnected()) {
+      this.attachTransportListeners();
+      return;
+    }
+    await this.transport.connect();
+    this.attachTransportListeners();
+  }
+  attachTransportListeners() {
+    if (!this.transport || this.disposers.length > 0) return;
+    this.disposers.push(
+      this.transport.onEvent((event) => void this.handleEvent(event))
+    );
+    this.disposers.push(
+      this.transport.onAudio(
+        (audioData, sampleRate, side, encoding, sequence) => {
+          const audioEncoding = encoding ?? "pcm16";
+          void this.handleAudioChunk(
+            audioData,
+            sampleRate,
+            side,
+            audioEncoding,
+            sequence
+          );
+        }
+      )
+    );
+    if (this.transport.onTranscript) {
+      this.disposers.push(
+        this.transport.onTranscript((text, isFinal, metadata) => {
+          this.receiveTranscript(text, isFinal, metadata);
+        })
+      );
+    }
+    if (this.transport.onWifiStatus) {
+      this.disposers.push(
+        this.transport.onWifiStatus((status) => {
+          this.lastWifiStatus = status;
+        })
+      );
+    }
+  }
+  async disconnect() {
+    this.stopHeartbeatLoop();
+    for (const dispose of this.disposers.splice(0)) dispose();
+    if (this.transport?.isConnected()) await this.transport.disconnect();
+    this.microphoneEnabled = false;
+  }
+  async stop() {
+    await this.disconnect();
+  }
+  getStatus() {
+    return {
+      available: Boolean(this.transport),
+      connected: this.transport?.isConnected() ?? false,
+      transport: this.transport?.name ?? null,
+      microphoneEnabled: this.microphoneEnabled,
+      heartbeatRunning: Boolean(this.heartbeatTimer),
+      heartbeatIntervalMs: this.heartbeatIntervalMs,
+      lastHeartbeatAt: this.lastHeartbeatAt,
+      lastEvent: this.lastEvent,
+      lastTranscript: this.lastTranscript,
+      audioChunksReceived: this.audioChunksReceived,
+      lastAudioEncoding: this.lastAudioEncoding,
+      lastAudioSequence: this.lastAudioSequence,
+      audioSequenceGaps: this.audioSequenceGaps,
+      physicalState: this.physicalState,
+      batteryState: this.batteryState,
+      batteryLevels: { ...this.batteryLevels },
+      batteryVoltagesMv: { ...this.batteryVoltagesMv },
+      deviceState: this.deviceState,
+      lastSerialNumber: this.lastSerialNumber,
+      connectedLenses: this.transport?.getConnectedLenses?.() ?? {},
+      wifiAvailable: this.isWifiAvailable(),
+      lastWifiStatus: this.lastWifiStatus
+    };
+  }
+  async displayText(text, options = {}) {
+    if (!this.transport)
+      throw new Error("No smartglasses transport is configured");
+    if (!this.transport.isConnected()) await this.connect();
+    const pages = paginateDisplayText(text);
+    const mode = options.mode ?? "ai";
+    for (const [index, page] of pages.entries()) {
+      const seq = this.nextDisplaySeq();
+      const streamingPage = withScreenStatus(
+        page,
+        streamingStatus(mode, index)
+      );
+      for (const packet of encodeTextPackets(streamingPage, seq)) {
+        await this.transport.writeBoth(packet);
+      }
+      if (options.pageHoldMs && index < pages.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, options.pageHoldMs));
+      }
+    }
+    if (mode === "text") return { pages: pages.length };
+    if (options.completionDelayMs) {
+      await new Promise(
+        (resolve) => setTimeout(resolve, options.completionDelayMs)
+      );
+    }
+    const lastPage = pages.at(-1);
+    if (lastPage) {
+      const seq = this.nextDisplaySeq();
+      for (const packet of encodeTextPackets(
+        withScreenStatus(lastPage, G1AiStatus.DisplayComplete),
+        seq
+      )) {
+        await this.transport.writeBoth(packet);
+      }
+    }
+    return { pages: pages.length };
+  }
+  async displayRsvpText(text, options = {}) {
+    const words = text.split(/\s+/).map((word) => word.trim()).filter(Boolean);
+    if (words.length === 0) return { groups: 0, pages: 0 };
+    const wordsPerGroup = positiveIntegerOrDefault(options.wordsPerGroup, 1);
+    const paddingChar = options.paddingChar ?? "...";
+    const groups = [];
+    for (let offset = 0; offset < words.length; offset += wordsPerGroup) {
+      const group = words.slice(offset, offset + wordsPerGroup);
+      while (group.length < wordsPerGroup) group.push(paddingChar);
+      groups.push(group.join(" "));
+    }
+    let pages = 0;
+    const delayMs = rsvpDelayMs(options.wpm, wordsPerGroup);
+    for (const group of groups) {
+      const result = await this.displayText(group, { mode: options.mode });
+      pages += result.pages;
+      if (!options.skipDelay && delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    return { groups: groups.length, pages };
+  }
+  async clearDisplay() {
+    await this.writeBoth(encodeClearScreen());
+  }
+  async sendHeartbeat(seq) {
+    const effectiveSeq = seq === void 0 ? this.nextHeartbeatSeq() : seq;
+    await this.writeBoth(encodeHeartbeat(effectiveSeq));
+    this.lastHeartbeatAt = Date.now();
+  }
+  async requestBatteryStatus(side = "both") {
+    await this.sendRaw(encodeBatteryStatusRequest(), side);
+  }
+  startHeartbeatLoop(options = {}) {
+    const intervalMs = positiveIntegerOrDefault(options.intervalMs, 8e3);
+    this.stopHeartbeatLoop();
+    this.heartbeatIntervalMs = intervalMs;
+    if (options.immediate !== false) void this.sendHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      void this.sendHeartbeat().catch((error) => {
+        logger.warn(
+          { error },
+          "[plugin-facewear/smartglasses] heartbeat failed"
+        );
+      });
+    }, intervalMs);
+    this.heartbeatTimer.unref?.();
+  }
+  stopHeartbeatLoop() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    this.heartbeatIntervalMs = null;
+  }
+  async sendConnectionReady(side = "both", mode = "lens-specific") {
+    if (side === "both") {
+      await this.writeSide("left", encodeConnectionReady("left", mode));
+      await this.writeSide("right", encodeConnectionReady("right", mode));
+      return;
+    }
+    await this.writeSide(side, encodeConnectionReady(side, mode));
+  }
+  async sendStartAi(subcommand, param = new Uint8Array()) {
+    await this.writeBoth(encodeStartAi(subcommand, param));
+  }
+  async exitToDashboard() {
+    await this.sendStartAi(G1SubCommand.Exit);
+  }
+  async exitFunction() {
+    await this.writeBoth(encodeExitFunction());
+  }
+  async requestSerial(side = "both") {
+    await this.sendRaw(encodeGetSerial(), side);
+  }
+  async sendAppWhitelist(whitelist, side = "left") {
+    const packets = encodeAppWhitelist(whitelist);
+    for (const packet of packets) await this.sendRaw(packet, side);
+    return { packets: packets.length };
+  }
+  async sendG1Setup(payload, side = "left") {
+    const packets = encodeG1Setup(payload);
+    for (const packet of packets) await this.sendRaw(packet, side);
+    return { packets: packets.length };
+  }
+  async sendRaw(packet, side = "both") {
+    if (side === "both") {
+      await this.writeBoth(packet);
+      return;
+    }
+    await this.writeSide(side, packet);
+  }
+  async pageUp() {
+    await this.writeSide("left", encodeStartAi(G1SubCommand.PageControl));
+  }
+  async pageDown() {
+    await this.writeSide("right", encodeStartAi(G1SubCommand.PageControl));
+  }
+  async setMicrophoneEnabled(enabled) {
+    if (!this.transport)
+      throw new Error("No smartglasses transport is configured");
+    if (!this.transport.isConnected()) await this.connect();
+    await this.transport.openMicrophone(enabled);
+    this.microphoneEnabled = enabled;
+  }
+  async sendMicCommandPacket(enabled) {
+    if (!this.transport)
+      throw new Error("No smartglasses transport is configured");
+    if (!this.transport.isConnected()) await this.connect();
+    await this.transport.write("right", encodeMicCommand(enabled));
+    this.microphoneEnabled = enabled;
+  }
+  async setSilentMode(enabled) {
+    await this.writeBoth(encodeSilentMode(enabled));
+  }
+  async setBrightness(level, auto = false) {
+    await this.writeBoth(encodeBrightness(level, auto));
+  }
+  async setDashboard(enabled, position = 0) {
+    await this.writeBoth(encodeDashboard(enabled, position));
+  }
+  async setDashboardPosition(height, depth) {
+    await this.writeBoth(
+      encodeDashboardPosition(height, depth, this.nextDashboardSeq())
+    );
+  }
+  async setDashboardLayout(layout) {
+    await this.writeBoth(encodeDashboardLayout(layout));
+  }
+  async sendDashboardCalendarItem(payload) {
+    await this.writeBoth(encodeDashboardCalendarItem(payload));
+  }
+  async sendDashboardTimeWeather(payload) {
+    await this.writeBoth(
+      encodeDashboardTimeWeather({
+        ...payload,
+        seqId: payload.seqId ?? this.nextDashboardSeq()
+      })
+    );
+  }
+  async setHeadUpAngle(angle) {
+    await this.writeBoth(encodeHeadUpAngle(angle));
+  }
+  async setGlassesWearDetection(enabled) {
+    await this.writeBoth(encodeGlassesWear(enabled));
+  }
+  async scanWifi() {
+    const wifi = this.requireWifiCapability("scanWifi");
+    const result = await wifi.scanWifi();
+    this.lastWifiStatus = result;
+    return result;
+  }
+  async getWifiStatus() {
+    const wifi = this.requireWifiCapability("getWifiStatus");
+    const result = await wifi.getWifiStatus();
+    this.lastWifiStatus = result;
+    return result;
+  }
+  async configureWifi(ssid, password) {
+    if (!ssid.trim()) throw new Error("Wi-Fi SSID is required");
+    const wifi = this.requireWifiCapability("configureWifi");
+    const result = await wifi.configureWifi(ssid.trim(), password);
+    this.lastWifiStatus = result;
+    return result;
+  }
+  async requestWifiSetup(reason) {
+    const wifi = this.requireWifiCapability("requestWifiSetup");
+    const result = await wifi.requestWifiSetup(reason);
+    this.lastWifiStatus = result;
+    return result;
+  }
+  async startNavigation() {
+    await this.writeBoth(encodeNavigationInit(this.nextNavigationSeq()));
+  }
+  async sendNavigationDirections(payload) {
+    await this.writeBoth(
+      encodeNavigationDirections({
+        ...payload,
+        seqId: payload.seqId ?? this.nextNavigationSeq()
+      })
+    );
+  }
+  async sendNavigationPrimaryImage(image, overlay) {
+    const packets = encodeNavigationPrimaryImage(
+      image,
+      overlay,
+      this.navigationSeq
+    );
+    this.navigationSeq = this.navigationSeq + packets.length & 255;
+    for (const packet of packets) await this.writeBoth(packet);
+    return { packets: packets.length };
+  }
+  async sendNavigationSecondaryImage(image, overlay) {
+    const packets = encodeNavigationSecondaryImage(
+      image,
+      overlay,
+      this.navigationSeq
+    );
+    this.navigationSeq = this.navigationSeq + packets.length & 255;
+    for (const packet of packets) await this.writeBoth(packet);
+    return { packets: packets.length };
+  }
+  async sendNavigationPoller() {
+    await this.writeBoth(
+      encodeNavigationPoller(
+        this.nextNavigationSeq(),
+        this.nextNavigationPollerSeq()
+      )
+    );
+  }
+  async endNavigation() {
+    await this.writeBoth(encodeNavigationEnd(this.nextNavigationSeq()));
+  }
+  async sendTranslateSetup() {
+    await this.writeBoth(encodeTranslateSetup());
+  }
+  async startTranslate() {
+    await this.writeSide("right", encodeTranslateStart());
+  }
+  async setTranslateLanguages(fromLanguage, toLanguage) {
+    await this.writeBoth(encodeTranslateLanguages(fromLanguage, toLanguage));
+  }
+  async sendTranslateText(kind, text, syncId) {
+    const effectiveSyncId = syncId ?? this.nextTranslateSyncId();
+    await this.writeBoth(encodeTranslateText(kind, text, effectiveSyncId));
+    return { syncId: effectiveSyncId };
+  }
+  async addOrUpdateNote(noteNumber, title, text) {
+    await this.writeBoth(encodeNoteAdd(noteNumber, title, text));
+  }
+  async deleteNote(noteNumber) {
+    await this.writeBoth(encodeNoteDelete(noteNumber));
+  }
+  async requestVoiceNoteAudio(noteIndex, options = {}) {
+    const syncId = options.syncId ?? this.nextVoiceNoteSyncId();
+    await this.writeSide(
+      options.side ?? "right",
+      encodeVoiceNoteFetch(noteIndex, syncId)
+    );
+    return { syncId };
+  }
+  async requestVoiceNoteList(options = {}) {
+    const syncId = options.syncId ?? this.nextVoiceNoteSyncId();
+    await this.writeSide(options.side ?? "right", encodeVoiceNoteList(syncId));
+    return { syncId };
+  }
+  async deleteVoiceNoteAudio(noteIndex, options = {}) {
+    const syncId = options.syncId ?? this.nextVoiceNoteSyncId();
+    await this.writeSide(
+      options.side ?? "right",
+      encodeVoiceNoteDelete(noteIndex, syncId)
+    );
+    return { syncId };
+  }
+  async deleteAllVoiceNoteAudio(options = {}) {
+    const syncId = options.syncId ?? this.nextVoiceNoteSyncId();
+    await this.writeSide(
+      options.side ?? "right",
+      encodeVoiceNoteDeleteAll(syncId)
+    );
+    return { syncId };
+  }
+  async sendNotification(payload) {
+    const packets = encodeNotification(payload);
+    for (const packet of packets) await this.writeBoth(packet);
+    return { packets: packets.length };
+  }
+  async sendBmpImage(imageData) {
+    const packets = encodeBmpTransfer(imageData);
+    for (const packet of packets) await this.writeBoth(packet);
+    return { packets: packets.length };
+  }
+  async sendMonochromeBmpImage(pixels, options = {}) {
+    const imageData = encodeG1MonochromeBmp(pixels, options);
+    const result = await this.sendBmpImage(imageData);
+    return { ...result, bytes: imageData.length };
+  }
+  onTranscript(callback) {
+    this.transcriptCallbacks.add(callback);
+    return () => this.transcriptCallbacks.delete(callback);
+  }
+  onAudio(callback) {
+    this.audioCallbacks.add(callback);
+    return () => this.audioCallbacks.delete(callback);
+  }
+  onRawAudio(callback) {
+    this.rawAudioCallbacks.add(callback);
+    return () => this.rawAudioCallbacks.delete(callback);
+  }
+  setAudioDecoder(decoder) {
+    this.audioDecoder = decoder;
+  }
+  receiveTranscript(text, isFinal = true, metadata) {
+    this.lastTranscript = text;
+    for (const callback of this.transcriptCallbacks) callback(text, isFinal);
+    void this.emitPluginEvent(SMARTGLASSES_TRANSCRIPT_EVENT, {
+      text,
+      isFinal,
+      metadata
+    });
+  }
+  async receiveExternalRawEvent(side, data, options = {}) {
+    const event = parseG1Notification(side, data);
+    await this.handleEvent(event, options);
+    return event;
+  }
+  async receiveExternalAudioChunk(audioData, options = {}) {
+    await this.handleAudioChunk(
+      audioData,
+      options.sampleRate ?? 16e3,
+      options.side ?? "right",
+      options.encoding ?? "lc3",
+      options.sequence
+    );
+  }
+  async handleAudioChunk(audioData, sampleRate, side, audioEncoding, sequence) {
+    this.audioChunksReceived += 1;
+    this.lastAudioEncoding = audioEncoding;
+    if (sequence !== void 0) {
+      if (this.lastAudioSequence !== null && (this.lastAudioSequence + 1 & 255) !== sequence) {
+        this.audioSequenceGaps += 1;
+      }
+      this.lastAudioSequence = sequence;
+    }
+    for (const callback of this.rawAudioCallbacks)
+      callback(audioData, sampleRate, side, audioEncoding, sequence);
+    const payload = {
+      side,
+      sampleRate,
+      audioData,
+      audioEncoding,
+      audioSequenceGaps: this.audioSequenceGaps
+    };
+    if (sequence !== void 0) payload.sequence = sequence;
+    const audioPcm = audioEncoding === "pcm16" ? audioData : await this.decodeAudioChunk(
+      audioData,
+      sampleRate,
+      side,
+      audioEncoding,
+      sequence
+    );
+    if (audioPcm) {
+      const pcm = pcm16ToFloat32(audioPcm);
+      for (const callback of this.audioCallbacks)
+        callback(pcm, sampleRate, side);
+      payload.audioPcm = audioPcm;
+      payload.decodedAudioEncoding = "pcm16";
+    }
+    void this.emitPluginEvent(SMARTGLASSES_AUDIO_EVENT, {
+      ...payload
+    });
+  }
+  async decodeAudioChunk(audioData, sampleRate, side, audioEncoding, sequence) {
+    if (!this.audioDecoder) return null;
+    try {
+      return await this.audioDecoder(audioData, {
+        sampleRate,
+        side,
+        encoding: audioEncoding,
+        sequence
+      }) ?? null;
+    } catch (error) {
+      logger.warn(
+        { error },
+        "[plugin-facewear/smartglasses] audio decoder failed; raw audio event preserved"
+      );
+      return null;
+    }
+  }
+  async handleEvent(event, options = {}) {
+    this.lastEvent = event;
+    void this.emitPluginEvent(SMARTGLASSES_EVENT, { event });
+    if (event.type === "mic-response" && typeof event.micEnabled === "boolean") {
+      this.microphoneEnabled = event.micEnabled;
+    }
+    if (event.type === "state") {
+      if (event.stateCategory === "physical") {
+        this.physicalState = event.stateName ?? event.label ?? null;
+      } else if (event.stateCategory === "battery") {
+        this.batteryState = event.stateName ?? event.label ?? null;
+      } else if (event.stateCategory === "device") {
+        this.deviceState = event.stateName ?? event.label ?? null;
+      }
+      const applyControls = options.applyControls !== false;
+      const microphoneAction = microphoneActionForInteractionEvent(event);
+      if (microphoneAction) {
+        const enabled = microphoneAction === "enable";
+        if (applyControls) await this.setMicrophoneEnabled(enabled);
+        else this.microphoneEnabled = enabled;
+      }
+      if (applyControls && event.label === "scroll_up") await this.pageUp();
+      if (applyControls && event.label === "scroll_down") await this.pageDown();
+    }
+    if (event.type === "serial" && event.serialNumber) {
+      this.lastSerialNumber = event.serialNumber;
+    }
+    if (event.type === "battery-status" && typeof event.batteryPercent === "number") {
+      this.batteryLevels[event.side] = event.batteryPercent;
+      if (typeof event.batteryVoltageMv === "number") {
+        this.batteryVoltagesMv[event.side] = event.batteryVoltageMv;
+      }
+    }
+  }
+  async writeBoth(packet) {
+    if (!this.transport)
+      throw new Error("No smartglasses transport is configured");
+    if (!this.transport.isConnected()) await this.connect();
+    await this.transport.writeBoth(packet);
+  }
+  async writeSide(side, packet) {
+    if (!this.transport)
+      throw new Error("No smartglasses transport is configured");
+    if (!this.transport.isConnected()) await this.connect();
+    await this.transport.write(side, packet);
+  }
+  requireWifiCapability(method) {
+    if (!this.transport)
+      throw new Error("No smartglasses transport is configured");
+    if (!this.isWifiAvailable() || !this.transport[method]) {
+      throw new Error(
+        "Wi-Fi is only available through a native smartglasses bridge transport"
+      );
+    }
+    return this.transport;
+  }
+  isWifiAvailable() {
+    if (!this.transport) return false;
+    if (this.transport.supportsWifi) return this.transport.supportsWifi();
+    return Boolean(
+      this.transport.scanWifi || this.transport.getWifiStatus || this.transport.configureWifi || this.transport.requestWifiSetup
+    );
+  }
+  nextDisplaySeq() {
+    const seq = this.displaySeq & 255;
+    this.displaySeq = this.displaySeq + 1 & 255;
+    return seq;
+  }
+  nextHeartbeatSeq() {
+    const seq = this.heartbeatSeq & 255;
+    this.heartbeatSeq = this.heartbeatSeq + 1 & 255;
+    return seq;
+  }
+  nextDashboardSeq() {
+    const seq = this.dashboardSeq & 255;
+    this.dashboardSeq = this.dashboardSeq + 1 & 255;
+    return seq;
+  }
+  nextNavigationSeq() {
+    const seq = this.navigationSeq & 255;
+    this.navigationSeq = this.navigationSeq + 1 & 255;
+    return seq;
+  }
+  nextNavigationPollerSeq() {
+    const seq = this.navigationPollerSeq & 255;
+    this.navigationPollerSeq = this.navigationPollerSeq + 1 & 255;
+    return seq;
+  }
+  nextVoiceNoteSyncId() {
+    const syncId = this.voiceNoteSyncId & 255;
+    this.voiceNoteSyncId = this.voiceNoteSyncId + 1 & 255;
+    return syncId;
+  }
+  nextTranslateSyncId() {
+    this.translateSyncId = this.translateSyncId + 1 & 255;
+    return this.translateSyncId;
+  }
+  async emitPluginEvent(eventName, payload) {
+    if (!this.runtime) return;
+    await this.runtime.emitEvent(eventName, {
+      runtime: this.runtime,
+      source: "@elizaos/plugin-facewear",
+      ...payload
+    });
+  }
+}
+function getSmartglassesService(runtime) {
+  return runtime.getService(SMARTGLASSES_SERVICE_NAME) ?? null;
+}
+async function chooseTransport(runtime) {
+  const preferred = normalizePreferredTransport(
+    readFirstSetting(runtime, [
+      FACEWEAR_SMARTGLASSES_TRANSPORT_SETTING,
+      SMARTGLASSES_TRANSPORT_SETTING
+    ])
+  );
+  const scanTimeoutMs = readPositiveIntegerSetting(runtime, [
+    FACEWEAR_SCAN_TIMEOUT_SETTING,
+    SMARTGLASSES_SCAN_TIMEOUT_SETTING
+  ]);
+  if (preferred === "even-bridge") return getGlobalEvenBridgeTransport();
+  if (preferred === "web-bluetooth") return getWebBluetoothG1Transport();
+  if (preferred === "noble") return getNobleG1Transport({ scanTimeoutMs });
+  return getGlobalEvenBridgeTransport() ?? getWebBluetoothG1Transport() ?? await getNobleG1Transport({ scanTimeoutMs });
+}
+function readSetting(runtime, key) {
+  return runtime.getSetting?.(key) ?? (typeof process !== "undefined" ? process.env[key] : void 0);
+}
+function readFirstSetting(runtime, keys) {
+  for (const key of keys) {
+    const value = readSetting(runtime, key);
+    if (value !== void 0 && value !== null && value !== "") return value;
+  }
+  return void 0;
+}
+function normalizePreferredTransport(value) {
+  if (typeof value !== "string") return "auto";
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "even-bridge" || normalized === "web-bluetooth" || normalized === "noble") {
+    return normalized;
+  }
+  return "auto";
+}
+function readPositiveIntegerSetting(runtime, keys) {
+  const value = Array.isArray(keys) ? readFirstSetting(runtime, keys) : readSetting(runtime, keys);
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function readBooleanSetting(runtime, keys, fallback) {
+  const value = Array.isArray(keys) ? readFirstSetting(runtime, keys) : readSetting(runtime, keys);
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") {
+    if (/^(false|0|no|off|disabled)$/i.test(value.trim())) return false;
+    if (/^(true|1|yes|on|enabled)$/i.test(value.trim())) return true;
+  }
+  return fallback;
+}
+function readConnectionReadyModeSetting(runtime) {
+  const value = String(
+    readFirstSetting(runtime, [
+      FACEWEAR_INIT_MODE_SETTING,
+      SMARTGLASSES_INIT_MODE_SETTING
+    ]) ?? ""
+  ).trim().toLowerCase();
+  if (value === "official" || value === "official-app" || value === "even-demo-app" || value === "same-init")
+    return "official";
+  if (value === "android-f4" || value === "android" || value === "even-demo-android" || value === "f4")
+    return "android-f4";
+  return "lens-specific";
+}
+function withScreenStatus(page, screenStatus) {
+  return { ...page, screenStatus };
+}
+function streamingStatus(mode, pageIndex) {
+  if (mode === "text") return G1TextStatus.TextShow | G1ScreenAction.NewContent;
+  return pageIndex === 0 ? G1AiStatus.Displaying | G1ScreenAction.NewContent : G1AiStatus.Displaying;
+}
+function positiveIntegerOrDefault(value, fallback) {
+  return Number.isInteger(value) && Number(value) > 0 ? Number(value) : fallback;
+}
+function rsvpDelayMs(wpm, wordsPerGroup) {
+  if (!Number.isFinite(wpm) || Number(wpm) <= 0) return 0;
+  return Math.max(0, Math.round(6e4 / Number(wpm) * wordsPerGroup));
+}
+export {
+  FACEWEAR_AUTO_INIT_SETTING,
+  FACEWEAR_INIT_MODE_SETTING,
+  FACEWEAR_SCAN_TIMEOUT_SETTING,
+  FACEWEAR_SMARTGLASSES_TRANSPORT_SETTING,
+  SMARTGLASSES_AUDIO_EVENT,
+  SMARTGLASSES_AUTO_INIT_SETTING,
+  SMARTGLASSES_EVENT,
+  SMARTGLASSES_INIT_MODE_SETTING,
+  SMARTGLASSES_SCAN_TIMEOUT_SETTING,
+  SMARTGLASSES_SERVICE_NAME,
+  SMARTGLASSES_TRANSCRIPT_EVENT,
+  SMARTGLASSES_TRANSPORT_SETTING,
+  SmartglassesService,
+  getSmartglassesService,
+  setSmartglassesAudioDecoderForRuntime,
+  setSmartglassesTransportForRuntime
+};
+//# sourceMappingURL=smartglasses-service.js.map