@dronedeploy/rocos-js-sdk 4.4.5 → 4.4.7

package/cjs/services/robot-status/connectivity.d.ts

@@ -36,18 +36,19 @@ export declare const buildConnectionsUrl: (serviceId: string, baseUrl: string, p
 export declare const mapConnectionStatus: (connection?: IConnectedCallsign | null) => ServiceConnection;
 /**
  * Aggregates per-service connection states into an overall verdict:
- * - `ONLINE`   — at least one service connected and none disconnected.
- * - `DEGRADED` — a genuine mix: some connected, some disconnected.
+ * - `DEGRADED` — any service reports an explicit `FAILED` fault, or a genuine mix (some connected,
+ *                some disconnected).
+ * - `ONLINE`   — at least one service connected and none disconnected or failed.
  * - `OFFLINE`  — nothing connected.
  *
- * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup
- * settles on `OFFLINE` (gray) rather than a spurious flashing-red degraded state.
+ * A `FAILED` service forces `DEGRADED` even when nothing else is connected, so a fault (e.g. a failed
+ * deployment) raises attention rather than reading as a plain, switched-off `OFFLINE`.
  *
- * Note: this optimism also means a service held `UNKNOWN` indefinitely (e.g. an
- * endpoint whose polls keep failing) does not by itself pull the aggregate below
- * `ONLINE` — a deliberate v1 tradeoff to keep transient errors from flapping the
- * indicator. Surfacing a long-lived failure distinctly (likely via health rather
- * than connectivity) is left as a future refinement.
+ * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup settles on `OFFLINE`
+ * (gray) rather than a spurious flashing-red degraded state. This optimism also means a service held
+ * `UNKNOWN` indefinitely (e.g. an endpoint whose polls keep failing) does not by itself pull the
+ * aggregate below `ONLINE` — a deliberate tradeoff to keep transient errors from flapping the
+ * indicator; a service that wants to be surfaced reports `FAILED` explicitly.
  */
 export declare const aggregateConnectivity: (services: Record<string, ServiceConnection>) => RobotConnectivity;
 /**
@@ -66,11 +67,14 @@ export interface ConnectivityDeps {
     insecure?: boolean;
     /** The telemetry-liveness signal (from `getTelemetryLiveness`), folded in as one service. */
     telemetryLiveness$: Observable<ServiceConnection>;
+    /** Caller-injected connectivity signals, keyed by service id, folded in on equal footing. */
+    extraServices?: Record<string, Observable<ServiceConnection>>;
 }
 /**
  * Emits the robot's {@link RobotConnectivityStatus} — the per-service breakdown
- * plus the aggregate verdict — for the configured `expectedServices`. HTTP
- * services are polled; `telemetry-liveness` uses the supplied observable; any
- * unrecognised service id resolves to `UNKNOWN`.
+ * plus the aggregate verdict — for the configured `expectedServices`, plus any
+ * caller-injected `extraServices` (folded in on equal footing). HTTP services
+ * are polled; `telemetry-liveness` and injected services use their supplied
+ * observable; any unrecognised service id resolves to `UNKNOWN`.
  */
 export declare const getConnectivityChanges: (deps: ConnectivityDeps, projectId: string, callsign: string, expectedServices?: string[], pollMs?: number) => Observable<RobotConnectivityStatus>;

package/cjs/services/robot-status/connectivity.js

@@ -58,21 +58,24 @@ const mapConnectionStatus = (connection) => {
 exports.mapConnectionStatus = mapConnectionStatus;
 /**
  * Aggregates per-service connection states into an overall verdict:
- * - `ONLINE`   — at least one service connected and none disconnected.
- * - `DEGRADED` — a genuine mix: some connected, some disconnected.
+ * - `DEGRADED` — any service reports an explicit `FAILED` fault, or a genuine mix (some connected,
+ *                some disconnected).
+ * - `ONLINE`   — at least one service connected and none disconnected or failed.
  * - `OFFLINE`  — nothing connected.
  *
- * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup
- * settles on `OFFLINE` (gray) rather than a spurious flashing-red degraded state.
+ * A `FAILED` service forces `DEGRADED` even when nothing else is connected, so a fault (e.g. a failed
+ * deployment) raises attention rather than reading as a plain, switched-off `OFFLINE`.
  *
- * Note: this optimism also means a service held `UNKNOWN` indefinitely (e.g. an
- * endpoint whose polls keep failing) does not by itself pull the aggregate below
- * `ONLINE` — a deliberate v1 tradeoff to keep transient errors from flapping the
- * indicator. Surfacing a long-lived failure distinctly (likely via health rather
- * than connectivity) is left as a future refinement.
+ * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup settles on `OFFLINE`
+ * (gray) rather than a spurious flashing-red degraded state. This optimism also means a service held
+ * `UNKNOWN` indefinitely (e.g. an endpoint whose polls keep failing) does not by itself pull the
+ * aggregate below `ONLINE` — a deliberate tradeoff to keep transient errors from flapping the
+ * indicator; a service that wants to be surfaced reports `FAILED` explicitly.
  */
 const aggregateConnectivity = (services) => {
     const values = Object.values(services);
+    if (values.includes(models_1.ServiceConnection.FAILED))
+        return models_1.RobotConnectivity.DEGRADED;
     const hasConnected = values.includes(models_1.ServiceConnection.CONNECTED);
     const hasDisconnected = values.includes(models_1.ServiceConnection.DISCONNECTED);
     if (hasConnected && hasDisconnected)
@@ -107,24 +110,32 @@ const connectivityEquals = (a, b) => {
 };
 /**
  * Emits the robot's {@link RobotConnectivityStatus} — the per-service breakdown
- * plus the aggregate verdict — for the configured `expectedServices`. HTTP
- * services are polled; `telemetry-liveness` uses the supplied observable; any
- * unrecognised service id resolves to `UNKNOWN`.
+ * plus the aggregate verdict — for the configured `expectedServices`, plus any
+ * caller-injected `extraServices` (folded in on equal footing). HTTP services
+ * are polled; `telemetry-liveness` and injected services use their supplied
+ * observable; any unrecognised service id resolves to `UNKNOWN`.
  */
 const getConnectivityChanges = (deps, projectId, callsign, expectedServices = exports.DEFAULT_EXPECTED_SERVICES, pollMs = DEFAULT_CONNECTIVITY_POLL_MS) => {
+    const extraServices = deps.extraServices ?? {};
+    const serviceIds = [...expectedServices, ...Object.keys(extraServices).filter((id) => !expectedServices.includes(id))];
     // combineLatest([]) completes without emitting; emit an explicit empty/offline status instead.
-    if (expectedServices.length === 0) {
+    if (serviceIds.length === 0) {
         return (0, rxjs_1.of)({ overall: models_1.RobotConnectivity.OFFLINE, services: {} });
     }
-    const perService = expectedServices.map((serviceId) => {
+    const perService = serviceIds.map((serviceId) => {
         let source$;
         if (serviceId === exports.TELEMETRY_LIVENESS_SERVICE) {
             source$ = deps.telemetryLiveness$;
         }
-        else if (serviceId in exports.CONNECTION_SERVICE_PREFIXES) {
+        else if (Object.prototype.hasOwnProperty.call(exports.CONNECTION_SERVICE_PREFIXES, serviceId)) {
             const url = (0, exports.buildConnectionsUrl)(serviceId, deps.baseUrl, projectId, callsign, deps.insecure);
             source$ = (0, exports.getServiceConnectionChanges)(deps.httpGet, url, pollMs);
         }
+        else if (Object.prototype.hasOwnProperty.call(extraServices, serviceId)) {
+            // Contain an injected observable's errors as UNKNOWN, mirroring the built-in sources, so a
+            // faulty caller signal can't error out combineLatest and tear down the whole aggregate.
+            source$ = extraServices[serviceId].pipe((0, rxjs_1.catchError)(() => (0, rxjs_1.of)(models_1.ServiceConnection.UNKNOWN)));
+        }
         else {
             source$ = (0, rxjs_1.of)(models_1.ServiceConnection.UNKNOWN);
         }

package/cjs/services/robot-status/reportedStatus.d.ts

@@ -1,10 +1,12 @@
 import { Observable } from 'rxjs';
-import { RobotHealth, RobotReadiness, ServiceConnection } from '../../models';
+import { RobotHealth, RobotReadiness, RobotStatusContributors, ServiceConnection } from '../../models';
 import { TelemetryService } from '../TelemetryService';
 /** The new agent topic carrying health + readiness (replaces the heartbeat). */
 export declare const ROBOT_STATUS_SOURCE = "/diagnostics/robot/status";
 /** The legacy heartbeat topic — liveness only, no status payload. */
 export declare const LEGACY_HEARTBEAT_SOURCE = "/rocos/agent/telemetry/heartbeat";
+/** The per-contributor breakdown behind the reported status (health + readiness). */
+export declare const ROBOT_STATUS_CONTRIBUTORS_SOURCE = "/diagnostics/robot/status/contributors";
 export interface ReportedRobotStatus {
     health: RobotHealth;
     readiness: RobotReadiness;
@@ -28,6 +30,17 @@ export declare const parseRobotReadiness: (value: unknown) => RobotReadiness;
  * new topic.
  */
 export declare const getReportedStatusChanges: (telemetry: TelemetryService, projectId: string, callsign: string) => Observable<ReportedRobotStatus>;
+/**
+ * Emits the per-contributor breakdown behind the robot's reported health and
+ * readiness, from the agent's `robot/status/contributors` topic. Each
+ * contributor's integer wire value is mapped onto {@link RobotHealth} /
+ * {@link RobotReadiness}; a missing `health`/`readiness` array becomes `[]`.
+ *
+ * Starts with an empty breakdown so consumers combining this with other streams
+ * emit immediately, and — like {@link getReportedStatusChanges} — a telemetry
+ * error falls back to an empty breakdown rather than terminating the stream.
+ */
+export declare const getStatusContributorsChanges: (telemetry: TelemetryService, projectId: string, callsign: string) => Observable<RobotStatusContributors>;
 /**
  * Emits the `telemetry-liveness` connectivity signal: whether a heartbeat (from
  * either the new `robot/status` topic or the legacy heartbeat) has been received

package/cjs/services/robot-status/reportedStatus.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTelemetryLiveness = exports.getReportedStatusChanges = exports.parseRobotReadiness = exports.parseRobotHealth = exports.LEGACY_HEARTBEAT_SOURCE = exports.ROBOT_STATUS_SOURCE = void 0;
+exports.getTelemetryLiveness = exports.getStatusContributorsChanges = exports.getReportedStatusChanges = exports.parseRobotReadiness = exports.parseRobotHealth = exports.ROBOT_STATUS_CONTRIBUTORS_SOURCE = exports.LEGACY_HEARTBEAT_SOURCE = exports.ROBOT_STATUS_SOURCE = void 0;
 const rxjs_1 = require("rxjs");
 const models_1 = require("../../models");
 /** The new agent topic carrying health + readiness (replaces the heartbeat). */
 exports.ROBOT_STATUS_SOURCE = '/diagnostics/robot/status';
 /** The legacy heartbeat topic — liveness only, no status payload. */
 exports.LEGACY_HEARTBEAT_SOURCE = '/rocos/agent/telemetry/heartbeat';
+/** The per-contributor breakdown behind the reported status (health + readiness). */
+exports.ROBOT_STATUS_CONTRIBUTORS_SOURCE = `${exports.ROBOT_STATUS_SOURCE}/contributors`;
 const DEFAULT_HEARTBEAT_TIMEOUT_MS = 5000;
 const DEFAULT_INTERVAL_MS = 2000;
 /**
@@ -84,6 +86,39 @@ const getReportedStatusChanges = (telemetry, projectId, callsign) => {
     (0, rxjs_1.catchError)(() => (0, rxjs_1.of)({ health: models_1.RobotHealth.UNKNOWN, readiness: models_1.RobotReadiness.UNKNOWN })));
 };
 exports.getReportedStatusChanges = getReportedStatusChanges;
+const toContributor = (raw, parse) => ({
+    id: raw.id ?? '',
+    component: raw.component ?? '',
+    reason: raw.reason ?? '',
+    status: parse(raw.value),
+});
+const EMPTY_CONTRIBUTORS = { health: [], readiness: [] };
+/**
+ * Emits the per-contributor breakdown behind the robot's reported health and
+ * readiness, from the agent's `robot/status/contributors` topic. Each
+ * contributor's integer wire value is mapped onto {@link RobotHealth} /
+ * {@link RobotReadiness}; a missing `health`/`readiness` array becomes `[]`.
+ *
+ * Starts with an empty breakdown so consumers combining this with other streams
+ * emit immediately, and — like {@link getReportedStatusChanges} — a telemetry
+ * error falls back to an empty breakdown rather than terminating the stream.
+ */
+const getStatusContributorsChanges = (telemetry, projectId, callsign) => {
+    return telemetry
+        .subscribe({
+        projectId,
+        callsigns: [callsign],
+        sources: [exports.ROBOT_STATUS_CONTRIBUTORS_SOURCE],
+    })
+        .pipe((0, rxjs_1.map)((message) => {
+        const payload = message.payload ?? {};
+        return {
+            health: (payload.health ?? []).map((c) => toContributor(c, exports.parseRobotHealth)),
+            readiness: (payload.readiness ?? []).map((c) => toContributor(c, exports.parseRobotReadiness)),
+        };
+    }), (0, rxjs_1.startWith)(EMPTY_CONTRIBUTORS), (0, rxjs_1.distinctUntilChanged)((a, b) => JSON.stringify(a) === JSON.stringify(b)), (0, rxjs_1.catchError)(() => (0, rxjs_1.of)(EMPTY_CONTRIBUTORS)));
+};
+exports.getStatusContributorsChanges = getStatusContributorsChanges;
 /**
  * Emits the `telemetry-liveness` connectivity signal: whether a heartbeat (from
  * either the new `robot/status` topic or the legacy heartbeat) has been received

package/esm/api/StreamRegister.js

@@ -79,13 +79,13 @@ export class StreamRegister {
             return;
         // Wait for init to settle before tearing down, so init can never open resources on an already
         // stopped stream. A re-acquire in the meantime revives the entry and cancels the teardown.
-        void entry.ready
-            .catch(() => undefined)
-            .then(() => {
+        const evictIfUnheld = () => {
             if (this.entries.get(identifier) === entry && entry.refCount <= 0) {
                 this.evict(identifier, entry.stream);
             }
-        })
+        };
+        void entry.ready
+            .then(() => evictIfUnheld(), () => evictIfUnheld())
             .catch((e) => this.logger.error(`Failed to evict stream. identifier: ${identifier}`, e));
     }
     evict(identifier, stream) {

package/esm/api/streams/caller/CallerStreamAbstract.js

@@ -26,7 +26,8 @@ export class CallerStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     invokeRequest(params) {
         this.logger.info('invokeRequest', params);

package/esm/api/streams/command/CommandStreamAbstract.js

@@ -28,7 +28,8 @@ export class CommandStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     invokeRequest(params) {
         if (params.timeoutMs === undefined || params.timeoutMs === null) {

package/esm/api/streams/control/ControlStreamAbstract.js

@@ -25,7 +25,8 @@ export class ControlStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     takeActionWithAck(action, params, ackTimeoutInSeconds = 15) {
         return new Observable((emitter) => {

package/esm/api/streams/fileAccessor/FileAccessorStreamAbstract.js

@@ -24,7 +24,8 @@ export class FileAccessorStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     async serverReqOp(params) {
         return this.serverReqOpInternal(params);

package/esm/api/streams/search/SearchStreamAbstract.js

@@ -25,7 +25,8 @@ export class SearchStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     searchStream(params) {
         const request = this.convertToQueryMessage(params.query);

package/esm/api/streams/telemetry/TelemetryStream.js

@@ -21,6 +21,7 @@ export class TelemetryStream extends TelemetryStreamAbstract {
         this.client = new TelemetryGatewayClient(transport);
     }
     stopInternal() {
+        this.subscriberId = undefined;
         if (this.abortController) {
             this.logger.info('Starting stop stream process');
             this.abortController.abort();

package/esm/api/streams/telemetry/TelemetryStreamAbstract.js

@@ -1,7 +1,7 @@
 import { BehaviorSubject, Subject } from 'rxjs';
 import { CallsignsLookup, RocosTelemetryMessage, StreamOptions, SubscriberStatusEnum, } from '../../../models';
 import { GRPC_SOURCE_NOOP, GRPC_SOURCE_SUBSCRIBED } from '../../../constants/grpc';
-import { QueryOrPredicate, TelemetryAckStatus, TelemetryQueryRequest, TelemetryRequest, UnsubscribeOperation, } from '../../../grpc/teletubby_pb';
+import { QueryOrPredicate, TelemetryAckStatus, TelemetryAction, TelemetryQueryRequest, TelemetryRequest, UnsubscribeOperation, } from '../../../grpc/teletubby_pb';
 import { IDENTIFIER_NAME_TELEMETRY } from '../../../constants/identifier';
 import { RocosStore } from '../../../store/RocosStore';
 import { StreamHeartbeat } from '../../atoms/StreamHeartbeat';
@@ -10,6 +10,33 @@ import { arrayRemove } from '../../../helpers/arrayRemove';
 import { arrayUnique } from '../../../helpers/arrayUnique';
 import { filter } from 'rxjs/operators';
 import { getSubscriptionsDifference } from '../../../helpers/getSubscriptionsDifference';
+const telemetryActionQueueStates = new WeakMap();
+const resolveTelemetryActions = (actions) => {
+    actions.forEach((action) => action.resolve());
+};
+const resolveUnsentTelemetryActions = (queueState) => {
+    resolveTelemetryActions(queueState.pendingActions.splice(0));
+};
+const takeNextTelemetryBatch = (queueState) => {
+    const firstAction = queueState.pendingActions.shift();
+    if (!firstAction)
+        return [];
+    const activeBatch = [firstAction];
+    if (firstAction.callsignsLookup.isQuery() || firstAction.terminate)
+        return activeBatch;
+    while (queueState.pendingActions.length > 0) {
+        const [nextAction] = queueState.pendingActions;
+        if (nextAction.callsignsLookup.isQuery() ||
+            nextAction.terminate ||
+            nextAction.actionType !== firstAction.actionType ||
+            nextAction.subscriberId !== firstAction.subscriberId ||
+            nextAction.registration !== firstAction.registration) {
+            break;
+        }
+        activeBatch.push(queueState.pendingActions.shift());
+    }
+    return activeBatch;
+};
 export class TelemetryStreamAbstract {
     constructor(config) {
         this.telemetryActionQueue = Promise.resolve();
@@ -35,6 +62,14 @@ export class TelemetryStreamAbstract {
         this.messageStream$ = new Subject();
         this.statusStream$ = new BehaviorSubject(SubscriberStatusEnum.STOPPED);
         this.heartbeat = new StreamHeartbeat(this.identifier);
+        telemetryActionQueueStates.set(this, {
+            pendingActions: [],
+            activeBatch: [],
+            registration: 0,
+            drainScheduled: false,
+            requestInFlight: false,
+            stopped: false,
+        });
         RocosStore.getChangeSubject()
             .pipe(filter((message) => {
             return message.type === 'token' && message.url === this.url;
@@ -52,6 +87,12 @@ export class TelemetryStreamAbstract {
         this.registerReceiver();
     }
     stopStream() {
+        const queueState = telemetryActionQueueStates.get(this);
+        if (queueState) {
+            queueState.stopped = true;
+            resolveUnsentTelemetryActions(queueState);
+        }
+        this.subscriberId = undefined;
         this.heartbeat?.stop();
         this.stopInternal();
         if (this.messagesTimer) {
@@ -59,6 +100,10 @@ export class TelemetryStreamAbstract {
         }
         this.subscriberStatus = SubscriberStatusEnum.STOPPED;
         this.statusStream$.next(this.subscriberStatus);
+        // The stream is being torn down (the registry only stops a stream when it is evicted), so
+        // complete the status stream: this releases every service-level forwarder subscribed to it
+        // rather than leaving them attached to a dead instance.
+        this.statusStream$.complete();
     }
     addSubscription(params) {
         this.logger.info('Adding subscriptions from stream', params.uniqueId);
@@ -80,7 +125,9 @@ export class TelemetryStreamAbstract {
                 const toAdd = arrayRemove(this.sources, sourcesBefore);
                 if (toAdd.length) {
                     this.logger.debug('New query subscriptions added, we need to refresh sources', { toAdd });
-                    void this.enqueueTelemetryAction('subscribe', this.callsignsLookup, toAdd);
+                    void this.enqueueTelemetryAction('subscribe', this.callsignsLookup, toAdd).catch((error) => {
+                        this.logger.error(`Failed to subscribe: ${error}`);
+                    });
                 }
             }
             else {
@@ -91,7 +138,9 @@ export class TelemetryStreamAbstract {
                 const { toAdd } = getSubscriptionsDifference(before, after);
                 if (toAdd.callsigns.length && toAdd.sources.length) {
                     this.logger.debug('New subscriptions added, we need to refresh sources', { toAdd });
-                    void this.enqueueTelemetryAction('subscribe', new CallsignsLookup(toAdd.callsigns), toAdd.sources);
+                    void this.enqueueTelemetryAction('subscribe', new CallsignsLookup(toAdd.callsigns), toAdd.sources).catch((error) => {
+                        this.logger.error(`Failed to subscribe: ${error}`);
+                    });
                 }
             }
         }
@@ -197,14 +246,22 @@ export class TelemetryStreamAbstract {
             // Subscribe message
             case GRPC_SOURCE_SUBSCRIBED: {
                 const { subscriberId } = rocosMessage.payload;
+                const queueState = telemetryActionQueueStates.get(this);
+                if (queueState?.stopped)
+                    return;
                 if (this.subscriberId && subscriberId) {
                     this.logger.warn(`Replacing old subscriberId (${this.subscriberId}) with a new one (${subscriberId})`);
                 }
-                // Update the subscriberId
+                if (queueState) {
+                    queueState.registration++;
+                    resolveUnsentTelemetryActions(queueState);
+                }
                 this.subscriberId = subscriberId;
                 rocosMessage.subscriberId = this.subscriberId;
                 this.logger.info('onData', `subscriberId has been updated - ${subscriberId}`, { subscriberId });
-                void this.enqueueTelemetryAction('subscribe');
+                void this.enqueueTelemetryAction('subscribe').catch((error) => {
+                    this.logger.error(`Failed to subscribe: ${error}`);
+                });
                 this.heartbeat.start(() => this.sendHeartbeat(), this.sendHeartbeatTime);
                 isRobotMessage = false;
                 break;
@@ -246,21 +303,69 @@ export class TelemetryStreamAbstract {
      * unsubscribe landing last strands a subscribe and nothing re-adds it.
      */
     enqueueTelemetryAction(actionType, callsignsLookup, sources, terminate) {
-        const takeAction = () => this.takeTelemetryAction(actionType, callsignsLookup, sources, terminate);
-        const run = this.telemetryActionQueue.then(takeAction);
-        // The tail only signals whose turn it is, so it must never reject, otherwise one failed op
-        // would wedge every op queued behind it. Callers still see the failure through `run`.
-        this.telemetryActionQueue = run.then(() => undefined, () => undefined);
-        return run;
+        const queueState = telemetryActionQueueStates.get(this);
+        if (!queueState || queueState.stopped)
+            return Promise.resolve();
+        const completion = new Promise((resolve, reject) => {
+            queueState.pendingActions.push({
+                actionType,
+                callsignsLookup: callsignsLookup ?? this.callsignsLookup,
+                sources: [...(sources ?? this.sources)],
+                terminate: terminate ?? false,
+                subscriberId: this.subscriberId,
+                registration: queueState.registration,
+                resolve,
+                reject,
+            });
+        });
+        const scheduleDrain = () => {
+            if (queueState.stopped ||
+                queueState.requestInFlight ||
+                queueState.drainScheduled ||
+                queueState.pendingActions.length === 0) {
+                return;
+            }
+            queueState.drainScheduled = true;
+            this.telemetryActionQueue = this.telemetryActionQueue.then(async () => {
+                queueState.drainScheduled = false;
+                if (queueState.stopped || queueState.requestInFlight)
+                    return;
+                const activeBatch = takeNextTelemetryBatch(queueState);
+                const [firstAction] = activeBatch;
+                if (!firstAction)
+                    return;
+                queueState.activeBatch = activeBatch;
+                queueState.requestInFlight = true;
+                try {
+                    await this.takeTelemetryAction(firstAction.actionType, firstAction.callsignsLookup, firstAction.sources);
+                    resolveTelemetryActions(activeBatch);
+                }
+                catch (error) {
+                    activeBatch.forEach((action) => action.reject(error));
+                }
+                finally {
+                    queueState.activeBatch = [];
+                    queueState.requestInFlight = false;
+                    scheduleDrain();
+                }
+            });
+        };
+        scheduleDrain();
+        return completion;
     }
-    async takeTelemetryAction(actionType, callsignsLookup, sources, terminate) {
+    async takeTelemetryAction(actionType, callsignsLookup, sources) {
         this.logger.debug('takeTelemetryAction', actionType);
+        const queueState = telemetryActionQueueStates.get(this);
+        const activeBatch = queueState?.activeBatch ?? [];
+        const [firstAction] = activeBatch;
         // A config fault, not a race: this stream can never address a request.
         if (!this.projectId) {
             this.logger.warn('takeTelemetryAction', actionType, `${actionType} without a projectId - dropped`);
             return Promise.resolve();
         }
-        if (!this.subscriberId) {
+        if (!firstAction?.subscriberId ||
+            firstAction.subscriberId !== this.subscriberId ||
+            firstAction.registration !== queueState?.registration) {
             // Deferred, not lost: `onData` re-asserts `this.sources` when the subscriberId arrives.
             this.logger.debug('takeTelemetryAction', actionType, `${actionType} before the receiver was registered - deferred to the post-registration re-assert`);
             return Promise.resolve();
@@ -268,20 +373,20 @@ export class TelemetryStreamAbstract {
         const actionSources = sources ?? this.sources;
         const actionCallsigns = callsignsLookup ?? this.callsignsLookup;
         if (!actionCallsigns.isQuery()) {
-            // Compose the request message
             const req = TelemetryRequest.create({
-                subscriberId: this.subscriberId,
-                requestedActions: [
-                    {
-                        operation: actionType,
-                        callsigns: actionCallsigns.getCallsigns(),
-                        sources: actionSources,
-                    },
-                ],
+                subscriberId: firstAction.subscriberId,
+                requestedActions: activeBatch.map((action) => {
+                    const telemetryAction = TelemetryAction.create({
+                        operation: action.actionType,
+                        callsigns: action.callsignsLookup.getCallsigns(),
+                        sources: action.sources,
+                    });
+                    if (action.actionType === 'unsubscribe' && action.terminate) {
+                        this.addTerminateToAction(telemetryAction);
+                    }
+                    return telemetryAction;
+                }),
             });
-            if (actionType === 'unsubscribe' && terminate) {
-                this.addTerminateToAction(req.requestedActions[0]);
-            }
             this.logger.debug('takeTelemetryAction', actionType, 'client.requestTelemetry', this.subscriberId);
             // Send the message to back-end.
             return this.requestTelemetry(req);
@@ -306,7 +411,7 @@ export class TelemetryStreamAbstract {
             });
             // Compose the request message
             const req = TelemetryQueryRequest.create({
-                subscriberId: this.subscriberId,
+                subscriberId: firstAction.subscriberId,
                 sources: actionSources,
                 operation: actionType,
                 callsignQuery: {

package/esm/api/streams/telemetry/TelemetryStreamConnect.js

@@ -37,6 +37,7 @@ export class TelemetryStreamConnect extends TelemetryStreamAbstract {
         this.client = createClient(TelemetryGateway, transport);
     }
     stopInternal() {
+        this.subscriberId = undefined;
         if (this.abortController) {
             this.logger.info('Starting stop stream process');
             this.abortController.abort();

package/esm/api/streams/telemetry/TelemetryStreamNode.js

@@ -12,6 +12,7 @@ export class TelemetryStreamNode extends TelemetryStreamAbstract {
         this.credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
     }
     stopInternal() {
+        this.subscriberId = undefined;
         try {
             this.logger.info('Starting stop stream process');
             this.logger.info('Stopping stream');

package/esm/api/streams/webRTCSignalling/WebRTCSignallingStreamAbstract.js

@@ -25,7 +25,8 @@ export class WebRTCSignallingStreamAbstract {
         this.token = token;
     }
     stopStream() {
-        // do nothing for now
+        this.statusStream$.next(SubscriberStatusEnum.STOPPED);
+        this.statusStream$.complete();
     }
     /**
      * Connect operator

package/esm/models/maps/Map.d.ts

@@ -8,6 +8,6 @@ export interface Map {
     deployedCount: number;
     isUploading: boolean;
     isInCloud: boolean;
-    hash: string;
+    hash?: string;
     lastModifiedTimestamp: number;
 }

package/esm/models/robot-status/RobotStatus.d.ts

@@ -41,3 +41,26 @@ export interface RobotStatus {
     connectivity: RobotConnectivityStatus;
     colour: RobotStatusColour;
 }
+/**
+ * One contributor to a reported-status axis, from the agent's
+ * `robot/status/contributors` topic. `status` is the contributor's own verdict
+ * for that axis — the integer wire value mapped onto the enum.
+ */
+export interface RobotStatusContributor<TStatus = RobotHealth | RobotReadiness> {
+    /** Identifier of the contributor, e.g. `battery`. */
+    id: string;
+    /** The agent component that raised it, e.g. `dji`. */
+    component: string;
+    /** Human-readable explanation, e.g. `battery below 20%`; empty when none was given. */
+    reason: string;
+    /** The contributor's verdict for its axis. */
+    status: TStatus;
+}
+/**
+ * The per-contributor breakdown behind a robot's reported health and readiness,
+ * from the agent's `robot/status/contributors` topic.
+ */
+export interface RobotStatusContributors {
+    health: RobotStatusContributor<RobotHealth>[];
+    readiness: RobotStatusContributor<RobotReadiness>[];
+}