reddit-mcp-server 1.4.7 → 1.5.0

package/dist/index.js

@@ -3,9 +3,162 @@ import dotenv from "dotenv";
 import { FastMCP } from "fastmcp";
 import { Left, Option, Right, Try } from "functype";
 import { z } from "zod";
+//#region src/client/errors.ts
+/**
+* Typed error channel for the Reddit client.
+*
+* The client's methods are the imperative-to-functional boundary: each captures throws
+* (network, HTTP, JSON parsing, validation, deliberate domain errors) inside a `Try` and
+* converts to a typed `Either<RedditError, T>`. Modelling the error as a discriminated ADT
+* — rather than a bare `Error` — makes the failure contract explicit at the type level, so
+* callers can reason about (and branch on) what actually went wrong without string-matching.
+*
+* `classifyRedditError` is TOTAL and never re-throws — every captured `Error` maps to a
+* variant — which is what makes the migration behavior-preserving: an error that was a
+* graceful `Left` before is still a graceful `Left` after, just with a richer type.
+*
+* Two-tier behavior, to preserve the exact messages of the original try/catch code:
+*  - A *deliberate* typed throw (HttpError, NotFoundError, …) already carries its final
+*    message, so it passes through unchanged.
+*  - An *unexpected* generic error (fetch/JSON/orThrow) is wrapped as UnknownError, with the
+*    optional `context` prefix — present for read methods (which prefixed in their catch),
+*    absent for write methods (which returned the raw message).
+*/
+var RedditErrorBase = class extends Error {};
+/** A non-ok HTTP response from the Reddit API. Carries the status for caller branching. */
+var HttpError = class extends RedditErrorBase {
+	status;
+	_tag = "HttpError";
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "HttpError";
+	}
+};
+/** A write operation was attempted without the required user credentials / in a wrong mode. */
+var NotAuthenticatedError = class extends RedditErrorBase {
+	_tag = "NotAuthenticatedError";
+	constructor(message) {
+		super(message);
+		this.name = "NotAuthenticatedError";
+	}
+};
+/** Reddit accepted the request but returned errors in its JSON envelope (or an unusable body). */
+var ApiError = class extends RedditErrorBase {
+	_tag = "ApiError";
+	constructor(message) {
+		super(message);
+		this.name = "ApiError";
+	}
+};
+/** The requested post/entity does not exist or is not accessible. */
+var NotFoundError = class extends RedditErrorBase {
+	_tag = "NotFoundError";
+	constructor(message) {
+		super(message);
+		this.name = "NotFoundError";
+	}
+};
+/** Client-side input or safety-policy rejection (invalid sort, duplicate-content guard). */
+var ValidationError = class extends RedditErrorBase {
+	_tag = "ValidationError";
+	constructor(message) {
+		super(message);
+		this.name = "ValidationError";
+	}
+};
+/** Any failure that is not a recognized category: network, JSON parsing, unexpected throws. */
+var UnknownError = class extends RedditErrorBase {
+	cause;
+	_tag = "UnknownError";
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "UnknownError";
+	}
+};
+function isRedditError(error) {
+	return error instanceof RedditErrorBase;
+}
+/**
+* Total classifier from a captured `Error` to a `RedditError`. Deliberate typed throws pass
+* through unchanged; everything else becomes an `UnknownError`, prefixed with `context` when
+* provided so the observable message text matches the previous try/catch-based wrapping.
+*/
+function classifyRedditError(error, context) {
+	if (isRedditError(error)) return error;
+	return new UnknownError(Option(context).fold(() => error.message, (ctx) => `${ctx}: ${error.message}`), error);
+}
+//#endregion
+//#region src/client/response-cache.ts
+const SECOND = 1e3;
+var ResponseCache = class {
+	maxBytes;
+	now;
+	entries = /* @__PURE__ */ new Map();
+	currentBytes = 0;
+	constructor(options) {
+		this.maxBytes = options.maxBytes;
+		this.now = options.now ?? Date.now;
+	}
+	/** Adaptive TTL (in milliseconds) for a given request URL. */
+	ttlFor(url) {
+		if (/\/(hot|new|rising)\.json/.test(url)) return 60 * SECOND;
+		if (/\/(top|controversial)\.json/.test(url) || /\/search\.json/.test(url) || /\/about\.json/.test(url)) return 300 * SECOND;
+		if (/\/comments\//.test(url)) return 60 * SECOND;
+		return 120 * SECOND;
+	}
+	get(url) {
+		const entry = this.entries.get(url);
+		if (entry === void 0) return;
+		if (this.now() >= entry.expiresAt) {
+			this.entries.delete(url);
+			this.currentBytes -= entry.bytes;
+			return;
+		}
+		this.entries.delete(url);
+		this.entries.set(url, entry);
+		return {
+			body: entry.body,
+			status: entry.status
+		};
+	}
+	set(url, body, status) {
+		const bytes = Buffer.byteLength(body, "utf8");
+		if (bytes > this.maxBytes) return;
+		const existing = this.entries.get(url);
+		if (existing !== void 0) {
+			this.entries.delete(url);
+			this.currentBytes -= existing.bytes;
+		}
+		this.entries.set(url, {
+			body,
+			status,
+			expiresAt: this.now() + this.ttlFor(url),
+			bytes
+		});
+		this.currentBytes += bytes;
+		this.evictUntilWithinBudget();
+	}
+	evictUntilWithinBudget() {
+		while (this.currentBytes > this.maxBytes) {
+			const oldestKey = this.entries.keys().next().value;
+			if (oldestKey === void 0) return;
+			const oldest = this.entries.get(oldestKey);
+			this.entries.delete(oldestKey);
+			if (oldest !== void 0) this.currentBytes -= oldest.bytes;
+		}
+	}
+};
+//#endregion
 //#region src/client/reddit-client.ts
-function toError(error) {
-	return error instanceof Error ? error : new Error(String(error));
+function listingCursor(data) {
+	const after = typeof data.after === "string" ? { after: data.after } : {};
+	const before = typeof data.before === "string" ? { before: data.before } : {};
+	return {
+		...after,
+		...before
+	};
 }
 function parsePostData(post) {
 	return {
@@ -38,12 +191,15 @@ var RedditClient = class {
 	hasCredentials;
 	safeMode;
 	botDisclosure;
+	cache;
+	retry;
 	accessToken;
 	tokenExpiry = 0;
 	authenticated = false;
 	lastWriteTime = 0;
 	recentContentRecords = [];
 	constructor(config) {
+		var _config$cache;
 		this.clientId = config.clientId;
 		this.clientSecret = config.clientSecret;
 		this.userAgent = config.userAgent;
@@ -63,6 +219,12 @@ var RedditClient = class {
 			enabled: false,
 			footer: ""
 		};
+		this.cache = ((_config$cache = config.cache) === null || _config$cache === void 0 ? void 0 : _config$cache.enabled) === true ? new ResponseCache({ maxBytes: config.cache.maxBytes }) : void 0;
+		this.retry = config.retry ?? {
+			maxRetries: 3,
+			baseDelayMs: 1e3,
+			maxDelayMs: 6e4
+		};
 	}
 	determineBaseUrl() {
 		switch (this.authMode) {
@@ -72,34 +234,33 @@ var RedditClient = class {
 		}
 	}
 	async makeRequest(path, options = {}) {
-		try {
+		return (await Try.async(async () => {
+			const url = `${this.baseUrl}${path}`;
+			const method = (options.method ?? "GET").toUpperCase();
+			const cacheable = this.cache !== void 0 && method === "GET";
+			if (cacheable) {
+				const cached = this.cache.get(url);
+				if (cached !== void 0) return new Response(cached.body, { status: cached.status });
+			}
 			const requiresAuth = this.authMode === "authenticated" || this.authMode === "auto" && this.hasCredentials;
 			if (requiresAuth && (Date.now() >= this.tokenExpiry || !this.authenticated)) (await this.authenticate()).orThrow();
-			const url = `${this.baseUrl}${path}`;
 			const headers = {
 				"User-Agent": this.userAgent,
 				...options.headers
 			};
 			if (requiresAuth && this.accessToken !== void 0) headers["Authorization"] = `Bearer ${this.accessToken}`;
-			const response = await fetch(url, {
-				...options,
-				headers
-			});
-			if (response.status === 401 && this.authenticated) {
-				(await this.authenticate()).orThrow();
-				const retryHeaders = {
-					...headers,
-					Authorization: `Bearer ${this.accessToken}`
-				};
-				return Right(await fetch(url, {
-					...options,
-					headers: retryHeaders
-				}));
+			const first = await this.fetchWithRetry(url, options, headers, path, 0);
+			const response = first.status === 401 && this.authenticated ? await this.fetchWithRetry(url, options, {
+				...headers,
+				Authorization: await this.reauthorize()
+			}, path, 0) : first;
+			if (cacheable && response.ok) {
+				const text = await response.text();
+				this.cache.set(url, text, response.status);
+				return new Response(text, { status: response.status });
 			}
-			return Right(response);
-		} catch (error) {
-			return Left(toError(error));
-		}
+			return response;
+		})).toEither((error) => error);
 	}
 	async authenticate() {
 		if (this.authMode === "anonymous") {
@@ -111,9 +272,9 @@ var RedditClient = class {
 			this.authenticated = false;
 			return Right(void 0);
 		}
-		try {
+		return (await Try.async(async () => {
 			const now = Date.now();
-			if (this.accessToken !== void 0 && now < this.tokenExpiry) return Right(void 0);
+			if (this.accessToken !== void 0 && now < this.tokenExpiry) return;
 			const authUrl = "https://www.reddit.com/api/v1/access_token";
 			const authData = new URLSearchParams();
 			const { username } = this;
@@ -135,16 +296,13 @@ var RedditClient = class {
 			});
 			if (!response.ok) {
 				const statusText = response.statusText !== "" ? response.statusText : "Unknown Error";
-				return Left(/* @__PURE__ */ new Error(`Authentication failed: ${response.status} ${statusText}`));
+				throw new Error(`Authentication failed: ${response.status} ${statusText}`);
 			}
 			const data = await response.json();
 			this.accessToken = data.access_token;
 			this.tokenExpiry = now + data.expires_in * 1e3;
 			this.authenticated = true;
-			return Right(void 0);
-		} catch (error) {
-			return Left(toError(error));
-		}
+		})).toEither((error) => error);
 	}
 	async checkAuthentication() {
 		if (!this.authenticated) return (await this.authenticate()).isRight();
@@ -152,8 +310,8 @@ var RedditClient = class {
 	}
 	validateWriteAccess() {
 		if (this.username === void 0 || this.password === void 0) {
-			if (this.authMode === "anonymous") throw new Error("Write operations not available in anonymous mode. Set REDDIT_USERNAME, REDDIT_PASSWORD and use 'auto' or 'authenticated' mode.");
-			throw new Error("Write operations require REDDIT_USERNAME and REDDIT_PASSWORD");
+			if (this.authMode === "anonymous") throw new NotAuthenticatedError("Write operations not available in anonymous mode. Set REDDIT_USERNAME, REDDIT_PASSWORD and use 'auto' or 'authenticated' mode.");
+			throw new NotAuthenticatedError("Write operations require REDDIT_USERNAME and REDDIT_PASSWORD");
 		}
 	}
 	async enforceWriteRateLimit() {
@@ -174,8 +332,8 @@ var RedditClient = class {
 		const hash = this.hashContent(content);
 		const duplicate = this.recentContentRecords.find((record) => record.hash === hash);
 		if (duplicate !== void 0) {
-			if (subreddit !== void 0 && duplicate.subreddit !== "" && subreddit !== duplicate.subreddit) throw new Error("Cross-subreddit duplicate detected. Reddit's Responsible Builder Policy prohibits posting identical or substantially similar content across multiple subreddits. Please create unique content for each subreddit.");
-			throw new Error("Duplicate content detected. Reddit's spam filter may ban your account for posting identical content. Please modify your content and try again.");
+			if (subreddit !== void 0 && duplicate.subreddit !== "" && subreddit !== duplicate.subreddit) throw new ValidationError("Cross-subreddit duplicate detected. Reddit's Responsible Builder Policy prohibits posting identical or substantially similar content across multiple subreddits. Please create unique content for each subreddit.");
+			throw new ValidationError("Duplicate content detected. Reddit's spam filter may ban your account for posting identical content. Please modify your content and try again.");
 		}
 		this.recentContentRecords.push({
 			hash,
@@ -184,16 +342,49 @@ var RedditClient = class {
 		});
 		this.recentContentRecords = this.recentContentRecords.slice(-this.safeMode.maxRecentHashes);
 	}
+	async reauthorize() {
+		(await this.authenticate()).orThrow();
+		return `Bearer ${this.accessToken}`;
+	}
+	async fetchWithRetry(url, options, headers, path, attempt) {
+		const response = await fetch(url, {
+			...options,
+			headers
+		});
+		if (response.status !== 429 || attempt >= this.retry.maxRetries) return response;
+		const wait = this.retryAfterMs(response).fold(() => Math.min(this.retry.baseDelayMs * 2 ** attempt, this.retry.maxDelayMs), (ms) => ms);
+		if (wait > this.retry.maxDelayMs) return response;
+		console.error(`[RateLimit] 429 from ${path} — retry ${attempt + 1}/${this.retry.maxRetries} in ${wait}ms`);
+		await new Promise((resolve) => setTimeout(resolve, wait));
+		return this.fetchWithRetry(url, options, headers, path, attempt + 1);
+	}
+	retryAfterMs(response) {
+		const { headers } = response;
+		const retryAfter = headers.get("retry-after");
+		if (retryAfter !== null && retryAfter !== "") {
+			const seconds = Number(retryAfter);
+			if (!Number.isNaN(seconds)) return Option(seconds * 1e3);
+			const when = Date.parse(retryAfter);
+			if (!Number.isNaN(when)) return Option(Math.max(0, when - Date.now()));
+		}
+		const reset = headers.get("x-ratelimit-reset");
+		if (reset !== null && reset !== "") {
+			const seconds = Number(reset);
+			if (!Number.isNaN(seconds)) return Option(seconds * 1e3);
+		}
+		return Option.none();
+	}
 	appendBotDisclosure(content) {
 		if (!this.botDisclosure.enabled || this.botDisclosure.footer === "") return content;
 		return `${content}${this.botDisclosure.footer}`;
 	}
 	async getUser(username) {
-		try {
+		const context = `Failed to get user info for ${username}`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`/user/${username}/about.json`)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to get user info for ${username}: HTTP ${response.status}`));
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
 			const { data } = await response.json();
-			return Right({
+			return {
 				name: data.name,
 				id: data.id,
 				commentKarma: data.comment_karma,
@@ -204,17 +395,79 @@ var RedditClient = class {
 				isEmployee: data.is_employee,
 				createdUtc: data.created_utc,
 				profileUrl: `https://reddit.com/user/${data.name}`
-			});
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to get user info for ${username}: ${toError(error).message}`));
-		}
+			};
+		})).toEither((error) => classifyRedditError(error, context));
+	}
+	async getUserContent(path, context) {
+		return (await Try.async(async () => {
+			const response = (await this.makeRequest(path)).orThrow();
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			const json = await response.json();
+			return {
+				posts: json.data.children.filter((child) => child.kind === "t3").map((child) => parsePostData(child.data)),
+				comments: json.data.children.filter((child) => child.kind === "t1").map((child) => {
+					const comment = child.data;
+					return {
+						id: comment.id,
+						author: comment.author,
+						body: comment.body ?? "",
+						score: comment.score,
+						controversiality: comment.controversiality,
+						subreddit: comment.subreddit,
+						submissionTitle: comment.link_title ?? "",
+						createdUtc: comment.created_utc,
+						edited: Boolean(comment.edited),
+						isSubmitter: comment.is_submitter,
+						permalink: comment.permalink,
+						parentId: comment.parent_id
+					};
+				}),
+				...listingCursor(json.data)
+			};
+		})).toEither((error) => classifyRedditError(error, context));
+	}
+	async getMyOverview(options = {}) {
+		if (this.username === void 0) return Left(new NotAuthenticatedError("Fetching your overview requires REDDIT_USERNAME"));
+		const { limit = 25, after } = options;
+		const params = new URLSearchParams({ limit: limit.toString() });
+		if (after !== void 0) params.set("after", after);
+		return this.getUserContent(`/user/${this.username}/overview.json?${params}`, "Failed to get your overview");
+	}
+	async getMySaved(options = {}) {
+		if (this.username === void 0) return Left(new NotAuthenticatedError("Fetching saved content requires REDDIT_USERNAME"));
+		const { limit = 25, after } = options;
+		const params = new URLSearchParams({ limit: limit.toString() });
+		if (after !== void 0) params.set("after", after);
+		return this.getUserContent(`/user/${this.username}/saved.json?${params}`, "Failed to get saved content");
+	}
+	async getMe() {
+		if (this.username === void 0) return Left(new NotAuthenticatedError("Fetching your account requires REDDIT_USERNAME"));
+		const context = "Failed to get authenticated user info";
+		return (await Try.async(async () => {
+			const response = (await this.makeRequest("/api/v1/me")).orThrow();
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			const data = await response.json();
+			return {
+				name: data.name,
+				id: data.id,
+				commentKarma: data.comment_karma,
+				linkKarma: data.link_karma,
+				totalKarma: data.total_karma ?? data.comment_karma + data.link_karma,
+				isMod: data.is_mod,
+				isGold: data.is_gold,
+				isEmployee: data.is_employee,
+				createdUtc: data.created_utc,
+				profileUrl: `https://reddit.com/user/${data.name}`
+			};
+		})).toEither((error) => classifyRedditError(error, context));
 	}
 	async getSubredditInfo(subredditName) {
-		try {
+		const context = `Failed to get subreddit info for ${subredditName}`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`/r/${subredditName}/about.json`)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to get subreddit info for ${subredditName}: HTTP ${response.status}`));
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
 			const { data } = await response.json();
-			return Right({
+			return {
 				displayName: data.display_name,
 				title: data.title,
 				description: data.description,
@@ -225,50 +478,103 @@ var RedditClient = class {
 				over18: data.over18,
 				subredditType: data.subreddit_type,
 				url: data.url
-			});
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to get subreddit info for ${subredditName}: ${toError(error).message}`));
-		}
+			};
+		})).toEither((error) => classifyRedditError(error, context));
+	}
+	async getSubredditRules(subreddit) {
+		const context = `Failed to get rules for r/${subreddit}`;
+		return (await Try.async(async () => {
+			const response = (await this.makeRequest(`/r/${subreddit}/about/rules.json`)).orThrow();
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			return (await response.json()).rules.map((rule) => ({
+				shortName: rule.short_name,
+				description: rule.description,
+				kind: rule.kind,
+				violationReason: rule.violation_reason,
+				priority: rule.priority,
+				createdUtc: rule.created_utc
+			}));
+		})).toEither((error) => classifyRedditError(error, context));
+	}
+	async getPostFlairs(subreddit) {
+		const context = `Failed to get post flairs for r/${subreddit}`;
+		return (await Try.async(async () => {
+			const response = (await this.makeRequest(`/r/${subreddit}/api/link_flair_v2.json`)).orThrow();
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			return (await response.json()).map((flair) => ({
+				id: flair.id,
+				text: flair.text,
+				type: flair.type,
+				textEditable: flair.text_editable
+			}));
+		})).toEither((error) => classifyRedditError(error, context));
 	}
-	async getTopPosts(subreddit, timeFilter = "week", limit = 10) {
+	async getTopPosts(subreddit, timeFilter = "week", limit = 10, after) {
 		const endpoint = subreddit !== "" ? `/r/${subreddit}/top.json` : "/top.json";
 		const params = new URLSearchParams({
 			t: timeFilter,
 			limit: limit.toString()
 		});
-		try {
+		if (after !== void 0) params.set("after", after);
+		const context = `Failed to get top posts for ${subreddit !== "" ? subreddit : "home"}`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`${endpoint}?${params}`)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to get top posts: HTTP ${response.status}`));
-			return Right((await response.json()).data.children.map((child) => parsePostData(child.data)));
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to get top posts for ${subreddit !== "" ? subreddit : "home"}: ${toError(error).message}`));
-		}
+			if (!response.ok) throw new HttpError(response.status, `Failed to get top posts: HTTP ${response.status}`);
+			const json = await response.json();
+			return {
+				items: json.data.children.map((child) => parsePostData(child.data)),
+				...listingCursor(json.data)
+			};
+		})).toEither((error) => classifyRedditError(error, context));
+	}
+	async browseSubreddit(subreddit, sort = "hot", timeFilter = "week", limit = 10, after) {
+		const validSorts = [
+			"hot",
+			"new",
+			"top",
+			"rising",
+			"controversial"
+		];
+		if (!validSorts.includes(sort)) return Left(new ValidationError(`Invalid sort "${sort}". Valid options are: ${validSorts.join(", ")}`));
+		const endpoint = subreddit !== "" ? `/r/${subreddit}/${sort}.json` : `/${sort}.json`;
+		const params = new URLSearchParams({ limit: limit.toString() });
+		if (sort === "top" || sort === "controversial") params.set("t", timeFilter);
+		if (after !== void 0) params.set("after", after);
+		const home = subreddit !== "" ? subreddit : "home";
+		const context = `Failed to browse r/${home} (${sort})`;
+		return (await Try.async(async () => {
+			const response = (await this.makeRequest(`${endpoint}?${params}`)).orThrow();
+			if (!response.ok) throw new HttpError(response.status, `Failed to browse r/${home}: HTTP ${response.status}`);
+			const json = await response.json();
+			return {
+				items: json.data.children.map((child) => parsePostData(child.data)),
+				...listingCursor(json.data)
+			};
+		})).toEither((error) => classifyRedditError(error, context));
 	}
 	async getPost(postId, subreddit) {
 		const endpoint = Option(subreddit).fold(() => `/api/info.json?id=t3_${postId}`, (sr) => `/r/${sr}/comments/${postId}.json`);
-		try {
+		const context = `Failed to get post with ID ${postId}`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(endpoint)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to get post with ID ${postId}: HTTP ${response.status}`));
-			if (subreddit !== void 0) return Right(parsePostData((await response.json())[0].data.children[0].data));
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			if (subreddit !== void 0) return parsePostData((await response.json())[0].data.children[0].data);
 			const json = await response.json();
-			if (json.data.children.length === 0) return Left(/* @__PURE__ */ new Error(`Post with ID ${postId} not found`));
-			return Right(parsePostData(json.data.children[0].data));
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to get post with ID ${postId}: ${toError(error).message}`));
-		}
+			if (json.data.children.length === 0) throw new NotFoundError(`Post with ID ${postId} not found`);
+			return parsePostData(json.data.children[0].data);
+		})).toEither((error) => classifyRedditError(error, context));
 	}
 	async getTrendingSubreddits(limit = 5) {
 		const params = new URLSearchParams({ limit: limit.toString() });
-		try {
+		const context = `Failed to get trending subreddits`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`/subreddits/popular.json?${params}`)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to get trending subreddits: HTTP ${response.status}`));
-			return Right((await response.json()).data.children.map((child) => child.data.display_name));
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to get trending subreddits: ${toError(error).message}`));
-		}
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			return (await response.json()).data.children.map((child) => child.data.display_name);
+		})).toEither((error) => classifyRedditError(error, context));
 	}
-	async createPost(subreddit, title, content, isSelf = true) {
-		try {
+	async createPost(subreddit, title, content, isSelf = true, flairId, flairText) {
+		return (await Try.async(async () => {
 			var _json$json$data, _json$json$data2;
 			this.validateWriteAccess();
 			await this.enforceWriteRateLimit();
@@ -281,35 +587,30 @@ var RedditClient = class {
 			params.append("title", title);
 			params.append(isSelf ? "text" : "url", finalContent);
 			params.append("api_type", "json");
+			if (flairId !== void 0) params.append("flair_id", flairId);
+			if (flairText !== void 0) params.append("flair_text", flairText);
 			const response = (await this.makeRequest("/api/submit", {
 				method: "POST",
 				headers: { "Content-Type": "application/x-www-form-urlencoded" },
 				body: params.toString()
 			})).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to create post: HTTP ${response.status}`));
+			if (!response.ok) throw new HttpError(response.status, `Failed to create post: HTTP ${response.status}`);
 			const json = await response.json();
-			if (json.json.errors !== void 0 && json.json.errors.length > 0) {
-				const errors = json.json.errors.map((e) => e[1]).join(", ");
-				return Left(/* @__PURE__ */ new Error(`Reddit API errors: ${errors}`));
-			}
+			if (json.json.errors !== void 0 && json.json.errors.length > 0) throw new ApiError(`Reddit API errors: ${json.json.errors.map((e) => e[1]).join(", ")}`);
 			const postId = ((_json$json$data = json.json.data) === null || _json$json$data === void 0 ? void 0 : _json$json$data.id) ?? ((_json$json$data2 = json.json.data) === null || _json$json$data2 === void 0 || (_json$json$data2 = _json$json$data2.name) === null || _json$json$data2 === void 0 ? void 0 : _json$json$data2.replace("t3_", ""));
-			if (postId === void 0) return Left(/* @__PURE__ */ new Error("No post ID returned from Reddit"));
-			return this.getPost(postId, subreddit);
-		} catch (error) {
-			return Left(toError(error));
-		}
+			if (postId === void 0) throw new ApiError("No post ID returned from Reddit");
+			return (await this.getPost(postId, subreddit)).orThrow();
+		})).toEither((error) => classifyRedditError(error));
 	}
 	async checkPostExists(postId) {
-		try {
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`/api/info.json?id=t3_${postId}`)).orThrow();
 			if (!response.ok) return false;
 			return (await response.json()).data.children.length > 0;
-		} catch {
-			return false;
-		}
+		})).orElse(false);
 	}
 	async replyToPost(postId, content) {
-		try {
+		return (await Try.async(async () => {
 			var _json$json$data3;
 			this.validateWriteAccess();
 			await this.enforceWriteRateLimit();
@@ -317,7 +618,7 @@ var RedditClient = class {
 			const finalContent = this.appendBotDisclosure(content);
 			const fullThingId = postId.startsWith("t3_") || postId.startsWith("t1_") ? postId : `t3_${postId}`;
 			if (!postId.startsWith("t1_")) {
-				if (!await this.checkPostExists(postId.replace(/^t3_/, ""))) return Left(/* @__PURE__ */ new Error(`Post with ID ${postId} does not exist or is not accessible`));
+				if (!await this.checkPostExists(postId.replace(/^t3_/, ""))) throw new NotFoundError(`Post with ID ${postId} does not exist or is not accessible`);
 			}
 			const params = new URLSearchParams();
 			params.append("thing_id", fullThingId);
@@ -328,12 +629,12 @@ var RedditClient = class {
 				headers: { "Content-Type": "application/x-www-form-urlencoded" },
 				body: params.toString()
 			})).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to reply: HTTP ${response.status}`));
+			if (!response.ok) throw new HttpError(response.status, `Failed to reply: HTTP ${response.status}`);
 			const json = await response.json();
 			if (((_json$json$data3 = json.json.data) === null || _json$json$data3 === void 0 ? void 0 : _json$json$data3.things) !== void 0 && json.json.data.things.length > 0) {
 				const commentData = json.json.data.things[0].data;
 				const author = this.username ?? "[unknown]";
-				return Right({
+				return {
 					id: commentData.id,
 					author,
 					body: content,
@@ -345,17 +646,13 @@ var RedditClient = class {
 					edited: false,
 					isSubmitter: false,
 					permalink: commentData.permalink
-				});
-			} else if (json.json.errors !== void 0 && json.json.errors.length > 0) {
-				const errors = json.json.errors.map((e) => e[1]).join(", ");
-				return Left(/* @__PURE__ */ new Error(`Reddit API errors: ${errors}`));
-			} else return Left(/* @__PURE__ */ new Error("Failed to parse reply response"));
-		} catch (error) {
-			return Left(toError(error));
-		}
+				};
+			} else if (json.json.errors !== void 0 && json.json.errors.length > 0) throw new ApiError(`Reddit API errors: ${json.json.errors.map((e) => e[1]).join(", ")}`);
+			else throw new ApiError("Failed to parse reply response");
+		})).toEither((error) => classifyRedditError(error));
 	}
 	async deletePost(thingId) {
-		try {
+		return (await Try.async(async () => {
 			this.validateWriteAccess();
 			const fullThingId = thingId.startsWith("t3_") || thingId.startsWith("t1_") ? thingId : `t3_${thingId}`;
 			const params = new URLSearchParams();
@@ -369,21 +666,21 @@ var RedditClient = class {
 				const errorText = await response.text();
 				console.error(`[Reddit API] Delete failed: ${response.status} ${response.statusText}`);
 				console.error(`[Reddit API] Error response: ${errorText}`);
-				return Left(/* @__PURE__ */ new Error(`HTTP ${response.status}: ${errorText}`));
+				throw new HttpError(response.status, `HTTP ${response.status}: ${errorText}`);
 			}
 			console.error(`[Reddit API] Successfully deleted ${fullThingId}`);
-			return Right(true);
-		} catch (error) {
-			console.error(`[Reddit API] Delete exception:`, error);
-			return Left(toError(error));
-		}
+			return true;
+		})).toEither((error) => {
+			if (!isRedditError(error)) console.error(`[Reddit API] Delete exception:`, error);
+			return classifyRedditError(error);
+		});
 	}
 	async deleteComment(thingId) {
 		const fullThingId = thingId.startsWith("t1_") ? thingId : `t1_${thingId}`;
 		return this.deletePost(fullThingId);
 	}
 	async editPost(thingId, newText) {
-		try {
+		return (await Try.async(async () => {
 			this.validateWriteAccess();
 			await this.enforceWriteRateLimit();
 			this.checkDuplicateContent(newText);
@@ -398,23 +695,18 @@ var RedditClient = class {
 				headers: { "Content-Type": "application/x-www-form-urlencoded" },
 				body: params.toString()
 			})).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to edit: HTTP ${response.status}`));
+			if (!response.ok) throw new HttpError(response.status, `Failed to edit: HTTP ${response.status}`);
 			const json = await response.json();
-			if (json.json.errors !== void 0 && json.json.errors.length > 0) {
-				const errors = json.json.errors.map((e) => e[1]).join(", ");
-				return Left(/* @__PURE__ */ new Error(`Reddit API errors: ${errors}`));
-			}
-			return Right(true);
-		} catch (error) {
-			return Left(toError(error));
-		}
+			if (json.json.errors !== void 0 && json.json.errors.length > 0) throw new ApiError(`Reddit API errors: ${json.json.errors.map((e) => e[1]).join(", ")}`);
+			return true;
+		})).toEither((error) => classifyRedditError(error));
 	}
 	async editComment(thingId, newText) {
 		const fullThingId = thingId.startsWith("t1_") ? thingId : `t1_${thingId}`;
 		return this.editPost(fullThingId, newText);
 	}
 	async searchReddit(query, options = {}) {
-		const { subreddit, sort = "relevance", timeFilter = "all", limit = 25, type = "link" } = options;
+		const { subreddit, sort = "relevance", timeFilter = "all", limit = 25, type = "link", after, before } = options;
 		const endpoint = Option(subreddit).fold(() => "/search.json", (sr) => `/r/${sr}/search.json`);
 		const params = new URLSearchParams({
 			q: query,
@@ -422,15 +714,20 @@ var RedditClient = class {
 			t: timeFilter,
 			limit: limit.toString(),
 			type,
-			...subreddit !== void 0 ? { restrict_sr: "true" } : {}
+			...subreddit !== void 0 ? { restrict_sr: "true" } : {},
+			...after !== void 0 ? { after } : {},
+			...before !== void 0 ? { before } : {}
 		});
-		try {
+		const context = `Failed to search Reddit for: ${query}`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`${endpoint}?${params}`)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to search Reddit: HTTP ${response.status}`));
-			return Right((await response.json()).data.children.filter((child) => child.kind === "t3").map((child) => parsePostData(child.data)));
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to search Reddit for: ${query}: ${toError(error).message}`));
-		}
+			if (!response.ok) throw new HttpError(response.status, `Failed to search Reddit: HTTP ${response.status}`);
+			const json = await response.json();
+			return {
+				items: json.data.children.filter((child) => child.kind === "t3").map((child) => parsePostData(child.data)),
+				...listingCursor(json.data)
+			};
+		})).toEither((error) => classifyRedditError(error, context));
 	}
 	async getPostComments(postId, subreddit, options = {}) {
 		const { sort = "best", limit = 100 } = options;
@@ -438,9 +735,10 @@ var RedditClient = class {
 			sort,
 			limit: limit.toString()
 		});
-		try {
+		const context = `Failed to get comments for post ${postId}`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`/r/${subreddit}/comments/${postId}.json?${params}`)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to get comments: HTTP ${response.status}`));
+			if (!response.ok) throw new HttpError(response.status, `Failed to get comments: HTTP ${response.status}`);
 			const json = await response.json();
 			const postData = json[0].data.children[0].data;
 			const post = parsePostData(postData);
@@ -464,58 +762,95 @@ var RedditClient = class {
 				const { replies } = item.data;
 				return [comment, ...replies !== void 0 && typeof replies !== "string" ? parseComments(replies.data.children, depth + 1) : []];
 			});
-			return Right({
+			return {
 				post,
 				comments: parseComments(json[1].data.children)
+			};
+		})).toEither((error) => classifyRedditError(error, context));
+	}
+	async getMoreComments(linkId, commentIds) {
+		const fullLinkId = linkId.startsWith("t3_") ? linkId : `t3_${linkId}`;
+		const context = `Failed to expand comments for ${fullLinkId}`;
+		const params = new URLSearchParams({
+			api_type: "json",
+			link_id: fullLinkId,
+			children: commentIds.join(",")
+		});
+		return (await Try.async(async () => {
+			var _json$json$data4;
+			const response = (await this.makeRequest(`/api/morechildren?${params}`)).orThrow();
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			return (((_json$json$data4 = (await response.json()).json.data) === null || _json$json$data4 === void 0 ? void 0 : _json$json$data4.things) ?? []).filter((thing) => thing.kind === "t1" && thing.data.body !== void 0).map((thing) => {
+				const comment = thing.data;
+				return {
+					id: comment.id,
+					author: comment.author,
+					body: comment.body ?? "",
+					score: comment.score,
+					controversiality: comment.controversiality,
+					subreddit: comment.subreddit,
+					submissionTitle: comment.link_title ?? "",
+					createdUtc: comment.created_utc,
+					edited: Boolean(comment.edited),
+					isSubmitter: comment.is_submitter,
+					permalink: comment.permalink,
+					parentId: comment.parent_id
+				};
 			});
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to get comments for post ${postId}: ${toError(error).message}`));
-		}
+		})).toEither((error) => classifyRedditError(error, context));
 	}
 	async getUserPosts(username, options = {}) {
-		const { sort = "new", timeFilter = "all", limit = 25 } = options;
+		const { sort = "new", timeFilter = "all", limit = 25, after } = options;
 		const params = new URLSearchParams({
 			sort,
 			t: timeFilter,
 			limit: limit.toString()
 		});
-		try {
+		if (after !== void 0) params.set("after", after);
+		const context = `Failed to get posts for user ${username}`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`/user/${username}/submitted.json?${params}`)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to get posts for user ${username}: HTTP ${response.status}`));
-			return Right((await response.json()).data.children.filter((child) => child.kind === "t3").map((child) => parsePostData(child.data)));
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to get posts for user ${username}: ${toError(error).message}`));
-		}
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			const json = await response.json();
+			return {
+				items: json.data.children.filter((child) => child.kind === "t3").map((child) => parsePostData(child.data)),
+				...listingCursor(json.data)
+			};
+		})).toEither((error) => classifyRedditError(error, context));
 	}
 	async getUserComments(username, options = {}) {
-		const { sort = "new", timeFilter = "all", limit = 25 } = options;
+		const { sort = "new", timeFilter = "all", limit = 25, after } = options;
 		const params = new URLSearchParams({
 			sort,
 			t: timeFilter,
 			limit: limit.toString()
 		});
-		try {
+		if (after !== void 0) params.set("after", after);
+		const context = `Failed to get comments for user ${username}`;
+		return (await Try.async(async () => {
 			const response = (await this.makeRequest(`/user/${username}/comments.json?${params}`)).orThrow();
-			if (!response.ok) return Left(/* @__PURE__ */ new Error(`Failed to get comments for user ${username}: HTTP ${response.status}`));
-			return Right((await response.json()).data.children.filter((child) => child.kind === "t1").map((child) => {
-				const comment = child.data;
-				return {
-					id: comment.id,
-					author: comment.author,
-					body: comment.body ?? "",
-					score: comment.score,
-					controversiality: comment.controversiality,
-					subreddit: comment.subreddit,
-					submissionTitle: comment.link_title ?? "",
-					createdUtc: comment.created_utc,
-					edited: Boolean(comment.edited),
-					isSubmitter: comment.is_submitter,
-					permalink: comment.permalink
-				};
-			}));
-		} catch (error) {
-			return Left(/* @__PURE__ */ new Error(`Failed to get comments for user ${username}: ${toError(error).message}`));
-		}
+			if (!response.ok) throw new HttpError(response.status, `${context}: HTTP ${response.status}`);
+			const json = await response.json();
+			return {
+				items: json.data.children.filter((child) => child.kind === "t1").map((child) => {
+					const comment = child.data;
+					return {
+						id: comment.id,
+						author: comment.author,
+						body: comment.body ?? "",
+						score: comment.score,
+						controversiality: comment.controversiality,
+						subreddit: comment.subreddit,
+						submissionTitle: comment.link_title ?? "",
+						createdUtc: comment.created_utc,
+						edited: Boolean(comment.edited),
+						isSubmitter: comment.is_submitter,
+						permalink: comment.permalink
+					};
+				}),
+				...listingCursor(json.data)
+			};
+		})).toEither((error) => classifyRedditError(error, context));
 	}
 };
 const clientHolder = { instance: Option.none() };
@@ -657,7 +992,7 @@ function formatSubredditInfo(subreddit) {
 //#endregion
 //#region src/index.ts
 dotenv.config({ quiet: true });
-const VERSION = "1.4.7";
+const VERSION = "1.5.0";
 function validateUserAgent(userAgent, username) {
 	if (!/^[\w-]+:[\w-]+:[\d.]+ \(by \/u\/\w+\)$/.test(userAgent)) {
 		console.error("[Warning] User-Agent does not follow Reddit's recommended format");
@@ -708,6 +1043,15 @@ function buildSafeModeConfig(safeMode) {
 function unwrapClient() {
 	return getRedditClient().orThrow(/* @__PURE__ */ new Error("Reddit client not initialized"));
 }
+function nextPageHint(after) {
+	return Option(after).fold(() => "", (cursor) => `\n\n---\nMore results available — call again with after="${cursor}" for the next page.`);
+}
+function formatUserContent(heading, content) {
+	return `# ${heading}\n\n${content.posts.length === 0 ? "" : `## Posts (${content.posts.length})\n${content.posts.map((post, index) => `${index + 1}. ${post.title} — r/${post.subreddit}, score ${post.score.toLocaleString()} — https://reddit.com${post.permalink}`).join("\n")}\n\n`}${content.comments.length === 0 ? "" : `## Comments (${content.comments.length})\n${content.comments.map((comment, index) => {
+		const body = comment.body.length > 200 ? `${comment.body.substring(0, 200)}...` : comment.body;
+		return `${index + 1}. in r/${comment.subreddit}: ${body} — https://reddit.com${comment.permalink}`;
+	}).join("\n")}\n\n`}${content.posts.length === 0 && content.comments.length === 0 ? "No items found.\n\n" : ""}`.trimEnd() + nextPageHint(content.after);
+}
 async function setupRedditClient() {
 	const clientId = process.env.REDDIT_CLIENT_ID;
 	const clientSecret = process.env.REDDIT_CLIENT_SECRET;
@@ -746,6 +1090,13 @@ async function setupRedditClient() {
 		enabled: botDisclosureMode === "auto",
 		footer: botDisclosureMode === "auto" ? process.env.REDDIT_BOT_FOOTER ?? "\n\n---\n^(🤖 I am a bot | Built with) [^reddit-mcp-server](https://github.com/jordanburke/reddit-mcp-server)" : ""
 	};
+	const cacheEnabled = (process.env.REDDIT_CACHE ?? "on") !== "off";
+	const cacheMaxMb = Number(process.env.REDDIT_CACHE_MAX_MB ?? "50");
+	const cacheConfig = {
+		enabled: cacheEnabled,
+		maxBytes: (Number.isFinite(cacheMaxMb) && cacheMaxMb > 0 ? cacheMaxMb : 50) * 1024 * 1024
+	};
+	const maxRetriesRaw = Number(process.env.REDDIT_MAX_RETRIES ?? "3");
 	const client = initializeRedditClient({
 		clientId: clientId ?? "",
 		clientSecret: clientSecret ?? "",
@@ -754,7 +1105,13 @@ async function setupRedditClient() {
 		password,
 		authMode,
 		safeMode: safeModeConfig,
-		botDisclosure: botDisclosureConfig
+		botDisclosure: botDisclosureConfig,
+		cache: cacheConfig,
+		retry: {
+			maxRetries: Number.isFinite(maxRetriesRaw) && maxRetriesRaw >= 0 ? Math.floor(maxRetriesRaw) : 3,
+			baseDelayMs: 1e3,
+			maxDelayMs: 6e4
+		}
 	});
 	console.error("[Setup] Reddit client initialized");
 	console.error(`[Setup] Authentication mode: ${authMode}`);
@@ -880,6 +1237,61 @@ server.addTool({
 		});
 	}
 });
+server.addTool({
+	name: "get_me",
+	description: "Get the authenticated user's own account info (karma, account status). Requires user credentials (REDDIT_USERNAME/REDDIT_PASSWORD); fails in anonymous mode.",
+	parameters: z.object({}),
+	execute: async () => {
+		return (await unwrapClient().getMe()).fold((err) => {
+			throw new Error(`Failed to get authenticated user: ${err.message}`);
+		}, (user) => {
+			const formattedUser = formatUserInfo(user);
+			return `# Your Account: u/${formattedUser.username}
+
+## Profile Overview
+- Username: u/${formattedUser.username}
+- Karma:
+  - Comment Karma: ${formattedUser.karma.commentKarma.toLocaleString()}
+  - Post Karma: ${formattedUser.karma.postKarma.toLocaleString()}
+  - Total Karma: ${formattedUser.karma.totalKarma.toLocaleString()}
+- Account Status: ${formattedUser.accountStatus.join(", ")}
+- Account Created: ${formattedUser.accountCreated}
+- Profile URL: ${formattedUser.profileUrl}`;
+		});
+	}
+});
+server.addTool({
+	name: "get_my_overview",
+	description: "Get your own recent activity (posts and comments combined). Requires user credentials (REDDIT_USERNAME/REDDIT_PASSWORD).",
+	parameters: z.object({
+		limit: z.number().min(1).max(100).default(25).describe("Number of items to retrieve"),
+		after: z.string().optional().describe("Pagination cursor: pass the `after` value from a previous page")
+	}),
+	execute: async (args) => {
+		return (await unwrapClient().getMyOverview({
+			limit: args.limit,
+			after: args.after
+		})).fold((err) => {
+			throw new Error(`Failed to get your overview: ${err.message}`);
+		}, (content) => formatUserContent("Your Overview", content));
+	}
+});
+server.addTool({
+	name: "get_my_saved",
+	description: "Get your saved posts and comments. Requires user credentials (REDDIT_USERNAME/REDDIT_PASSWORD); saved content is private.",
+	parameters: z.object({
+		limit: z.number().min(1).max(100).default(25).describe("Number of items to retrieve"),
+		after: z.string().optional().describe("Pagination cursor: pass the `after` value from a previous page")
+	}),
+	execute: async (args) => {
+		return (await unwrapClient().getMySaved({
+			limit: args.limit,
+			after: args.after
+		})).fold((err) => {
+			throw new Error(`Failed to get saved content: ${err.message}`);
+		}, (content) => formatUserContent("Your Saved Content", content));
+	}
+});
 server.addTool({
 	name: "get_user_posts",
 	description: "Get recent posts by a Reddit user with sorting and filtering options",
@@ -898,16 +1310,19 @@ server.addTool({
 			"year",
 			"all"
 		]).default("all").describe("Time filter for top posts"),
-		limit: z.number().min(1).max(100).default(10).describe("Number of posts to retrieve")
+		limit: z.number().min(1).max(100).default(10).describe("Number of posts to retrieve"),
+		after: z.string().optional().describe("Pagination cursor: pass the `after` value from a previous page to fetch the next page")
 	}),
 	execute: async (args) => {
 		return (await unwrapClient().getUserPosts(args.username, {
 			sort: args.sort,
 			timeFilter: args.time_filter,
-			limit: args.limit
+			limit: args.limit,
+			after: args.after
 		})).fold((err) => {
 			throw new Error(`Failed to get user posts: ${err.message}`);
-		}, (posts) => {
+		}, (page) => {
+			const posts = page.items;
 			if (posts.length === 0) return `No posts found for u/${args.username} with the specified filters.`;
 			const postSummaries = posts.map((post, index) => {
 				const flags = [...post.over18 ? ["**NSFW**"] : [], ...post.spoiler === true ? ["**Spoiler**"] : []];
@@ -920,7 +1335,7 @@ server.addTool({
 			}).join("\n\n");
 			return `# Posts by u/${args.username} (${args.sort} - ${args.time_filter})
 
-${postSummaries}`;
+${postSummaries}${nextPageHint(page.after)}`;
 		});
 	}
 });
@@ -942,16 +1357,19 @@ server.addTool({
 			"year",
 			"all"
 		]).default("all").describe("Time filter for top comments"),
-		limit: z.number().min(1).max(100).default(10).describe("Number of comments to retrieve")
+		limit: z.number().min(1).max(100).default(10).describe("Number of comments to retrieve"),
+		after: z.string().optional().describe("Pagination cursor: pass the `after` value from a previous page to fetch the next page")
 	}),
 	execute: async (args) => {
 		return (await unwrapClient().getUserComments(args.username, {
 			sort: args.sort,
 			timeFilter: args.time_filter,
-			limit: args.limit
+			limit: args.limit,
+			after: args.after
 		})).fold((err) => {
 			throw new Error(`Failed to get user comments: ${err.message}`);
-		}, (comments) => {
+		}, (page) => {
+			const comments = page.items;
 			if (comments.length === 0) return `No comments found for u/${args.username} with the specified filters.`;
 			const commentSummaries = comments.map((comment, index) => {
 				const truncatedBody = comment.body.length > 300 ? `${comment.body.substring(0, 300)}...` : comment.body;
@@ -967,7 +1385,7 @@ In r/${comment.subreddit} on "${comment.submissionTitle}"
 			}).join("\n\n");
 			return `# Comments by u/${args.username} (${args.sort} - ${args.time_filter})
 
-${commentSummaries}`;
+${commentSummaries}${nextPageHint(page.after)}`;
 		});
 	}
 });
@@ -1028,12 +1446,14 @@ server.addTool({
 			"year",
 			"all"
 		]).default("week").describe("Time period for top posts"),
-		limit: z.number().min(1).max(100).default(10).describe("Number of posts to retrieve")
+		limit: z.number().min(1).max(100).default(10).describe("Number of posts to retrieve"),
+		after: z.string().optional().describe("Pagination cursor: pass the `after` value from a previous page to fetch the next page")
 	}),
 	execute: async (args) => {
-		return (await unwrapClient().getTopPosts(args.subreddit ?? "", args.time_filter, args.limit)).fold((err) => {
+		return (await unwrapClient().getTopPosts(args.subreddit ?? "", args.time_filter, args.limit, args.after)).fold((err) => {
 			throw new Error(`Failed to get top posts: ${err.message}`);
-		}, (posts) => {
+		}, (page) => {
+			const posts = page.items;
 			if (posts.length === 0) return `No posts found in ${Option(args.subreddit).fold(() => "home feed", (sr) => `r/${sr}`)} for the specified time period.`;
 			const postSummaries = posts.map(formatPostInfo).map((post, index) => `### ${index + 1}. ${post.title}
 - Author: u/${post.author}
@@ -1043,7 +1463,51 @@ server.addTool({
 - Link: ${post.links.shortLink}`).join("\n\n");
 			return `# Top Posts from ${Option(args.subreddit).fold(() => "Home Feed", (sr) => `r/${sr}`)} (${args.time_filter})
 
-${postSummaries}`;
+${postSummaries}${nextPageHint(page.after)}`;
+		});
+	}
+});
+server.addTool({
+	name: "browse_subreddit",
+	description: "Browse posts from a subreddit or the Reddit home feed with a sort order (hot, new, top, rising, controversial). The time_filter only applies to top and controversial sorts.",
+	parameters: z.object({
+		subreddit: z.string().optional().describe("The subreddit name (without r/ prefix). Leave empty for home feed"),
+		sort: z.enum([
+			"hot",
+			"new",
+			"top",
+			"rising",
+			"controversial"
+		]).default("hot").describe("Sort order for posts"),
+		time_filter: z.enum([
+			"hour",
+			"day",
+			"week",
+			"month",
+			"year",
+			"all"
+		]).default("week").describe("Time period (only applies to top and controversial sorts)"),
+		limit: z.number().min(1).max(100).default(10).describe("Number of posts to retrieve"),
+		after: z.string().optional().describe("Pagination cursor: pass the `after` value from a previous page to fetch the next page")
+	}),
+	execute: async (args) => {
+		return (await unwrapClient().browseSubreddit(args.subreddit ?? "", args.sort, args.time_filter, args.limit, args.after)).fold((err) => {
+			throw new Error(`Failed to browse subreddit: ${err.message}`);
+		}, (page) => {
+			const posts = page.items;
+			const location = Option(args.subreddit).fold(() => "home feed", (sr) => `r/${sr}`);
+			if (posts.length === 0) return `No posts found in ${location}.`;
+			const postSummaries = posts.map(formatPostInfo).map((post, index) => `### ${index + 1}. ${post.title}
+- Author: u/${post.author}
+- Score: ${post.stats.score.toLocaleString()} (${(post.stats.upvoteRatio * 100).toFixed(1)}% upvoted)
+- Comments: ${post.stats.comments.toLocaleString()}
+- Posted: ${post.metadata.posted}
+- Link: ${post.links.shortLink}`).join("\n\n");
+			const timeSuffix = args.sort === "top" || args.sort === "controversial" ? `, ${args.time_filter}` : "";
+			const heading = location === "home feed" ? "Home Feed" : location;
+			return `# ${args.sort} posts from ${heading} (${args.sort}${timeSuffix})
+
+${postSummaries}${nextPageHint(page.after)}`;
 		});
 	}
 });
@@ -1086,6 +1550,47 @@ ${formattedSubreddit.description.full}
 		});
 	}
 });
+server.addTool({
+	name: "get_subreddit_rules",
+	description: "Get a subreddit's posting rules. Useful to check requirements before creating a post to avoid auto-removal.",
+	parameters: z.object({ subreddit_name: z.string().describe("The subreddit name (without r/ prefix)") }),
+	execute: async (args) => {
+		return (await unwrapClient().getSubredditRules(args.subreddit_name)).fold((err) => {
+			throw new Error(`Failed to get subreddit rules: ${err.message}`);
+		}, (rules) => {
+			if (rules.length === 0) return `r/${args.subreddit_name} has no listed subreddit-specific rules.`;
+			const ruleList = rules.map((rule, index) => {
+				const applies = rule.kind === "all" ? "posts & comments" : `${rule.kind}s`;
+				const detail = rule.description.trim() === "" ? "" : `\n${rule.description.trim()}`;
+				return `### ${index + 1}. ${rule.shortName} _(applies to ${applies})_${detail}`;
+			}).join("\n\n");
+			return `# Posting Rules for r/${args.subreddit_name}
+
+${ruleList}`;
+		});
+	}
+});
+server.addTool({
+	name: "get_post_flairs",
+	description: "List the available link flairs for a subreddit (use a flair_id with create_post). Requires user credentials; many subreddits only expose flairs to members, so this may fail in anonymous mode.",
+	parameters: z.object({ subreddit_name: z.string().describe("The subreddit name (without r/ prefix)") }),
+	execute: async (args) => {
+		return (await unwrapClient().getPostFlairs(args.subreddit_name)).fold((err) => {
+			throw new Error(`Failed to get post flairs: ${err.message}`);
+		}, (flairs) => {
+			if (flairs.length === 0) return `r/${args.subreddit_name} has no selectable link flairs (or none are visible to this account).`;
+			const flairList = flairs.map((flair) => {
+				const editable = flair.textEditable === true ? " _(text editable)_" : "";
+				return `- ${flair.text}${editable} — \`flair_id: ${flair.id}\``;
+			}).join("\n");
+			return `# Available Link Flairs for r/${args.subreddit_name}
+
+${flairList}
+
+Pass the desired \`flair_id\` to \`create_post\`.`;
+		});
+	}
+});
 server.addTool({
 	name: "get_trending_subreddits",
 	description: "Get a list of currently trending subreddits",
@@ -1110,7 +1615,7 @@ server.addTool({
 			"top",
 			"new",
 			"comments"
-		]).default("relevance").describe("Sort order"),
+		]).default("relevance").describe("Sort order. Prefer 'relevance' (default) for finding posts about a topic. Use 'top'/'hot' only for what's currently popular and 'new' for the latest — these rank by karma/recency and, especially combined with a narrow time_filter, can surface loosely-matching posts over the best topical results."),
 		time_filter: z.enum([
 			"hour",
 			"day",
@@ -1124,7 +1629,8 @@ server.addTool({
 			"link",
 			"sr",
 			"user"
-		]).default("link").describe("Type of content to search")
+		]).default("link").describe("Type of content to search"),
+		after: z.string().optional().describe("Pagination cursor: pass the `after` value from a previous page to fetch the next page")
 	}),
 	execute: async (args) => {
 		const client = unwrapClient();
@@ -1134,10 +1640,12 @@ server.addTool({
 			sort: args.sort,
 			timeFilter: args.time_filter,
 			limit: args.limit,
-			type: args.type
+			type: args.type,
+			after: args.after
 		})).fold((err) => {
 			throw new Error(`Failed to search: ${err.message}`);
-		}, (posts) => {
+		}, (page) => {
+			const posts = page.items;
 			if (posts.length === 0) {
 				const searchLocation = Option(args.subreddit).fold(() => "", (sr) => ` in r/${sr}`);
 				return `No results found for "${args.query}"${searchLocation}.`;
@@ -1157,7 +1665,7 @@ server.addTool({
 
 Sorted by: ${args.sort} | Time: ${args.time_filter} | Type: ${args.type}
 
-${searchResults}`;
+${searchResults}${nextPageHint(page.after)}`;
 		});
 	}
 });
@@ -1168,12 +1676,14 @@ server.addTool({
 		subreddit: z.string().describe("The subreddit name (without r/ prefix)"),
 		title: z.string().describe("The post title"),
 		content: z.string().describe("The post content (text for self posts, URL for link posts)"),
-		is_self: z.boolean().default(true).describe("Whether this is a self post (text) or link post")
+		is_self: z.boolean().default(true).describe("Whether this is a self post (text) or link post"),
+		flair_id: z.string().optional().describe("Link flair template id (from get_post_flairs); many subreddits require a flair"),
+		flair_text: z.string().optional().describe("Custom flair text, only for flairs whose template is text-editable")
 	}),
 	execute: async (args) => {
 		const client = unwrapClient();
 		if (process.env.REDDIT_USERNAME === void 0 || process.env.REDDIT_PASSWORD === void 0) throw new Error("User authentication required. Please set REDDIT_USERNAME and REDDIT_PASSWORD environment variables.");
-		return (await client.createPost(args.subreddit, args.title, args.content, args.is_self)).fold((err) => {
+		return (await client.createPost(args.subreddit, args.title, args.content, args.is_self, args.flair_id, args.flair_text)).fold((err) => {
 			throw new Error(`Failed to create post: ${err.message}`);
 		}, (post) => {
 			const formattedPost = formatPostInfo(post);
@@ -1333,6 +1843,33 @@ ${comment.body}
 		});
 	}
 });
+server.addTool({
+	name: "get_more_comments",
+	description: "Expand truncated 'load more comments' stubs in a thread. Pass the post's link id and the comment ids from a 'more' node (returned by get_post_comments) to fetch those comments.",
+	parameters: z.object({
+		link_id: z.string().describe("The post (link) id, with or without the t3_ prefix"),
+		comment_ids: z.array(z.string()).min(1).describe("Comment ids to expand (from a 'more' node)")
+	}),
+	execute: async (args) => {
+		return (await unwrapClient().getMoreComments(args.link_id, args.comment_ids)).fold((err) => {
+			throw new Error(`Failed to expand comments: ${err.message}`);
+		}, (comments) => {
+			if (comments.length === 0) return "No additional comments were returned for those ids.";
+			const commentList = comments.map((comment, index) => {
+				const truncated = comment.body.length > 300 ? `${comment.body.substring(0, 300)}...` : comment.body;
+				const flags = [...comment.edited ? ["*(edited)*"] : [], ...comment.isSubmitter ? ["**OP**"] : []];
+				return `### ${index + 1}. u/${comment.author} ${flags.join(" ")}
+> ${truncated}
+
+- Score: ${comment.score.toLocaleString()}
+- Link: https://reddit.com${comment.permalink}`;
+			}).join("\n\n");
+			return `# Expanded Comments (${comments.length})
+
+${commentList}`;
+		});
+	}
+});
 async function main() {
 	await setupRedditClient();
 	const useHttp = process.env.TRANSPORT_TYPE === "httpStream" || process.env.TRANSPORT_TYPE === "http";