birdclaw 0.8.2 → 0.8.3

package/src/lib/period-digest.ts

@@ -1,16 +1,25 @@
 import { createHash } from "node:crypto";
 import { Effect } from "effect";
 import { z } from "zod";
+import {
+	createAnalysisRequestBody,
+	type HybridAnalysisResult,
+	parseHybridAnalysis,
+	readHybridAnalysisStreamEffect,
+	resolveAnalysisModelSettings,
+	streamHybridAnalysisEffect,
+} from "./analysis-runtime";
 import { maybeAutoSyncBackupEffect } from "./backup";
-import { runEffectPromise, tryPromise } from "./effect-runtime";
+import { runEffectPromise } from "./effect-runtime";
 import { getLinkInsights } from "./link-insights";
 import { syncMentionThreadsEffect } from "./mention-threads-live";
 import { syncMentionsEffect } from "./mentions-live";
+import { listDmConversations } from "./dm-read-model";
+import { getTweetsByIds, listTimelineItems } from "./timeline-read-model";
 import {
-	getTweetsByIds,
-	listDmConversations,
-	listTimelineItems,
-} from "./queries";
+	type OpenAIStreamState,
+	processOpenAIResponseSseChunk,
+} from "./openai-response-runtime";
 import { readSyncCache, writeSyncCache } from "./sync-cache";
 import { syncHomeTimelineEffect, type HomeTimelineMode } from "./timeline-live";
 import type { EmbeddedTweet, ProfileRecord, TweetEntities } from "./types";
@@ -206,19 +215,6 @@ export interface PeriodDigestContext {
 	hash: string;
 }
 
-interface OpenAIStreamState {
-	eventBuffer: string;
-	rawText: string;
-	pendingVisible: string;
-	jsonMode: boolean;
-	responseId?: string;
-	usage?: unknown;
-	error?: string;
-}
-
-const DEFAULT_MODEL = "gpt-5.5";
-const DEFAULT_REASONING_EFFORT = "medium";
-const DEFAULT_SERVICE_TIER = "priority";
 const DEFAULT_MAX_TWEETS = 2_500;
 const DEFAULT_MAX_LINKS = 12;
 const DEFAULT_LIVE_TIMELINE_MAX_PAGES = undefined;
@@ -229,7 +225,6 @@ const DEFAULT_LIVE_THREAD_TIMEOUT_MS = 5_000;
 const DEFAULT_DIGEST_FRESHNESS_MS = 5 * 60_000;
 const MAX_PROMPT_DATA_CHARS = 1_200_000;
 const DELIMITER_PATTERN = /\n---\s*\n/;
-const VISIBLE_DELIMITER_HOLD = 8;
 
 function toError(error: unknown) {
 	return error instanceof Error ? error : new Error(String(error));
@@ -242,12 +237,6 @@ function tryDigestSync<T>(try_: () => T): Effect.Effect<T, Error> {
 	});
 }
 
-function tryDigestPromise<T>(
-	try_: () => PromiseLike<T>,
-): Effect.Effect<T, Error> {
-	return tryPromise(try_).pipe(Effect.mapError(toError));
-}
-
 function localDateStart(date: Date) {
 	return new Date(date.getFullYear(), date.getMonth(), date.getDate());
 }
@@ -622,27 +611,15 @@ function languageFromOptions(options: PeriodDigestOptions) {
 }
 
 function modelFromOptions(options: PeriodDigestOptions) {
-	return options.model ?? process.env.BIRDCLAW_AI_MODEL ?? DEFAULT_MODEL;
+	return resolveAnalysisModelSettings(options).model;
 }
 
 function reasoningEffortFromOptions(options: PeriodDigestOptions) {
-	return (
-		options.reasoningEffort ??
-		(process.env.BIRDCLAW_OPENAI_REASONING_EFFORT as
-			| PeriodDigestOptions["reasoningEffort"]
-			| undefined) ??
-		DEFAULT_REASONING_EFFORT
-	);
+	return resolveAnalysisModelSettings(options).reasoningEffort;
 }
 
 function serviceTierFromOptions(options: PeriodDigestOptions) {
-	return (
-		options.serviceTier ??
-		(process.env.BIRDCLAW_OPENAI_SERVICE_TIER as
-			| PeriodDigestOptions["serviceTier"]
-			| undefined) ??
-		DEFAULT_SERVICE_TIER
-	);
+	return resolveAnalysisModelSettings(options).serviceTier;
 }
 
 function boundedPositiveInteger(
@@ -1150,118 +1127,13 @@ function parseDigestFromHybridText(
 	rawText: string,
 	language?: string,
 ): { digest: PeriodDigest; markdown: string } {
-	const [markdownPart, jsonPart] = rawText.split(DELIMITER_PATTERN);
-	const markdown = (markdownPart ?? rawText).trim();
-	const candidate = jsonPart?.slice(
-		jsonPart.indexOf("{"),
-		jsonPart.lastIndexOf("}") + 1,
-	);
-	if (candidate?.startsWith("{")) {
-		try {
-			return {
-				markdown,
-				digest: PeriodDigestSchema.parse(JSON.parse(candidate)),
-			};
-		} catch {
-			return {
-				markdown,
-				digest: fallbackDigest(context, markdown, language),
-			};
-		}
-	}
-	return { markdown, digest: fallbackDigest(context, markdown, language) };
-}
-
-function emitVisibleDelta(
-	state: OpenAIStreamState,
-	delta: string,
-	handlers: PeriodDigestStreamHandlers,
-) {
-	state.rawText += delta;
-	if (state.jsonMode) return;
-
-	const combined = state.pendingVisible + delta;
-	const delimiterIndex = combined.search(DELIMITER_PATTERN);
-	if (delimiterIndex >= 0) {
-		const visible = combined.slice(0, delimiterIndex);
-		if (visible) {
-			handlers.onDelta?.(visible);
-			handlers.onEvent?.({ type: "delta", delta: visible });
-		}
-		state.pendingVisible = "";
-		state.jsonMode = true;
-		return;
-	}
-
-	if (combined.length <= VISIBLE_DELIMITER_HOLD) {
-		state.pendingVisible = combined;
-		return;
-	}
-
-	const visible = combined.slice(0, -VISIBLE_DELIMITER_HOLD);
-	state.pendingVisible = combined.slice(-VISIBLE_DELIMITER_HOLD);
-	if (visible) {
-		handlers.onDelta?.(visible);
-		handlers.onEvent?.({ type: "delta", delta: visible });
-	}
-}
-
-function flushPendingVisible(
-	state: OpenAIStreamState,
-	handlers: PeriodDigestStreamHandlers,
-) {
-	if (state.jsonMode || !state.pendingVisible) return;
-	const delta = state.pendingVisible;
-	state.pendingVisible = "";
-	handlers.onDelta?.(delta);
-	handlers.onEvent?.({ type: "delta", delta });
-}
-
-function handleOpenAIEvent(
-	state: OpenAIStreamState,
-	event: Record<string, unknown>,
-	handlers: PeriodDigestStreamHandlers,
-) {
-	const type = typeof event.type === "string" ? event.type : "";
-	if (
-		type === "response.output_text.delta" &&
-		typeof event.delta === "string"
-	) {
-		emitVisibleDelta(state, event.delta, handlers);
-		return;
-	}
-	if (type === "response.completed") {
-		const response = event.response;
-		if (response && typeof response === "object") {
-			const record = response as Record<string, unknown>;
-			state.responseId = typeof record.id === "string" ? record.id : undefined;
-			state.usage = record.usage;
-		}
-		return;
-	}
-	if (type === "response.error" || type === "error") {
-		const error = event.error;
-		state.error =
-			error && typeof error === "object" && "message" in error
-				? String((error as { message?: unknown }).message)
-				: "OpenAI stream failed";
-		return;
-	}
-	if (type === "response.failed" || type === "response.incomplete") {
-		const response = event.response;
-		const record =
-			response && typeof response === "object"
-				? (response as Record<string, unknown>)
-				: {};
-		const error = record.error;
-		const incomplete = record.incomplete_details;
-		state.error =
-			error && typeof error === "object" && "message" in error
-				? String((error as { message?: unknown }).message)
-				: incomplete && typeof incomplete === "object" && "reason" in incomplete
-					? `OpenAI response incomplete: ${String((incomplete as { reason?: unknown }).reason)}`
-					: "OpenAI stream failed";
-	}
+	const parsed = parseHybridAnalysis({
+		rawText,
+		parse: (value) => PeriodDigestSchema.parse(value),
+		fallback: (markdown) => fallbackDigest(context, markdown, language),
+		delimiterPattern: DELIMITER_PATTERN,
+	});
+	return { markdown: parsed.markdown, digest: parsed.value };
 }
 
 function processSseChunk(
@@ -1269,147 +1141,102 @@ function processSseChunk(
 	chunk: string,
 	handlers: PeriodDigestStreamHandlers,
 ) {
-	state.eventBuffer += chunk;
-	let boundary = state.eventBuffer.indexOf("\n\n");
-	while (boundary >= 0) {
-		const block = state.eventBuffer.slice(0, boundary);
-		state.eventBuffer = state.eventBuffer.slice(boundary + 2);
-		const data = block
-			.split("\n")
-			.filter((line) => line.startsWith("data:"))
-			.map((line) => line.slice(5).trimStart())
-			.join("\n");
-		if (data && data !== "[DONE]") {
-			try {
-				handleOpenAIEvent(
-					state,
-					JSON.parse(data) as Record<string, unknown>,
-					handlers,
-				);
-			} catch {
-				// Ignore malformed event frames; the final JSON parse will decide result quality.
-			}
-		}
-		boundary = state.eventBuffer.indexOf("\n\n");
-	}
+	processOpenAIResponseSseChunk(state, chunk, {
+		delimiterPattern: DELIMITER_PATTERN,
+		onDelta: (delta) => {
+			handlers.onDelta?.(delta);
+			handlers.onEvent?.({ type: "delta", delta });
+		},
+	});
 }
 
 function createOpenAIRequestBody(
 	context: PeriodDigestContext,
 	options: PeriodDigestOptions,
 ) {
-	return {
-		model: modelFromOptions(options),
-		reasoning: { effort: reasoningEffortFromOptions(options) },
-		service_tier: serviceTierFromOptions(options),
-		store: false,
+	return createAnalysisRequestBody({
+		settings: resolveAnalysisModelSettings(options),
+		system:
+			"You are a precise local Twitter archive analyst. Stream Markdown first, then emit the requested JSON object after the delimiter. Do not invent events not present in the dataset.",
+		prompt: buildPrompt(context, {
+			language: languageFromOptions(options),
+		}),
 		stream: true,
-		max_output_tokens: 7000,
-		input: [
-			{
-				role: "system",
-				content:
-					"You are a precise local Twitter archive analyst. Stream Markdown first, then emit the requested JSON object after the delimiter. Do not invent events not present in the dataset.",
-			},
-			{
-				role: "user",
-				content: buildPrompt(context, {
-					language: languageFromOptions(options),
-				}),
-			},
-		],
-	};
+	});
 }
 
-function readOpenAIStreamEffect(
-	response: Response,
+function completeOpenAIStreamEffect(
+	stream: HybridAnalysisResult<PeriodDigest>,
 	context: PeriodDigestContext,
 	options: PeriodDigestOptions,
 	handlers: PeriodDigestStreamHandlers,
 ): Effect.Effect<PeriodDigestRunResult, Error> {
-	const reader = response.body?.getReader();
-	if (!reader) {
-		return Effect.fail(new Error("OpenAI response did not include a stream"));
-	}
-
-	const decoder = new TextDecoder();
-	const state: OpenAIStreamState = {
-		eventBuffer: "",
-		rawText: "",
-		pendingVisible: "",
-		jsonMode: false,
-	};
-
 	return Effect.gen(function* () {
-		for (;;) {
-			const { done, value } = yield* tryDigestPromise(() => reader.read());
-			if (!done) {
-				processSseChunk(
-					state,
-					decoder.decode(value, { stream: true }),
-					handlers,
-				);
-				continue;
-			}
-
-			flushPendingVisible(state, handlers);
-			if (state.error) {
-				return yield* Effect.fail(new Error(state.error));
-			}
-
-			const parsed = yield* tryDigestSync(() =>
-				parseDigestFromHybridText(
-					context,
-					state.rawText,
-					languageFromOptions(options),
-				),
-			);
-			const enrichedContext = yield* tryDigestSync(() =>
-				enrichContextWithCitedTweets(context, parsed.digest),
-			);
-			const cacheKey = digestCacheKey(context, options);
-			const updatedAt = yield* tryDigestSync(() =>
-				writeSyncCache(cacheKey, {
-					digest: parsed.digest,
-					markdown: parsed.markdown,
-					model: modelFromOptions(options),
-					reasoningEffort: reasoningEffortFromOptions(options),
-					serviceTier: serviceTierFromOptions(options),
-					usage: state.usage,
-					responseId: state.responseId,
-				}),
-			);
-			const result: PeriodDigestRunResult = {
-				context: enrichedContext,
-				digest: parsed.digest,
-				markdown: parsed.markdown,
+		const enrichedContext = yield* tryDigestSync(() =>
+			enrichContextWithCitedTweets(context, stream.value),
+		);
+		const cacheKey = digestCacheKey(context, options);
+		const updatedAt = yield* tryDigestSync(() =>
+			writeSyncCache(cacheKey, {
+				digest: stream.value,
+				markdown: stream.markdown,
 				model: modelFromOptions(options),
 				reasoningEffort: reasoningEffortFromOptions(options),
 				serviceTier: serviceTierFromOptions(options),
-				cached: false,
-				updatedAt,
-			};
-			yield* tryDigestSync(() =>
-				writeSyncCache(latestDigestCacheKey(options), {
-					context: result.context,
-					digest: result.digest,
-					markdown: result.markdown,
-					model: result.model,
-					reasoningEffort: result.reasoningEffort,
-					serviceTier: result.serviceTier,
-					updatedAt: result.updatedAt,
-				}),
-			);
-			handlers.onEvent?.({ type: "done", result });
-			return result;
-		}
-	}).pipe(
-		Effect.ensuring(
-			Effect.sync(() => {
-				reader.releaseLock();
+				usage: stream.usage,
+				responseId: stream.responseId,
 			}),
-		),
-	);
+		);
+		const result: PeriodDigestRunResult = {
+			context: enrichedContext,
+			digest: stream.value,
+			markdown: stream.markdown,
+			model: modelFromOptions(options),
+			reasoningEffort: reasoningEffortFromOptions(options),
+			serviceTier: serviceTierFromOptions(options),
+			cached: false,
+			updatedAt,
+		};
+		yield* tryDigestSync(() =>
+			writeSyncCache(latestDigestCacheKey(options), {
+				context: result.context,
+				digest: result.digest,
+				markdown: result.markdown,
+				model: result.model,
+				reasoningEffort: result.reasoningEffort,
+				serviceTier: result.serviceTier,
+				updatedAt: result.updatedAt,
+			}),
+		);
+		handlers.onEvent?.({ type: "done", result });
+		return result;
+	});
+}
+
+function readOpenAIStreamEffect(
+	response: Response,
+	context: PeriodDigestContext,
+	options: PeriodDigestOptions,
+	handlers: PeriodDigestStreamHandlers,
+): Effect.Effect<PeriodDigestRunResult, Error> {
+	return Effect.gen(function* () {
+		const stream = yield* readHybridAnalysisStreamEffect(response, {
+			parse: (value) => PeriodDigestSchema.parse(value),
+			fallback: (markdown) =>
+				fallbackDigest(context, markdown, languageFromOptions(options)),
+			delimiterPattern: DELIMITER_PATTERN,
+			onDelta: (delta) => {
+				handlers.onDelta?.(delta);
+				handlers.onEvent?.({ type: "delta", delta });
+			},
+		});
+		return yield* completeOpenAIStreamEffect(
+			stream,
+			context,
+			options,
+			handlers,
+		);
+	});
 }
 
 export function streamPeriodDigestEffect(
@@ -1494,37 +1321,22 @@ export function streamPeriodDigestEffect(
 		);
 		cacheKey = digestCacheKey(context, resolvedOptions);
 
-		const apiKey = process.env.OPENAI_API_KEY;
-		if (!apiKey) {
-			return yield* Effect.fail(new Error("OPENAI_API_KEY is not set"));
-		}
-
 		handlers.onEvent?.({ type: "start", context, cached: false });
 		emitDigestStatus(handlers, "Streaming AI summary");
-		const response = yield* tryDigestPromise(() =>
-			fetch("https://api.openai.com/v1/responses", {
-				method: "POST",
-				signal: resolvedOptions.signal,
-				headers: {
-					authorization: `Bearer ${apiKey}`,
-					"content-type": "application/json",
-				},
-				body: JSON.stringify(createOpenAIRequestBody(context, resolvedOptions)),
-			}),
-		);
-		if (!response.ok) {
-			const text = yield* tryDigestPromise(() => response.text());
-			return yield* Effect.fail(
-				new Error(
-					`OpenAI request failed: ${String(response.status)} ${text.slice(
-						0,
-						400,
-					)}`,
-				),
-			);
-		}
-		return yield* readOpenAIStreamEffect(
-			response,
+		const stream = yield* streamHybridAnalysisEffect({
+			body: createOpenAIRequestBody(context, resolvedOptions),
+			signal: resolvedOptions.signal,
+			parse: (value) => PeriodDigestSchema.parse(value),
+			fallback: (markdown) =>
+				fallbackDigest(context, markdown, languageFromOptions(resolvedOptions)),
+			delimiterPattern: DELIMITER_PATTERN,
+			onDelta: (delta) => {
+				handlers.onDelta?.(delta);
+				handlers.onEvent?.({ type: "delta", delta });
+			},
+		});
+		return yield* completeOpenAIStreamEffect(
+			stream,
 			context,
 			resolvedOptions,
 			handlers,