Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 7 additions & 0 deletions apps/mobile/src/features/threads/ThreadFeed.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -245,6 +245,7 @@ import {
ThreadWorkLog,
WORK_GROUP_TOGGLE_HEIGHT,
} from "./thread-work-log";
import { seenMessagesFromFeed, useThreadSeenMarker } from "./useThreadSeenMarker";
import {
appendGuestPendingMessages,
appendPendingThreadMessages,
Expand Down Expand Up @@ -3525,6 +3526,11 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
onHeaderMaterialVisibilityChange?.(visible);
};
const feedThreadKey = scopedThreadKey(props.environmentId, props.threadId);
const seenMessages = useMemo(() => seenMessagesFromFeed(props.feed), [props.feed]);
const handleViewableItemsChanged = useThreadSeenMarker({
threadKey: feedThreadKey,
messages: seenMessages,
});
const [loadedListKey, setLoadedListKey] = useState<string | null>(null);
const [landedListKey, setLandedListKey] = useState<string | null>(null);
// LegendList reports ready, and shows its rows, while rows measured during its initial scroll can
Expand Down Expand Up @@ -4036,6 +4042,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
extraData={listAppearanceData}
renderItem={renderItem}
viewabilityConfig={THREAD_MEDIA_VIEWABILITY_CONFIG}
onViewableItemsChanged={handleViewableItemsChanged}
keyExtractor={(entry) => entry.id}
getItemType={(entry) => {
if (entry.type !== "message") return entry.type;
Expand Down
168 changes: 168 additions & 0 deletions apps/mobile/src/features/threads/useThreadSeenMarker.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,168 @@
import { MessageId, ThreadId } from "@t3tools/contracts";
import { buildSeenMarker, resetSeenMarkersForTest } from "@t3tools/client-runtime/seen-marker";
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";

const reactState = vi.hoisted(() => ({
refs: [] as Array<{ current: unknown }>,
cursor: 0,
cleanups: [] as Array<() => void>,
focused: true,
appState: "active",
appListener: null as null | ((state: string) => void),
}));

vi.mock("react", () => ({
useRef: (initial: unknown) => {
const index = reactState.cursor;
reactState.cursor += 1;
const existing = reactState.refs[index];
if (existing) return existing;
const ref = { current: initial };
reactState.refs[index] = ref;
return ref;
},
useEffect: (effect: () => void | (() => void)) => {
const cleanup = effect();
if (typeof cleanup === "function") reactState.cleanups.push(cleanup);
},
useEffectEvent: <T extends (...args: never[]) => unknown>(callback: T) => callback,
useCallback: <T extends (...args: never[]) => unknown>(callback: T) => callback,
}));

vi.mock("@react-navigation/native", () => ({
useIsFocused: () => reactState.focused,
}));

vi.mock("react-native", () => ({
AppState: {
get currentState() {
return reactState.appState;
},
addEventListener: (_type: string, listener: (state: string) => void) => {
reactState.appListener = listener;
return {
remove: () => {
reactState.appListener = null;
},
};
},
},
}));

import type { ThreadFeedEntry } from "../../lib/threadActivity";
import {
seenMessagesFromFeed,
useThreadSeenMarker,
viewableMessageIds,
} from "./useThreadSeenMarker";

const userId = MessageId.make("message-user");
const assistantId = MessageId.make("message-assistant");
const messages = [
{ id: userId, role: "user" },
{ id: assistantId, role: "assistant" },
];

function feedMessage(id: MessageId, role: "user" | "assistant"): ThreadFeedEntry {
return {
type: "message",
id,
createdAt: "2026-11-20T03:00:00.000Z",
message: {
id,
role,
text: id,
attachments: [],
runId: null,
streaming: false,
visibility: "local",
sourceThreadId: ThreadId.make("thread"),
createdAt: "2026-11-20T03:00:00.000Z",
updatedAt: "2026-11-20T03:00:00.000Z",
},
} as ThreadFeedEntry;
}

function renderTracker() {
reactState.cursor = 0;
reactState.cleanups = [];
return useThreadSeenMarker({ threadKey: "env:thread", messages });
}

function showAssistant(onViewable: ReturnType<typeof useThreadSeenMarker>) {
onViewable({
viewableItems: [
{ isViewable: true, item: feedMessage(userId, "user"), index: 0, key: userId },
{ isViewable: true, item: feedMessage(assistantId, "assistant"), index: 1, key: assistantId },
],
} as unknown as Parameters<typeof onViewable>[0]);
}

beforeEach(() => {
reactState.refs = [];
reactState.cursor = 0;
reactState.cleanups = [];
reactState.focused = true;
reactState.appState = "active";
reactState.appListener = null;
resetSeenMarkersForTest();
vi.useFakeTimers();
});

afterEach(() => {
for (const cleanup of reactState.cleanups) cleanup();
vi.useRealTimers();
});

describe("mobile seen marker", () => {
it("marks a focused active screen after 2 seconds and not sooner", () => {
const onViewable = renderTracker();
showAssistant(onViewable);
vi.advanceTimersByTime(1_999);
expect(buildSeenMarker("env:thread")).toBeUndefined();
vi.advanceTimersByTime(1);
expect(buildSeenMarker("env:thread")?.lastSeenMessageId).toBe(assistantId);
});

it("does not count an unfocused screen or a background app", () => {
reactState.focused = false;
const blurred = renderTracker();
showAssistant(blurred);
vi.advanceTimersByTime(2_000);
expect(buildSeenMarker("env:thread")).toBeUndefined();

reactState.refs = [];
reactState.focused = true;
reactState.appState = "background";
const backgrounded = renderTracker();
showAssistant(backgrounded);
vi.advanceTimersByTime(2_000);
expect(buildSeenMarker("env:thread")).toBeUndefined();
});

it("cancels a dwell when the app leaves the foreground", () => {
const onViewable = renderTracker();
showAssistant(onViewable);
vi.advanceTimersByTime(1_000);
reactState.appState = "background";
reactState.appListener?.("background");
vi.advanceTimersByTime(2_000);
expect(buildSeenMarker("env:thread")).toBeUndefined();
});

it("reads message rows and skips everything else", () => {
const feed = [
feedMessage(userId, "user"),
{ type: "work-toggle", id: "toggle" } as ThreadFeedEntry,
feedMessage(assistantId, "assistant"),
];
expect(seenMessagesFromFeed(feed).map((message) => message.id)).toEqual([userId, assistantId]);
expect(
viewableMessageIds([
{ isViewable: false, item: feed[0]! },
{ isViewable: true, item: feed[1]! },
{ isViewable: true, item: feed[2]! },
]),
).toEqual([assistantId]);
});
});
80 changes: 80 additions & 0 deletions apps/mobile/src/features/threads/useThreadSeenMarker.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,80 @@
import type { OnViewableItemsChangedInfo } from "@legendapp/list/react-native";
import {
createSeenMarkerSession,
type SeenMarkerSession,
type SeenMessage,
} from "@t3tools/client-runtime/seen-marker";
import type { MessageId } from "@t3tools/contracts";
import { useIsFocused } from "@react-navigation/native";
import { useCallback, useEffect, useEffectEvent, useRef } from "react";
import { AppState } from "react-native";

import type { ThreadFeedEntry } from "../../lib/threadActivity";
import type { ThreadFeedRow } from "./pending-thread-feed";

export function seenMessagesFromFeed(feed: ReadonlyArray<ThreadFeedEntry>): SeenMessage[] {
const messages: SeenMessage[] = [];
for (const entry of feed) {
if (entry.type === "message") messages.push(entry.message);
}
return messages;
}

export function viewableMessageIds(
viewableItems: ReadonlyArray<{ isViewable: boolean; item: ThreadFeedRow }>,
): MessageId[] {
const ids: MessageId[] = [];
for (const token of viewableItems) {
if (token.isViewable && token.item.type === "message") ids.push(token.item.message.id);
}
return ids;
}

export function useThreadSeenMarker(input: {
threadKey: string;
messages: ReadonlyArray<SeenMessage>;
}) {
const { threadKey, messages } = input;
const isFocused = useIsFocused();
const sessionRef = useRef<SeenMarkerSession | null>(null);
const visibleIdsRef = useRef<ReadonlyArray<MessageId>>([]);
const getMessages = useEffectEvent(() => messages);
const isActive = useEffectEvent(() => isFocused && AppState.currentState === "active");

// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- AppState listener and the dwell timer for this thread
useEffect(() => {
visibleIdsRef.current = [];
const session = createSeenMarkerSession({
threadKey,
getMessages,
seenAt: () => new Date().toISOString(),
timers: {
set: (callback, ms) => setTimeout(callback, ms),
clear: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
},
});
sessionRef.current = session;
session.update({ active: isActive(), visibleIds: visibleIdsRef.current });
const subscription = AppState.addEventListener("change", () =>
session.update({ active: isActive() }),
);
return () => {
subscription.remove();
session.dispose();
sessionRef.current = null;
};
}, [threadKey]);

// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- tells the dwell timer when screen focus or the thread's messages change
useEffect(() => {
sessionRef.current?.update({
active: isFocused && AppState.currentState === "active",
...(messages.length === 0 ? { visibleIds: [] } : {}),
});
}, [isFocused, messages]);

return useCallback((info: OnViewableItemsChangedInfo<ThreadFeedRow>) => {
visibleIdsRef.current = viewableMessageIds(info.viewableItems);
sessionRef.current?.update({ visibleIds: visibleIdsRef.current });
}, []);
}
5 changes: 5 additions & 0 deletions apps/mobile/src/state/threadOutboxDelivery.ts
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,7 @@ import * as Cause from "effect/Cause";
import { AsyncResult, Atom } from "effect/reactivity";

import { createDebugLogger } from "../lib/debugLog";
import { buildSeenMarker } from "@t3tools/client-runtime/seen-marker";
import { scopedThreadKey } from "../lib/scopedEntities";
import { buildProjectThreadStartTurnInput } from "../lib/projectThreadStartTurn";
import { serializeComposerMessageForServer, uploadedComposerContext } from "../lib/composerContext";
Expand Down Expand Up @@ -947,6 +948,9 @@ export function createThreadOutboxDelivery(): {
if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return true;
}
if (!hasAccess()) return true;
const seenMarker = buildSeenMarker(
scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId),
);
const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, {
environmentId: queuedMessage.environmentId,
input: {
Expand Down Expand Up @@ -976,6 +980,7 @@ export function createThreadOutboxDelivery(): {
createdAt: queuedMessage.createdAt,
dispatchMode: queuedMessage.dispatchMode ?? "start",
...(queuedMessage.freshContext ? { freshContext: true } : {}),
...(seenMarker ? { seenMarker } : {}),
resendAfterSocketLoss: false,
},
});
Expand Down
Loading
Loading