@m1kad0/hannah-proto 4.5.0 → 4.6.0

package/dist/v1/satellite_provisioning.js

@@ -0,0 +1,84 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.1
+//   protoc               unknown
+// source: hannah/v1/satellite_provisioning.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProvisionSatelliteRequest = exports.protobufPackage = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+exports.protobufPackage = "hannah.v1";
+function createBaseProvisionSatelliteRequest() {
+    return { seed: "", displayName: "", roomId: "" };
+}
+exports.ProvisionSatelliteRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.seed !== "") {
+            writer.uint32(10).string(message.seed);
+        }
+        if (message.displayName !== "") {
+            writer.uint32(18).string(message.displayName);
+        }
+        if (message.roomId !== "") {
+            writer.uint32(26).string(message.roomId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseProvisionSatelliteRequest();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.seed = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.displayName = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.roomId = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.ProvisionSatelliteRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseProvisionSatelliteRequest();
+        message.seed = object.seed ?? "";
+        message.displayName = object.displayName ?? "";
+        message.roomId = object.roomId ?? "";
+        return message;
+    },
+};

package/dist/v1/satellite_proxy.d.ts

@@ -0,0 +1,100 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "hannah.v1";
+/** Sent by the proxy periodically to keep the RegisterProxy stream alive. */
+export interface ProxyHeartbeat {
+    /** human-readable identifier, e.g. "hannah-proxy-living-room" */
+    proxyId: string;
+    /**
+     * UDP address the proxy is listening on for satellite connections.
+     * When set, Hannah publishes this address to the discovery topic so
+     * satellites connect to the proxy instead of Hannah's own UDP server.
+     */
+    udpHost: string;
+    /** UDP port, e.g. 7775 */
+    udpPort: number;
+}
+/** Sent by Hannah to the proxy over the RegisterProxy stream. */
+export interface ProxyCommand {
+    /** initial confirmation when stream is established */
+    ack?: ProxyAck | undefined;
+    /** Hannah wants the proxy to play TTS on a satellite */
+    playAudio?: PlayAudioCommand | undefined;
+}
+/** Sent once by Hannah after RegisterProxy stream is established. */
+export interface ProxyAck {
+    /** true = Hannah has disabled its own UDP server */
+    udpDisabled: boolean;
+    /** human-readable status, e.g. "UDP server stopped" */
+    message: string;
+}
+/**
+ * Hannah instructs the proxy to play TTS audio on a specific satellite.
+ * Used for announcements and other server-initiated audio.
+ * For streaming: Hannah sends multiple PlayAudioCommands with chunks of PCM.
+ * is_last=true on the final chunk signals the proxy to send tts_end to the satellite.
+ */
+export interface PlayAudioCommand {
+    /** satellite device name (as registered via UDP or proxy) */
+    deviceId: string;
+    /** raw PCM, 16-bit signed mono */
+    audioPcm: Uint8Array;
+    /** e.g. 24000 (Azure) or 16000 (Piper) */
+    sampleRate: number;
+    /** true on the last chunk of a TTS response */
+    isLast: boolean;
+}
+/** Sent by the proxy when a satellite has finished recording an utterance. */
+export interface SubmitSatelliteAudioRequest {
+    /** satellite device name */
+    deviceId: string;
+    /** room name (from proxy registration / config) */
+    room: string;
+    /** raw PCM, 16-bit signed mono, 16000 Hz */
+    audioPcm: Uint8Array;
+    /** sample rate of the audio (typically 16000) */
+    sampleRate: number;
+}
+export interface SubmitSatelliteAudioResponse {
+    /** STT result */
+    transcript: string;
+    /** text answer from Hannah */
+    answer: string;
+    /** e.g. "TurnOn", "CarQuery", "Unknown" */
+    intentName: string;
+    /** TTS response as raw PCM, 16-bit signed mono */
+    audioPcm: Uint8Array;
+    /** sample rate of audio_pcm */
+    sampleRate: number;
+}
+export interface SatelliteRegistration {
+    /** satellite device_id (== eFuse MAC since v0.34), e.g. "e072a1d01adc" */
+    deviceId: string;
+    /** IP of the UDP satellite as seen by the proxy, e.g. "192.168.8.42" */
+    address: string;
+    /** one-time pairing token from NVS (empty after successful pairing) */
+    seed: string;
+}
+export declare const ProxyHeartbeat: MessageFns<ProxyHeartbeat>;
+export declare const ProxyCommand: MessageFns<ProxyCommand>;
+export declare const ProxyAck: MessageFns<ProxyAck>;
+export declare const PlayAudioCommand: MessageFns<PlayAudioCommand>;
+export declare const SubmitSatelliteAudioRequest: MessageFns<SubmitSatelliteAudioRequest>;
+export declare const SubmitSatelliteAudioResponse: MessageFns<SubmitSatelliteAudioResponse>;
+export declare const SatelliteRegistration: MessageFns<SatelliteRegistration>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = T extends bigint ? string | number | bigint : T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};