Skip to content

Commit daffef7

Browse files
browcodex
andcommitted
fix(mobile): unwrap observer telemetry batches
Signed-off-by: Tom Brow <[email protected]> Co-authored-by: Codex <[email protected]> Ai-assisted: true
1 parent b269e8d commit daffef7

2 files changed

Lines changed: 229 additions & 4 deletions

File tree

‎mobile/lib/features/channels/agent_activity/observer_subscription.dart‎

Lines changed: 27 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ import 'transcript_builder.dart';
1111

1212
/// Maximum observer events to keep per agent.
1313
const _maxObserverEvents = 800;
14+
const _observerBatchKind = 'batch';
1415

1516
/// Key for channel-scoped transcript reads.
1617
typedef ObserverKey = ({String channelId, String agentPubkey});
@@ -189,9 +190,15 @@ class ObserverRelayNotifier extends Notifier<ObserverRelayState> {
189190
return;
190191
}
191192

192-
final frame = _decryptFrame(event, normalizedAgent, privHex);
193-
if (frame == null) return;
193+
final frames = _decryptFrames(event, normalizedAgent, privHex);
194+
if (frames == null) return;
194195

196+
for (final frame in frames) {
197+
_storeFrame(normalizedAgent, frame);
198+
}
199+
}
200+
201+
void _storeFrame(String normalizedAgent, ObserverFrame frame) {
195202
final dedupeKey = '${frame.seq}:${frame.timestamp}';
196203
final dedupeKeys = _dedupeKeysByAgent.putIfAbsent(
197204
normalizedAgent,
@@ -220,7 +227,7 @@ class ObserverRelayNotifier extends Notifier<ObserverRelayState> {
220227
_emit(connection: ObserverConnectionState.open);
221228
}
222229

223-
ObserverFrame? _decryptFrame(
230+
List<ObserverFrame>? _decryptFrames(
224231
NostrEvent event,
225232
String normalizedAgent,
226233
String privHex,
@@ -232,7 +239,23 @@ class ObserverRelayNotifier extends Notifier<ObserverRelayState> {
232239
);
233240
final plaintext = nip44Decrypt(conversationKey, event.content);
234241
final json = jsonDecode(plaintext) as Map<String, dynamic>;
235-
return ObserverFrame.fromJson(json);
242+
final frame = ObserverFrame.fromJson(json);
243+
if (frame.kind != _observerBatchKind) {
244+
return [frame];
245+
}
246+
247+
final payload = frame.payload;
248+
final events = payload is Map<String, dynamic> ? payload['events'] : null;
249+
// Preserve malformed envelopes so publisher defects are not silently
250+
// discarded, matching the desktop observer consumer.
251+
if (events is! List || events.isEmpty) {
252+
return [frame];
253+
}
254+
255+
return [
256+
for (final inner in events)
257+
ObserverFrame.fromJson(inner as Map<String, dynamic>),
258+
];
236259
} catch (error) {
237260
_errorMessage = 'Observer event decrypt failed: $error';
238261
_emit(connection: ObserverConnectionState.error);

‎mobile/test/features/channels/agent_activity/observer_subscription_test.dart‎

Lines changed: 202 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -289,6 +289,208 @@ void main() {
289289
expect(otherChannelState.transcript, isEmpty);
290290
},
291291
);
292+
293+
test('expands batch envelopes through ordering and dedupe', () async {
294+
final ownerKeychain = nostr.Keys.generate();
295+
final agentKeychain = nostr.Keys.generate();
296+
final relaySession = _RecordingRelaySession();
297+
final container = ProviderContainer(
298+
overrides: [
299+
relaySessionProvider.overrideWith(() => relaySession),
300+
relayConfigProvider.overrideWith(
301+
() => _FakeRelayConfigNotifier(nsec: ownerKeychain.nsec),
302+
),
303+
],
304+
);
305+
addTearDown(container.dispose);
306+
307+
const channelId = 'test-channel';
308+
final key = (channelId: channelId, agentPubkey: agentKeychain.public);
309+
container.read(observerSubscriptionProvider(key));
310+
await Future<void>.delayed(Duration.zero);
311+
312+
final laterFrame = _observerFrameJson(
313+
seq: 2,
314+
channelId: channelId,
315+
turnId: 'turn-2',
316+
);
317+
final earlierFrame = _observerFrameJson(
318+
seq: 1,
319+
channelId: channelId,
320+
turnId: 'turn-1',
321+
);
322+
relaySession.emit(
323+
_observerEvent(
324+
ownerKeychain: ownerKeychain,
325+
agentKeychain: agentKeychain,
326+
payload: {
327+
'seq': 2,
328+
'timestamp': '2026-04-30T12:00:02.000Z',
329+
'kind': 'batch',
330+
'channelId': channelId,
331+
'turnId': 'turn-2',
332+
'payload': {
333+
'events': [laterFrame, earlierFrame, earlierFrame],
334+
},
335+
},
336+
),
337+
);
338+
339+
final relayState = container.read(observerRelayProvider);
340+
final frames = relayState.framesByAgent[agentKeychain.public];
341+
expect(frames?.map((frame) => frame.seq), [1, 2]);
342+
343+
final state = container.read(observerSubscriptionProvider(key));
344+
expect(state.connection, ObserverConnectionState.open);
345+
expect(state.transcript, hasLength(2));
346+
expect(state.transcript.map((item) => item.id), [
347+
'turn:turn-1',
348+
'turn:turn-2',
349+
]);
350+
351+
final otherChannelState = container.read(
352+
observerSubscriptionProvider((
353+
channelId: 'other-channel',
354+
agentPubkey: agentKeychain.public,
355+
)),
356+
);
357+
expect(otherChannelState.transcript, isEmpty);
358+
});
359+
360+
test('keeps malformed batch envelopes as singleton frames', () async {
361+
final ownerKeychain = nostr.Keys.generate();
362+
final agentKeychain = nostr.Keys.generate();
363+
final relaySession = _RecordingRelaySession();
364+
final container = ProviderContainer(
365+
overrides: [
366+
relaySessionProvider.overrideWith(() => relaySession),
367+
relayConfigProvider.overrideWith(
368+
() => _FakeRelayConfigNotifier(nsec: ownerKeychain.nsec),
369+
),
370+
],
371+
);
372+
addTearDown(container.dispose);
373+
374+
container.read(
375+
observerSubscriptionProvider((
376+
channelId: 'test-channel',
377+
agentPubkey: agentKeychain.public,
378+
)),
379+
);
380+
await Future<void>.delayed(Duration.zero);
381+
382+
relaySession.emit(
383+
_observerEvent(
384+
ownerKeychain: ownerKeychain,
385+
agentKeychain: agentKeychain,
386+
payload: {
387+
'seq': 3,
388+
'timestamp': '2026-04-30T12:00:03.000Z',
389+
'kind': 'batch',
390+
'channelId': 'test-channel',
391+
'payload': <String, dynamic>{},
392+
},
393+
),
394+
);
395+
396+
final state = container.read(observerRelayProvider);
397+
expect(state.connection, ObserverConnectionState.open);
398+
expect(state.errorMessage, isNull);
399+
expect(state.framesByAgent[agentKeychain.public], hasLength(1));
400+
expect(state.framesByAgent[agentKeychain.public]!.single.kind, 'batch');
401+
});
402+
403+
test(
404+
'rejects invalid inner batch frames without partial ingestion',
405+
() async {
406+
final ownerKeychain = nostr.Keys.generate();
407+
final agentKeychain = nostr.Keys.generate();
408+
final relaySession = _RecordingRelaySession();
409+
final container = ProviderContainer(
410+
overrides: [
411+
relaySessionProvider.overrideWith(() => relaySession),
412+
relayConfigProvider.overrideWith(
413+
() => _FakeRelayConfigNotifier(nsec: ownerKeychain.nsec),
414+
),
415+
],
416+
);
417+
addTearDown(container.dispose);
418+
419+
container.read(
420+
observerSubscriptionProvider((
421+
channelId: 'test-channel',
422+
agentPubkey: agentKeychain.public,
423+
)),
424+
);
425+
await Future<void>.delayed(Duration.zero);
426+
427+
relaySession.emit(
428+
_observerEvent(
429+
ownerKeychain: ownerKeychain,
430+
agentKeychain: agentKeychain,
431+
payload: {
432+
'seq': 2,
433+
'timestamp': '2026-04-30T12:00:02.000Z',
434+
'kind': 'batch',
435+
'channelId': 'test-channel',
436+
'payload': {
437+
'events': [
438+
_observerFrameJson(
439+
seq: 1,
440+
channelId: 'test-channel',
441+
turnId: 'turn-1',
442+
),
443+
{'seq': 'invalid'},
444+
],
445+
},
446+
},
447+
),
448+
);
449+
450+
final state = container.read(observerRelayProvider);
451+
expect(state.connection, ObserverConnectionState.error);
452+
expect(state.errorMessage, contains('Observer event decrypt failed'));
453+
expect(state.framesByAgent[agentKeychain.public], isNull);
454+
},
455+
);
456+
}
457+
458+
Map<String, dynamic> _observerFrameJson({
459+
required int seq,
460+
required String channelId,
461+
required String turnId,
462+
}) => {
463+
'seq': seq,
464+
'timestamp': '2026-04-30T12:00:0$seq.000Z',
465+
'kind': 'turn_started',
466+
'channelId': channelId,
467+
'turnId': turnId,
468+
'payload': {
469+
'triggeringEventIds': ['$seq'],
470+
},
471+
};
472+
473+
NostrEvent _observerEvent({
474+
required nostr.Keys ownerKeychain,
475+
required nostr.Keys agentKeychain,
476+
required Map<String, dynamic> payload,
477+
}) {
478+
final conversationKey = getConversationKey(
479+
agentKeychain.secret,
480+
ownerKeychain.public,
481+
);
482+
final event = nostr.Event.from(
483+
kind: EventKind.agentObserverFrame,
484+
content: nip44Encrypt(conversationKey, jsonEncode(payload)),
485+
tags: [
486+
['p', ownerKeychain.public],
487+
['agent', agentKeychain.public],
488+
['frame', 'telemetry'],
489+
],
490+
secretKey: agentKeychain.secret,
491+
verify: false,
492+
);
493+
return NostrEvent.fromJson(event.toMap());
292494
}
293495

294496
class _RecordingRelaySession extends RelaySessionNotifier {

0 commit comments

Comments
 (0)