birdclaw 0.8.2 → 0.8.3

package/src/components/useTimelineRouteData.ts

@@ -1,35 +1,22 @@
-import { useEffect, useRef, useState } from "react";
-import type {
-	QueryEnvelope,
-	ReplyFilter,
-	ResourceKind,
-	TimelineItem,
-} from "#/lib/types";
 import {
-	fetchCachedQueryResponse,
+	useInfiniteQuery,
+	useMutation,
+	useQuery,
+	useQueryClient,
+} from "@tanstack/react-query";
+import { useMemo } from "react";
+import {
 	fetchQueryEnvelope,
-	invalidateCachedQueryResponse,
-	invalidateCachedQueryResponses,
+	fetchQueryResponse,
 	postAction,
-	readCachedQueryEnvelope,
 } from "#/lib/api-client";
-import {
-	deleteClientCache,
-	deleteClientCacheByPrefix,
-	readClientCache,
-	writeClientCache,
-} from "#/lib/client-cache";
+import { queryKeys } from "#/lib/query-client";
+import type { ReplyFilter, ResourceKind, TimelineItem } from "#/lib/types";
 import { useSelectedAccountId } from "./account-selection";
 import { useDebouncedValue } from "./useDebouncedValue";
 
 const PAGE_SIZE = 50;
-const TIMELINE_VIEW_CACHE_PREFIX = "timeline-view:";
-const TIMELINE_VIEW_CACHE_MAX_AGE_MS = 5 * 60_000;
-
-interface TimelineViewSnapshot {
-	items: TimelineItem[];
-	hasMore: boolean;
-}
+const TIMELINE_STALE_TIME_MS = 5 * 60_000;
 
 interface UseTimelineRouteDataOptions {
 	resource: Exclude<ResourceKind, "dms">;
@@ -40,6 +27,11 @@ interface UseTimelineRouteDataOptions {
 	bookmarkedOnly?: boolean;
 }
 
+interface TimelinePageParam {
+	until: string;
+	untilId: string;
+}
+
 function buildTimelineQueryUrl({
 	resource,
 	search,
@@ -47,9 +39,7 @@ function buildTimelineQueryUrl({
 	likedOnly,
 	bookmarkedOnly,
 	selectedAccountId,
-	refreshTick,
-	until,
-	untilId,
+	pageParam,
 }: {
 	resource: Exclude<ResourceKind, "dms">;
 	search: string;
@@ -57,22 +47,21 @@ function buildTimelineQueryUrl({
 	likedOnly: boolean;
 	bookmarkedOnly: boolean;
 	selectedAccountId?: string;
-	refreshTick: number;
-	until?: string;
-	untilId?: string;
+	pageParam?: TimelinePageParam;
 }) {
 	const params = new URLSearchParams({
 		resource,
 		limit: String(PAGE_SIZE),
 	});
 	if (selectedAccountId) params.set("account", selectedAccountId);
-	params.set("refresh", String(refreshTick));
 	if (replyFilter) params.set("replyFilter", replyFilter);
 	if (likedOnly) params.set("liked", "true");
 	if (bookmarkedOnly) params.set("bookmarked", "true");
 	if (search.trim()) params.set("search", search.trim());
-	if (until) params.set("until", until);
-	if (untilId) params.set("untilId", untilId);
+	if (pageParam) {
+		params.set("until", pageParam.until);
+		params.set("untilId", pageParam.untilId);
+	}
 	params.sort();
 	const base =
 		typeof window === "undefined"
@@ -81,12 +70,6 @@ function buildTimelineQueryUrl({
 	return new URL(`/api/query?${params.toString()}`, base).toString();
 }
 
-function timelineViewCacheKey(requestUrl: string) {
-	const url = new URL(requestUrl, "http://birdclaw.local");
-	url.searchParams.delete("refresh");
-	return `${TIMELINE_VIEW_CACHE_PREFIX}${url.pathname}?${url.searchParams.toString()}`;
-}
-
 export function useTimelineRouteData({
 	resource,
 	search,
@@ -95,229 +78,116 @@ export function useTimelineRouteData({
 	likedOnly = false,
 	bookmarkedOnly = false,
 }: UseTimelineRouteDataOptions) {
-	const [meta, setMeta] = useState<QueryEnvelope | null>(
-		() => readCachedQueryEnvelope() ?? null,
-	);
+	const queryClient = useQueryClient();
+	const statusQuery = useQuery({
+		queryKey: queryKeys.status,
+		queryFn: ({ signal }) => fetchQueryEnvelope({ signal }),
+	});
+	const meta = statusQuery.data ?? null;
 	const selectedAccountId = useSelectedAccountId(meta?.accounts);
 	const debouncedSearch = useDebouncedValue(search, 180);
-	const initialRequestUrl = buildTimelineQueryUrl({
-		resource,
-		search: debouncedSearch,
-		replyFilter,
-		likedOnly,
-		bookmarkedOnly,
-		selectedAccountId,
-		refreshTick: 0,
-	});
-	const initialSnapshot = useRef(
-		readClientCache<TimelineViewSnapshot>(
-			timelineViewCacheKey(initialRequestUrl),
-			TIMELINE_VIEW_CACHE_MAX_AGE_MS,
-		),
-	);
-	const [items, setItems] = useState<TimelineItem[]>(
-		() => initialSnapshot.current?.items ?? [],
-	);
-	const [loading, setLoading] = useState(() => !initialSnapshot.current);
-	const [error, setError] = useState<string | null>(null);
-	const [replyError, setReplyError] = useState<string | null>(null);
-	const [refreshTick, setRefreshTick] = useState(0);
-	const [hasMore, setHasMore] = useState(
-		() => initialSnapshot.current?.hasMore ?? false,
-	);
-	const [loadingMore, setLoadingMore] = useState(false);
-	// Bumped whenever the active filters change. A `loadMore` request that
-	// resolves against a stale generation is discarded so its older page is
-	// never appended to a freshly loaded feed.
-	const generationRef = useRef(0);
-	const loadMoreControllerRef = useRef<AbortController | null>(null);
-	const activeRequestUrlRef = useRef(initialRequestUrl);
-
-	async function loadStatus(force = false) {
-		setMeta(await fetchQueryEnvelope(undefined, { force }));
-	}
-
-	useEffect(() => {
-		void loadStatus();
-	}, []);
-
-	useEffect(() => {
-		generationRef.current += 1;
-		loadMoreControllerRef.current?.abort();
-		const controller = new AbortController();
-		let active = true;
-		const requestUrl = buildTimelineQueryUrl({
+	const timelineQueryKey = [
+		...queryKeys.timelines,
+		{
 			resource,
 			search: debouncedSearch,
-			replyFilter,
+			replyFilter: replyFilter ?? "all",
 			likedOnly,
 			bookmarkedOnly,
-			selectedAccountId,
-			refreshTick,
-		});
-		const viewCacheKey = timelineViewCacheKey(requestUrl);
-		activeRequestUrlRef.current = requestUrl;
-		setError(null);
-		setLoadingMore(false);
-		const cached = readClientCache<TimelineViewSnapshot>(
-			viewCacheKey,
-			TIMELINE_VIEW_CACHE_MAX_AGE_MS,
-		);
-		if (cached) {
-			setItems(cached.items);
-			setHasMore(cached.hasMore);
-			setLoading(false);
-			return () => {
-				active = false;
-				controller.abort();
-			};
-		}
-
-		setItems([]);
-		setHasMore(false);
-		setLoading(true);
-		fetchCachedQueryResponse(requestUrl, { signal: controller.signal })
-			.then((data) => {
-				if (!active) return;
-				const next = data.items as TimelineItem[];
-				setItems(next);
-				const nextHasMore = next.length >= PAGE_SIZE;
-				setHasMore(nextHasMore);
-				writeClientCache(viewCacheKey, {
-					items: next,
-					hasMore: nextHasMore,
-				});
-			})
-			.catch((fetchError: unknown) => {
-				if (
-					fetchError instanceof DOMException &&
-					fetchError.name === "AbortError"
-				) {
-					return;
-				}
-				if (!active) return;
-				setError(
-					fetchError instanceof Error ? fetchError.message : errorFallback,
-				);
-				setItems([]);
-				setHasMore(false);
-			})
-			.finally(() => {
-				if (active) {
-					setLoading(false);
-				}
-			});
-
-		return () => {
-			active = false;
-			controller.abort();
-		};
-	}, [
-		bookmarkedOnly,
-		debouncedSearch,
-		errorFallback,
-		likedOnly,
-		refreshTick,
-		replyFilter,
-		resource,
-		selectedAccountId,
-	]);
-
-	async function loadMore() {
-		if (loading || loadingMore || !hasMore || items.length === 0) return;
-		const lastItem = items[items.length - 1];
-		const until = lastItem?.createdAt;
-		const untilId = lastItem?.id;
-		if (!until || !untilId) return;
-		const generation = generationRef.current;
-		const controller = new AbortController();
-		loadMoreControllerRef.current = controller;
-		setLoadingMore(true);
-		try {
-			const nextPageUrl = new URL(
-				activeRequestUrlRef.current,
-				window.location.origin,
-			);
-			nextPageUrl.searchParams.set("until", until);
-			nextPageUrl.searchParams.set("untilId", untilId);
-			const data = await fetchCachedQueryResponse(nextPageUrl, {
-				signal: controller.signal,
-			});
-			// Discard if the filters changed (new generation) while in flight.
-			if (generation !== generationRef.current) return;
-			const page = data.items as TimelineItem[];
-			setItems((prev) => {
-				const seen = new Set(prev.map((item) => item.id));
-				const next = [...prev, ...page.filter((item) => !seen.has(item.id))];
-				writeClientCache(timelineViewCacheKey(activeRequestUrlRef.current), {
-					items: next,
-					hasMore: page.length >= PAGE_SIZE,
-				});
-				return next;
-			});
-			setHasMore(page.length >= PAGE_SIZE);
-		} catch (loadError) {
-			if (
-				loadError instanceof DOMException &&
-				loadError.name === "AbortError"
-			) {
-				return;
-			}
-			if (generation !== generationRef.current) return;
-			setError(loadError instanceof Error ? loadError.message : errorFallback);
-		} finally {
-			if (generation === generationRef.current) {
-				setLoadingMore(false);
+			selectedAccountId: selectedAccountId ?? null,
+		},
+	] as const;
+	const timelineQuery = useInfiniteQuery({
+		queryKey: timelineQueryKey,
+		initialPageParam: undefined as TimelinePageParam | undefined,
+		queryFn: ({ pageParam, signal }) =>
+			fetchQueryResponse(
+				buildTimelineQueryUrl({
+					resource,
+					search: debouncedSearch,
+					replyFilter,
+					likedOnly,
+					bookmarkedOnly,
+					selectedAccountId,
+					pageParam,
+				}),
+				{ signal },
+			),
+		getNextPageParam: (lastPage) => {
+			const items = lastPage.items as TimelineItem[];
+			const lastItem = items.at(-1);
+			return items.length >= PAGE_SIZE && lastItem
+				? { until: lastItem.createdAt, untilId: lastItem.id }
+				: undefined;
+		},
+		staleTime: TIMELINE_STALE_TIME_MS,
+	});
+	const items = useMemo(() => {
+		const seen = new Set<string>();
+		const merged: TimelineItem[] = [];
+		for (const page of timelineQuery.data?.pages ?? []) {
+			for (const item of page.items as TimelineItem[]) {
+				if (seen.has(item.id)) continue;
+				seen.add(item.id);
+				merged.push(item);
 			}
 		}
-	}
+		return merged;
+	}, [timelineQuery.data]);
+	const replyMutation = useMutation({
+		mutationFn: ({ tweetId, text }: { tweetId: string; text: string }) =>
+			postAction({
+				kind: "replyTweet",
+				accountId: selectedAccountId ?? "acct_primary",
+				tweetId,
+				text,
+			}),
+		onSuccess: () =>
+			queryClient.invalidateQueries({ queryKey: timelineQueryKey }),
+	});
 
 	function retry() {
-		invalidateCachedQueryResponse(activeRequestUrlRef.current);
-		deleteClientCache(timelineViewCacheKey(activeRequestUrlRef.current));
-		setRefreshTick((value) => value + 1);
+		void timelineQuery.refetch();
 	}
 
 	function refreshLocalView() {
-		invalidateCachedQueryResponses();
-		deleteClientCacheByPrefix(TIMELINE_VIEW_CACHE_PREFIX);
-		setRefreshTick((value) => value + 1);
-		void loadStatus(true);
+		void Promise.all([
+			queryClient.invalidateQueries({ queryKey: queryKeys.timelines }),
+			queryClient.invalidateQueries({ queryKey: queryKeys.status }),
+		]);
 	}
 
 	async function replyToTweet(tweetId: string) {
 		const text = window.prompt("Reply text");
 		if (!text?.trim()) return;
-
-		setReplyError(null);
-		try {
-			await postAction({
-				kind: "replyTweet",
-				accountId: selectedAccountId ?? "acct_primary",
-				tweetId,
-				text,
+		await replyMutation
+			.mutateAsync({ tweetId, text: text.trim() })
+			.catch(() => {
+				// The mutation error is exposed below for the route frame.
 			});
-
-			retry();
-		} catch (replyError) {
-			setReplyError(
-				replyError instanceof Error ? replyError.message : "Reply failed",
-			);
-		}
 	}
 
+	const queryError = timelineQuery.error;
 	return {
 		meta,
 		items,
-		loading,
-		error,
-		replyError,
+		loading: timelineQuery.isPending,
+		error: queryError
+			? queryError instanceof Error
+				? queryError.message
+				: errorFallback
+			: null,
+		replyError: replyMutation.error
+			? replyMutation.error instanceof Error
+				? replyMutation.error.message
+				: "Reply failed"
+			: null,
 		retry,
 		refreshLocalView,
 		replyToTweet,
 		selectedAccountId,
-		hasMore,
-		loadingMore,
-		loadMore,
+		hasMore: timelineQuery.hasNextPage,
+		loadingMore: timelineQuery.isFetchingNextPage,
+		loadMore: () => timelineQuery.fetchNextPage().then(() => undefined),
 	};
 }

package/src/lib/analysis-runtime.ts

@@ -0,0 +1,238 @@
+import { Effect } from "effect";
+import { tryPromise } from "./effect-runtime";
+import {
+	readOpenAIResponseStreamEffect,
+	requestOpenAIResponseEffect,
+} from "./openai-response-runtime";
+import {
+	defaultRuntimeServices,
+	type RuntimeServices,
+} from "./runtime-services";
+
+const DEFAULT_MODEL = "gpt-5.5";
+const DEFAULT_REASONING_EFFORT = "medium";
+const DEFAULT_SERVICE_TIER = "priority";
+const DEFAULT_DELIMITER_PATTERN = /\n---\s*\n/;
+
+export type AnalysisReasoningEffort = "minimal" | "low" | "medium" | "high";
+export type AnalysisServiceTier = "default" | "flex" | "priority";
+
+export interface AnalysisModelOptions {
+	model?: string;
+	reasoningEffort?: AnalysisReasoningEffort;
+	serviceTier?: AnalysisServiceTier;
+}
+
+export interface AnalysisModelSettings {
+	model: string;
+	reasoningEffort: AnalysisReasoningEffort;
+	serviceTier: AnalysisServiceTier;
+}
+
+export interface HybridAnalysisResult<T> {
+	value: T;
+	markdown: string;
+	rawText: string;
+	responseId?: string;
+	usage?: unknown;
+}
+
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+export function resolveAnalysisModelSettings(
+	options: AnalysisModelOptions,
+	runtime: RuntimeServices = defaultRuntimeServices,
+): AnalysisModelSettings {
+	return {
+		model: options.model ?? runtime.env("BIRDCLAW_AI_MODEL") ?? DEFAULT_MODEL,
+		reasoningEffort:
+			options.reasoningEffort ??
+			(runtime.env(
+				"BIRDCLAW_OPENAI_REASONING_EFFORT",
+			) as AnalysisReasoningEffort) ??
+			DEFAULT_REASONING_EFFORT,
+		serviceTier:
+			options.serviceTier ??
+			(runtime.env("BIRDCLAW_OPENAI_SERVICE_TIER") as AnalysisServiceTier) ??
+			DEFAULT_SERVICE_TIER,
+	};
+}
+
+export function createAnalysisRequestBody({
+	settings,
+	system,
+	prompt,
+	stream,
+	maxOutputTokens = 7000,
+}: {
+	settings: AnalysisModelSettings;
+	system: string;
+	prompt: string;
+	stream: boolean;
+	maxOutputTokens?: number;
+}) {
+	return {
+		model: settings.model,
+		reasoning: { effort: settings.reasoningEffort },
+		service_tier: settings.serviceTier,
+		store: false,
+		...(stream ? { stream: true } : {}),
+		max_output_tokens: maxOutputTokens,
+		input: [
+			{ role: "system", content: system },
+			{ role: "user", content: prompt },
+		],
+	};
+}
+
+export function parseHybridAnalysis<T>({
+	rawText,
+	parse,
+	fallback,
+	delimiterPattern = DEFAULT_DELIMITER_PATTERN,
+}: {
+	rawText: string;
+	parse: (value: unknown) => T;
+	fallback: (markdown: string) => T;
+	delimiterPattern?: RegExp;
+}) {
+	const [markdownPart, jsonPart] = rawText.split(delimiterPattern);
+	const markdown = (markdownPart ?? rawText).trim();
+	const candidate = jsonPart?.slice(
+		jsonPart.indexOf("{"),
+		jsonPart.lastIndexOf("}") + 1,
+	);
+	if (candidate?.startsWith("{")) {
+		try {
+			return { markdown, value: parse(JSON.parse(candidate)) };
+		} catch {
+			return { markdown, value: fallback(markdown) };
+		}
+	}
+	return { markdown, value: fallback(markdown) };
+}
+
+export function extractOpenAIResponseText(payload: Record<string, unknown>) {
+	if (typeof payload.output_text === "string") {
+		return payload.output_text;
+	}
+	const output = Array.isArray(payload.output) ? payload.output : [];
+	const parts: string[] = [];
+	for (const item of output) {
+		if (!item || typeof item !== "object") continue;
+		const content = (item as { content?: unknown }).content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) {
+			if (!block || typeof block !== "object") continue;
+			const record = block as Record<string, unknown>;
+			if (typeof record.text === "string") parts.push(record.text);
+		}
+	}
+	return parts.join("");
+}
+
+export function readHybridAnalysisStreamEffect<T>(
+	response: Response,
+	{
+		parse,
+		fallback,
+		onDelta,
+		delimiterPattern = DEFAULT_DELIMITER_PATTERN,
+	}: {
+		parse: (value: unknown) => T;
+		fallback: (markdown: string) => T;
+		onDelta?: (delta: string) => void;
+		delimiterPattern?: RegExp;
+	},
+): Effect.Effect<HybridAnalysisResult<T>, Error> {
+	return Effect.gen(function* () {
+		const stream = yield* readOpenAIResponseStreamEffect(response, {
+			delimiterPattern,
+			onDelta,
+		});
+		const parsed = parseHybridAnalysis({
+			rawText: stream.rawText,
+			parse,
+			fallback,
+			delimiterPattern,
+		});
+		return {
+			...parsed,
+			rawText: stream.rawText,
+			...(stream.responseId ? { responseId: stream.responseId } : {}),
+			...(stream.usage === undefined ? {} : { usage: stream.usage }),
+		};
+	});
+}
+
+export function streamHybridAnalysisEffect<T>({
+	body,
+	signal,
+	runtime = defaultRuntimeServices,
+	parse,
+	fallback,
+	onDelta,
+	delimiterPattern = DEFAULT_DELIMITER_PATTERN,
+}: {
+	body: unknown;
+	signal?: AbortSignal;
+	runtime?: RuntimeServices;
+	parse: (value: unknown) => T;
+	fallback: (markdown: string) => T;
+	onDelta?: (delta: string) => void;
+	delimiterPattern?: RegExp;
+}): Effect.Effect<HybridAnalysisResult<T>, Error> {
+	return Effect.gen(function* () {
+		const response = yield* requestOpenAIResponseEffect({
+			body,
+			signal,
+			runtime,
+		});
+		return yield* readHybridAnalysisStreamEffect(response, {
+			parse,
+			fallback,
+			onDelta,
+			delimiterPattern,
+		});
+	});
+}
+
+export function requestHybridAnalysisEffect<T>({
+	body,
+	signal,
+	runtime = defaultRuntimeServices,
+	parse,
+	fallback,
+	delimiterPattern = DEFAULT_DELIMITER_PATTERN,
+}: {
+	body: unknown;
+	signal?: AbortSignal;
+	runtime?: RuntimeServices;
+	parse: (value: unknown) => T;
+	fallback: (markdown: string) => T;
+	delimiterPattern?: RegExp;
+}): Effect.Effect<HybridAnalysisResult<T>, Error> {
+	return Effect.gen(function* () {
+		const response = yield* requestOpenAIResponseEffect({
+			body,
+			signal,
+			runtime,
+		});
+		const payload = (yield* tryPromise(() => response.json()).pipe(
+			Effect.mapError(toError),
+		)) as Record<string, unknown>;
+		const rawText = extractOpenAIResponseText(payload);
+		if (!rawText) {
+			return yield* Effect.fail(new Error("OpenAI returned no output text"));
+		}
+		const parsed = parseHybridAnalysis({
+			rawText,
+			parse,
+			fallback,
+			delimiterPattern,
+		});
+		return { ...parsed, rawText };
+	});
+}