@pixelzx/genesis 2026.5.5-3 → 2026.5.5-4

package/dist/sessions-helpers-CMf9gVTZ.js

@@ -0,0 +1,304 @@
+import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { a as loadConfig } from "./io-DNd8mbjy.js";
+import { a as isSubagentSessionKey, n as isAcpSessionKey } from "./session-key-utils-BT0y7mVK.js";
+import { l as normalizeMainKey } from "./session-key-EpIbK3Oz.js";
+import "./config-3He3LWHw.js";
+import { r as callGateway } from "./call-ORivR4Db.js";
+import { i as listSpawnedSessionKeys, o as resolveSandboxSessionToolsVisibility } from "./session-visibility-CJocpWP0.js";
+import { n as looksLikeSessionId } from "./session-id-xKzToZyy.js";
+import "./chat-history-text-SnTuV_CR.js";
+let sessionsResolutionDeps = { callGateway };
+function resolveMainSessionAlias(cfg) {
+	const mainKey = normalizeMainKey(cfg.session?.mainKey);
+	const scope = cfg.session?.scope ?? "per-sender";
+	return {
+		mainKey,
+		alias: scope === "global" ? "global" : mainKey,
+		scope
+	};
+}
+function resolveDisplaySessionKey(params) {
+	if (params.key === params.alias) return "main";
+	if (params.key === params.mainKey) return "main";
+	return params.key;
+}
+function resolveInternalSessionKey(params) {
+	if (params.key === "current") return params.requesterInternalKey ?? params.key;
+	if (params.key === "main") return params.alias;
+	return params.key;
+}
+async function isRequesterSpawnedSessionVisible(params) {
+	if (params.requesterSessionKey === params.targetSessionKey) return true;
+	try {
+		const resolved = await sessionsResolutionDeps.callGateway({
+			method: "sessions.resolve",
+			params: {
+				key: params.targetSessionKey,
+				spawnedBy: params.requesterSessionKey
+			}
+		});
+		if (typeof resolved?.key === "string" && resolved.key.trim() === params.targetSessionKey) return true;
+	} catch {}
+	return (await listSpawnedSessionKeys({
+		requesterSessionKey: params.requesterSessionKey,
+		limit: params.limit
+	})).has(params.targetSessionKey);
+}
+function shouldVerifyRequesterSpawnedSessionVisibility(params) {
+	return params.restrictToSpawned && !params.resolvedViaSessionId && params.requesterSessionKey !== params.targetSessionKey;
+}
+async function isResolvedSessionVisibleToRequester(params) {
+	if (!shouldVerifyRequesterSpawnedSessionVisibility({
+		requesterSessionKey: params.requesterSessionKey,
+		targetSessionKey: params.targetSessionKey,
+		restrictToSpawned: params.restrictToSpawned,
+		resolvedViaSessionId: params.resolvedViaSessionId
+	})) return true;
+	return await isRequesterSpawnedSessionVisible({
+		requesterSessionKey: params.requesterSessionKey,
+		targetSessionKey: params.targetSessionKey,
+		limit: params.limit
+	});
+}
+function looksLikeSessionKey(value) {
+	const raw = normalizeOptionalString(value) ?? "";
+	if (!raw) return false;
+	if (raw === "main" || raw === "global" || raw === "unknown" || raw === "current") return true;
+	if (isAcpSessionKey(raw)) return true;
+	if (raw.startsWith("agent:")) return true;
+	if (raw.startsWith("cron:") || raw.startsWith("hook:")) return true;
+	if (raw.startsWith("node-") || raw.startsWith("node:")) return true;
+	if (raw.includes(":group:") || raw.includes(":channel:")) return true;
+	return false;
+}
+function shouldResolveSessionIdInput(value) {
+	return looksLikeSessionId(value) || !looksLikeSessionKey(value);
+}
+function buildResolvedSessionReference(params) {
+	return {
+		ok: true,
+		key: params.key,
+		displayKey: resolveDisplaySessionKey({
+			key: params.key,
+			alias: params.alias,
+			mainKey: params.mainKey
+		}),
+		resolvedViaSessionId: params.resolvedViaSessionId
+	};
+}
+function buildSessionIdResolveParams(params) {
+	return {
+		sessionId: params.sessionId,
+		spawnedBy: params.restrictToSpawned ? params.requesterInternalKey : void 0,
+		includeGlobal: !params.restrictToSpawned,
+		includeUnknown: !params.restrictToSpawned
+	};
+}
+async function callGatewayResolveSessionId(params) {
+	const key = normalizeOptionalString((await sessionsResolutionDeps.callGateway({
+		method: "sessions.resolve",
+		params: buildSessionIdResolveParams(params)
+	}))?.key) ?? "";
+	if (!key) throw new Error(`Session not found: ${params.sessionId} (use the full sessionKey from sessions_list)`);
+	return key;
+}
+async function resolveSessionKeyFromSessionId(params) {
+	try {
+		return buildResolvedSessionReference({
+			key: await callGatewayResolveSessionId(params),
+			alias: params.alias,
+			mainKey: params.mainKey,
+			resolvedViaSessionId: true
+		});
+	} catch (err) {
+		if (params.restrictToSpawned) return {
+			ok: false,
+			status: "forbidden",
+			error: `Session not visible from this sandboxed agent session: ${params.sessionId}`
+		};
+		return {
+			ok: false,
+			status: "error",
+			error: formatErrorMessage(err) || `Session not found: ${params.sessionId} (use the full sessionKey from sessions_list)`
+		};
+	}
+}
+async function resolveSessionKeyFromKey(params) {
+	try {
+		const key = normalizeOptionalString((await sessionsResolutionDeps.callGateway({
+			method: "sessions.resolve",
+			params: {
+				key: params.key,
+				spawnedBy: params.restrictToSpawned ? params.requesterInternalKey : void 0
+			}
+		}))?.key) ?? "";
+		if (!key) return null;
+		return buildResolvedSessionReference({
+			key,
+			alias: params.alias,
+			mainKey: params.mainKey,
+			resolvedViaSessionId: false
+		});
+	} catch {
+		return null;
+	}
+}
+async function tryResolveSessionKeyFromSessionId(params) {
+	try {
+		return buildResolvedSessionReference({
+			key: await callGatewayResolveSessionId(params),
+			alias: params.alias,
+			mainKey: params.mainKey,
+			resolvedViaSessionId: true
+		});
+	} catch {
+		return null;
+	}
+}
+async function resolveSessionReferenceByKeyOrSessionId(params) {
+	if (!params.skipKeyLookup) {
+		const resolvedByKey = await resolveSessionKeyFromKey({
+			key: params.raw,
+			alias: params.alias,
+			mainKey: params.mainKey,
+			requesterInternalKey: params.requesterInternalKey,
+			restrictToSpawned: params.restrictToSpawned
+		});
+		if (resolvedByKey) return resolvedByKey;
+	}
+	if (!(params.forceSessionIdLookup || shouldResolveSessionIdInput(params.raw))) return null;
+	if (params.allowUnresolvedSessionId) return await tryResolveSessionKeyFromSessionId({
+		sessionId: params.raw,
+		alias: params.alias,
+		mainKey: params.mainKey,
+		requesterInternalKey: params.requesterInternalKey,
+		restrictToSpawned: params.restrictToSpawned
+	});
+	return await resolveSessionKeyFromSessionId({
+		sessionId: params.raw,
+		alias: params.alias,
+		mainKey: params.mainKey,
+		requesterInternalKey: params.requesterInternalKey,
+		restrictToSpawned: params.restrictToSpawned
+	});
+}
+async function resolveSessionReference(params) {
+	const rawInput = params.sessionKey.trim();
+	if (rawInput === "current") {
+		const resolvedCurrent = await resolveSessionReferenceByKeyOrSessionId({
+			raw: rawInput,
+			alias: params.alias,
+			mainKey: params.mainKey,
+			requesterInternalKey: params.requesterInternalKey,
+			restrictToSpawned: params.restrictToSpawned,
+			allowUnresolvedSessionId: true,
+			skipKeyLookup: params.restrictToSpawned,
+			forceSessionIdLookup: true
+		});
+		if (resolvedCurrent) return resolvedCurrent;
+	}
+	const raw = rawInput === "current" && params.requesterInternalKey ? params.requesterInternalKey : rawInput;
+	if (shouldResolveSessionIdInput(raw)) {
+		const resolvedByGateway = await resolveSessionReferenceByKeyOrSessionId({
+			raw,
+			alias: params.alias,
+			mainKey: params.mainKey,
+			requesterInternalKey: params.requesterInternalKey,
+			restrictToSpawned: params.restrictToSpawned,
+			allowUnresolvedSessionId: false
+		});
+		if (resolvedByGateway) return resolvedByGateway;
+	}
+	const resolvedKey = resolveInternalSessionKey({
+		key: raw,
+		alias: params.alias,
+		mainKey: params.mainKey,
+		requesterInternalKey: params.requesterInternalKey
+	});
+	return {
+		ok: true,
+		key: resolvedKey,
+		displayKey: resolveDisplaySessionKey({
+			key: resolvedKey,
+			alias: params.alias,
+			mainKey: params.mainKey
+		}),
+		resolvedViaSessionId: false
+	};
+}
+async function resolveVisibleSessionReference(params) {
+	const resolvedKey = params.resolvedSession.key;
+	const displayKey = params.resolvedSession.displayKey;
+	if (!await isResolvedSessionVisibleToRequester({
+		requesterSessionKey: params.requesterSessionKey,
+		targetSessionKey: resolvedKey,
+		restrictToSpawned: params.restrictToSpawned,
+		resolvedViaSessionId: params.resolvedSession.resolvedViaSessionId
+	})) return {
+		ok: false,
+		status: "forbidden",
+		error: `Session not visible from this sandboxed agent session: ${params.visibilitySessionKey}`,
+		displayKey
+	};
+	return {
+		ok: true,
+		key: resolvedKey,
+		displayKey
+	};
+}
+//#endregion
+//#region src/agents/tools/sessions-access.ts
+function resolveSandboxedSessionToolContext(params) {
+	const { mainKey, alias } = resolveMainSessionAlias(params.cfg);
+	const visibility = resolveSandboxSessionToolsVisibility(params.cfg);
+	const requesterSessionKey = normalizeOptionalString(params.agentSessionKey);
+	const requesterInternalKey = requesterSessionKey ? resolveInternalSessionKey({
+		key: requesterSessionKey,
+		alias,
+		mainKey
+	}) : void 0;
+	return {
+		mainKey,
+		alias,
+		visibility,
+		requesterInternalKey,
+		effectiveRequesterKey: requesterInternalKey ?? alias,
+		restrictToSpawned: params.sandboxed === true && visibility === "spawned" && !!requesterInternalKey && !isSubagentSessionKey(requesterInternalKey)
+	};
+}
+//#endregion
+//#region src/agents/tools/sessions-helpers.ts
+function resolveSessionToolContext(opts) {
+	const cfg = opts?.config ?? loadConfig();
+	return {
+		cfg,
+		...resolveSandboxedSessionToolContext({
+			cfg,
+			agentSessionKey: opts?.agentSessionKey,
+			sandboxed: opts?.sandboxed
+		})
+	};
+}
+function classifySessionKind(params) {
+	const key = params.key;
+	if (key === params.alias || key === params.mainKey) return "main";
+	if (key.startsWith("cron:")) return "cron";
+	if (key.startsWith("hook:")) return "hook";
+	if (key.startsWith("node-") || key.startsWith("node:")) return "node";
+	if (params.gatewayKind === "group") return "group";
+	if (key.includes(":group:") || key.includes(":channel:")) return "group";
+	return "other";
+}
+function deriveChannel(params) {
+	if (params.kind === "cron" || params.kind === "hook" || params.kind === "node") return "internal";
+	const channel = normalizeOptionalString(params.channel ?? void 0);
+	if (channel) return channel;
+	const lastChannel = normalizeOptionalString(params.lastChannel ?? void 0);
+	if (lastChannel) return lastChannel;
+	const parts = params.key.split(":").filter(Boolean);
+	if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) return parts[0];
+	return "unknown";
+}
+//#endregion
+export { resolveDisplaySessionKey as a, resolveSessionReference as c, resolveSandboxedSessionToolContext as i, resolveVisibleSessionReference as l, deriveChannel as n, resolveInternalSessionKey as o, resolveSessionToolContext as r, resolveMainSessionAlias as s, classifySessionKind as t, shouldResolveSessionIdInput as u };

package/dist/sessions-history-http-C5iZkW8x.js

@@ -0,0 +1,383 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { t as createSubsystemLogger } from "./subsystem-DTMy5YmO.js";
+import { a as loadConfig } from "./io-DNd8mbjy.js";
+import "./config-3He3LWHw.js";
+import { n as authorizeOperatorScopesForMethod } from "./method-scopes-DPvtAkiy.js";
+import { t as loadSessionStore } from "./store-load-CUqchamJ.js";
+import "./sessions--xDkaJeX.js";
+import { n as onSessionTranscriptUpdate } from "./transcript-events-DlllnQhZ.js";
+import { c as stripEnvelopeFromMessages, i as readSessionMessages, t as attachGenesisTranscriptMeta } from "./session-utils.fs-sxwRHULR.js";
+import { a as resolveSessionTranscriptCandidates } from "./session-transcript-files.fs-6Jz4i8Fr.js";
+import { d as resolveGatewaySessionStoreTarget, l as resolveFreshestSessionEntryFromStoreKeys } from "./session-utils-BPYVECh0.js";
+import "./heartbeat-DFFJQW7H.js";
+import { n as isHeartbeatOkResponse, r as isHeartbeatUserMessage } from "./heartbeat-filter-C4T2706Y.js";
+import { S as sendMethodNotAllowed, a as checkGatewayHttpRequestAuth, b as sendInvalidRequest, h as resolveTrustedHttpOperatorScopes, i as authorizeScopedGatewayHttpRequestOrReply, s as getHeader, w as setSseHeaders, x as sendJson } from "./http-utils-Da8hOLty.js";
+import { c as sanitizeChatHistoryMessages, n as DEFAULT_CHAT_HISTORY_TEXT_MAX_CHARS } from "./chat-C42usv-F.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/gateway/session-history-state.ts
+function asRoleContentMessage(message) {
+	const role = typeof message.role === "string" ? message.role.toLowerCase() : "";
+	if (!role) return null;
+	return {
+		role,
+		...message.content !== void 0 ? { content: message.content } : message.text !== void 0 ? { content: message.text } : {}
+	};
+}
+function isEmptyTextOnlyContent(content) {
+	if (typeof content === "string") return content.trim().length === 0;
+	if (!Array.isArray(content)) return false;
+	if (content.length === 0) return true;
+	let sawText = false;
+	for (const block of content) {
+		if (!block || typeof block !== "object") return false;
+		const entry = block;
+		if (entry.type !== "text") return false;
+		sawText = true;
+		if (typeof entry.text !== "string" || entry.text.trim().length > 0) return false;
+	}
+	return sawText;
+}
+function shouldHideSanitizedHistoryMessage(message) {
+	const roleContent = asRoleContentMessage(message);
+	if (!roleContent) return false;
+	if (roleContent.role === "user" && isEmptyTextOnlyContent(message.content ?? message.text)) return true;
+	if (isHeartbeatUserMessage(roleContent, "Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.")) return true;
+	return isHeartbeatOkResponse(roleContent);
+}
+function filterVisibleSessionHistoryMessages(messages) {
+	if (messages.length === 0) return messages;
+	let changed = false;
+	const visible = [];
+	for (let i = 0; i < messages.length; i++) {
+		const current = messages[i];
+		if (!current) continue;
+		const currentRoleContent = asRoleContentMessage(current);
+		const next = messages[i + 1];
+		const nextRoleContent = next ? asRoleContentMessage(next) : null;
+		if (currentRoleContent && nextRoleContent && isHeartbeatUserMessage(currentRoleContent, "Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.") && isHeartbeatOkResponse(nextRoleContent)) {
+			changed = true;
+			i++;
+			continue;
+		}
+		if (shouldHideSanitizedHistoryMessage(current)) {
+			changed = true;
+			continue;
+		}
+		visible.push(current);
+	}
+	return changed ? visible : messages;
+}
+function resolveCursorSeq(cursor) {
+	if (!cursor) return;
+	const normalized = cursor.startsWith("seq:") ? cursor.slice(4) : cursor;
+	const value = Number.parseInt(normalized, 10);
+	return Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function toSessionHistoryMessages(messages) {
+	return messages.filter((message) => Boolean(message) && typeof message === "object" && !Array.isArray(message));
+}
+function buildPaginatedSessionHistory(params) {
+	return {
+		items: params.messages,
+		messages: params.messages,
+		hasMore: params.hasMore,
+		...params.nextCursor ? { nextCursor: params.nextCursor } : {}
+	};
+}
+function resolveMessageSeq(message) {
+	const seq = message?.__genesis?.seq;
+	return typeof seq === "number" && Number.isFinite(seq) && seq > 0 ? seq : void 0;
+}
+function paginateSessionMessages(messages, limit, cursor) {
+	const cursorSeq = resolveCursorSeq(cursor);
+	let endExclusive = messages.length;
+	if (typeof cursorSeq === "number") {
+		endExclusive = messages.findIndex((message, index) => {
+			const seq = resolveMessageSeq(message);
+			if (typeof seq === "number") return seq >= cursorSeq;
+			return index + 1 >= cursorSeq;
+		});
+		if (endExclusive < 0) endExclusive = messages.length;
+	}
+	const start = typeof limit === "number" && limit > 0 ? Math.max(0, endExclusive - limit) : 0;
+	const paginatedMessages = messages.slice(start, endExclusive);
+	const firstSeq = resolveMessageSeq(paginatedMessages[0]);
+	return buildPaginatedSessionHistory({
+		messages: paginatedMessages,
+		hasMore: start > 0,
+		...start > 0 && typeof firstSeq === "number" ? { nextCursor: String(firstSeq) } : {}
+	});
+}
+function buildSessionHistorySnapshot(params) {
+	const history = paginateSessionMessages(filterVisibleSessionHistoryMessages(toSessionHistoryMessages(sanitizeChatHistoryMessages(stripEnvelopeFromMessages(params.rawMessages), params.maxChars ?? 8e3))), params.limit, params.cursor);
+	const rawHistoryMessages = toSessionHistoryMessages(params.rawMessages);
+	return {
+		history,
+		rawTranscriptSeq: resolveMessageSeq(rawHistoryMessages.at(-1)) ?? rawHistoryMessages.length
+	};
+}
+var SessionHistorySseState = class SessionHistorySseState {
+	static fromRawSnapshot(params) {
+		return new SessionHistorySseState({
+			target: params.target,
+			maxChars: params.maxChars,
+			limit: params.limit,
+			cursor: params.cursor,
+			initialRawMessages: params.rawMessages
+		});
+	}
+	constructor(params) {
+		this.target = params.target;
+		this.maxChars = params.maxChars ?? 8e3;
+		this.limit = params.limit;
+		this.cursor = params.cursor;
+		const snapshot = buildSessionHistorySnapshot({
+			rawMessages: params.initialRawMessages ?? this.readRawMessages(),
+			maxChars: this.maxChars,
+			limit: this.limit,
+			cursor: this.cursor
+		});
+		this.sentHistory = snapshot.history;
+		this.rawTranscriptSeq = snapshot.rawTranscriptSeq;
+	}
+	snapshot() {
+		return this.sentHistory;
+	}
+	appendInlineMessage(update) {
+		if (this.limit !== void 0 || this.cursor !== void 0) return null;
+		this.rawTranscriptSeq += 1;
+		const sanitized = sanitizeChatHistoryMessages(stripEnvelopeFromMessages([attachGenesisTranscriptMeta(update.message, {
+			...typeof update.messageId === "string" ? { id: update.messageId } : {},
+			seq: this.rawTranscriptSeq
+		})]), this.maxChars);
+		if (sanitized.length === 0) return null;
+		const [sanitizedMessage] = toSessionHistoryMessages(sanitized);
+		if (!sanitizedMessage) return null;
+		if (shouldHideSanitizedHistoryMessage(sanitizedMessage)) return null;
+		const nextMessages = [...this.sentHistory.messages, sanitizedMessage];
+		this.sentHistory = buildPaginatedSessionHistory({
+			messages: nextMessages,
+			hasMore: false
+		});
+		return {
+			message: sanitizedMessage,
+			messageSeq: resolveMessageSeq(sanitizedMessage)
+		};
+	}
+	refresh() {
+		const snapshot = buildSessionHistorySnapshot({
+			rawMessages: this.readRawMessages(),
+			maxChars: this.maxChars,
+			limit: this.limit,
+			cursor: this.cursor
+		});
+		this.rawTranscriptSeq = snapshot.rawTranscriptSeq;
+		this.sentHistory = snapshot.history;
+		return snapshot.history;
+	}
+	readRawMessages() {
+		return readSessionMessages(this.target.sessionId, this.target.storePath, this.target.sessionFile);
+	}
+};
+//#endregion
+//#region src/gateway/sessions-history-http.ts
+const log = createSubsystemLogger("gateway/sessions-history-sse");
+const MAX_SESSION_HISTORY_LIMIT = 1e3;
+function resolveSessionHistoryPath(req) {
+	const match = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`).pathname.match(/^\/sessions\/([^/]+)\/history$/);
+	if (!match) return null;
+	try {
+		return normalizeOptionalString(decodeURIComponent(match[1] ?? "")) ?? null;
+	} catch {
+		return "";
+	}
+}
+function shouldStreamSse(req) {
+	return normalizeLowercaseStringOrEmpty(getHeader(req, "accept")).includes("text/event-stream");
+}
+function getRequestUrl(req) {
+	return new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+}
+function resolveLimit(req) {
+	const raw = getRequestUrl(req).searchParams.get("limit");
+	if (raw == null || raw.trim() === "") return;
+	const value = Number.parseInt(raw, 10);
+	if (!Number.isFinite(value) || value < 1) return 1;
+	return Math.min(MAX_SESSION_HISTORY_LIMIT, Math.max(1, value));
+}
+function canonicalizePath(value) {
+	const trimmed = normalizeOptionalString(value);
+	if (!trimmed) return;
+	const resolved = path.resolve(trimmed);
+	try {
+		return fs.realpathSync(resolved);
+	} catch {
+		return resolved;
+	}
+}
+function sseWrite(res, event, payload) {
+	res.write(`event: ${event}\n`);
+	res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+async function handleSessionHistoryHttpRequest(req, res, opts) {
+	const sessionKey = resolveSessionHistoryPath(req);
+	if (sessionKey === null) return false;
+	if (!sessionKey) {
+		sendInvalidRequest(res, "invalid session key");
+		return true;
+	}
+	if (req.method !== "GET") {
+		sendMethodNotAllowed(res, "GET");
+		return true;
+	}
+	const authResult = await authorizeScopedGatewayHttpRequestOrReply({
+		req,
+		res,
+		auth: opts.auth,
+		trustedProxies: opts.trustedProxies,
+		allowRealIpFallback: opts.allowRealIpFallback,
+		rateLimiter: opts.rateLimiter,
+		operatorMethod: "chat.history",
+		resolveOperatorScopes: resolveTrustedHttpOperatorScopes
+	});
+	if (!authResult) return true;
+	const { cfg } = authResult;
+	const target = resolveGatewaySessionStoreTarget({
+		cfg,
+		key: sessionKey
+	});
+	const entry = resolveFreshestSessionEntryFromStoreKeys(loadSessionStore(target.storePath), target.storeKeys);
+	if (!entry?.sessionId) {
+		sendJson(res, 404, {
+			ok: false,
+			error: {
+				type: "not_found",
+				message: `Session not found: ${sessionKey}`
+			}
+		});
+		return true;
+	}
+	const limit = resolveLimit(req);
+	const cursor = normalizeOptionalString(getRequestUrl(req).searchParams.get("cursor"));
+	const effectiveMaxChars = typeof cfg.gateway?.webchat?.chatHistoryMaxChars === "number" ? cfg.gateway.webchat.chatHistoryMaxChars : DEFAULT_CHAT_HISTORY_TEXT_MAX_CHARS;
+	const rawSnapshot = entry?.sessionId ? readSessionMessages(entry.sessionId, target.storePath, entry.sessionFile) : [];
+	const history = buildSessionHistorySnapshot({
+		rawMessages: rawSnapshot,
+		maxChars: effectiveMaxChars,
+		limit,
+		cursor
+	}).history;
+	if (!shouldStreamSse(req)) {
+		sendJson(res, 200, {
+			sessionKey: target.canonicalKey,
+			...history
+		});
+		return true;
+	}
+	const transcriptCandidates = entry?.sessionId ? new Set(resolveSessionTranscriptCandidates(entry.sessionId, target.storePath, entry.sessionFile, target.agentId).map((candidate) => canonicalizePath(candidate)).filter((candidate) => typeof candidate === "string")) : /* @__PURE__ */ new Set();
+	let sentHistory = history;
+	const sseState = SessionHistorySseState.fromRawSnapshot({
+		target: {
+			sessionId: entry.sessionId,
+			storePath: target.storePath,
+			sessionFile: entry.sessionFile
+		},
+		rawMessages: rawSnapshot,
+		maxChars: effectiveMaxChars,
+		limit,
+		cursor
+	});
+	sentHistory = sseState.snapshot();
+	setSseHeaders(res);
+	res.write("retry: 1000\n\n");
+	sseWrite(res, "history", {
+		sessionKey: target.canonicalKey,
+		...sentHistory
+	});
+	let cleanedUp = false;
+	let streamQueue = Promise.resolve();
+	let heartbeat;
+	let unsubscribe;
+	const cleanup = () => {
+		if (cleanedUp) return;
+		cleanedUp = true;
+		if (heartbeat) clearInterval(heartbeat);
+		if (unsubscribe) unsubscribe();
+	};
+	const closeStream = () => {
+		cleanup();
+		if (!res.writableEnded) res.end();
+	};
+	const queueStreamWork = (work) => {
+		streamQueue = streamQueue.then(async () => {
+			if (cleanedUp || res.writableEnded) return;
+			await work();
+		}).catch((error) => {
+			log.warn("session history SSE stream work failed; closing stream", { error });
+			closeStream();
+		});
+	};
+	const isStreamStillAuthorized = async () => {
+		const cfg = loadConfig();
+		const currentRequestAuth = await checkGatewayHttpRequestAuth({
+			req,
+			auth: opts.getResolvedAuth?.() ?? opts.auth,
+			trustedProxies: cfg.gateway?.trustedProxies,
+			allowRealIpFallback: cfg.gateway?.allowRealIpFallback,
+			rateLimiter: opts.rateLimiter,
+			cfg
+		});
+		if (!currentRequestAuth.ok) return false;
+		return authorizeOperatorScopesForMethod("chat.history", resolveTrustedHttpOperatorScopes(req, currentRequestAuth.requestAuth)).allowed;
+	};
+	heartbeat = setInterval(() => {
+		queueStreamWork(async () => {
+			if (!await isStreamStillAuthorized()) {
+				closeStream();
+				return;
+			}
+			if (!res.writableEnded) res.write(": keepalive\n\n");
+		});
+	}, 15e3);
+	unsubscribe = onSessionTranscriptUpdate((update) => {
+		if (!entry?.sessionId) return;
+		const updatePath = canonicalizePath(update.sessionFile);
+		if (!updatePath || !transcriptCandidates.has(updatePath)) return;
+		queueStreamWork(async () => {
+			if (res.writableEnded) return;
+			if (!await isStreamStillAuthorized()) {
+				closeStream();
+				return;
+			}
+			if (update.message !== void 0) {
+				if (limit === void 0 && cursor === void 0) {
+					const nextEvent = sseState.appendInlineMessage({
+						message: update.message,
+						messageId: update.messageId
+					});
+					if (!nextEvent) return;
+					sentHistory = sseState.snapshot();
+					sseWrite(res, "message", {
+						sessionKey: target.canonicalKey,
+						message: nextEvent.message,
+						...typeof update.messageId === "string" ? { messageId: update.messageId } : {},
+						messageSeq: nextEvent.messageSeq
+					});
+					return;
+				}
+			}
+			sentHistory = sseState.refresh();
+			sseWrite(res, "history", {
+				sessionKey: target.canonicalKey,
+				...sentHistory
+			});
+		});
+	});
+	req.on("close", cleanup);
+	res.on("close", cleanup);
+	res.on("finish", cleanup);
+	return true;
+}
+//#endregion
+export { handleSessionHistoryHttpRequest };