@oh-my-pi/pi-coding-agent 3.30.0 → 3.32.0

package/src/core/tools/web-scrapers/orcid.ts

@@ -0,0 +1,299 @@
+/**
+ * ORCID handler for web-fetch
+ */
+
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, loadPage } from "./types";
+
+const MAX_WORKS = 50;
+const ORCID_PATTERN = /\/(\d{4}-\d{4}-\d{4}-\d{3}[\dXx])(?:\/|$)/;
+
+interface OrcidName {
+	"given-names"?: { value?: string };
+	"family-name"?: { value?: string };
+	"credit-name"?: { value?: string };
+}
+
+interface OrcidBiography {
+	content?: string;
+}
+
+interface OrcidPerson {
+	name?: OrcidName;
+	biography?: OrcidBiography;
+}
+
+interface OrcidSummaryDate {
+	year?: { value?: string };
+	month?: { value?: string };
+	day?: { value?: string };
+}
+
+interface OrcidOrganizationAddress {
+	city?: string;
+	region?: string;
+	country?: string;
+}
+
+interface OrcidOrganization {
+	name?: string;
+	address?: OrcidOrganizationAddress;
+}
+
+interface OrcidAffiliationSummary {
+	organization?: OrcidOrganization;
+	"role-title"?: string;
+	"department-name"?: string;
+	"start-date"?: OrcidSummaryDate;
+	"end-date"?: OrcidSummaryDate;
+}
+
+interface OrcidAffiliationGroupSummary {
+	"employment-summary"?: OrcidAffiliationSummary;
+	"education-summary"?: OrcidAffiliationSummary;
+}
+
+interface OrcidAffiliationGroup {
+	summaries?: OrcidAffiliationGroupSummary[];
+}
+
+interface OrcidAffiliationsContainer {
+	"affiliation-group"?: OrcidAffiliationGroup[];
+	"employment-summary"?: OrcidAffiliationSummary[];
+	"education-summary"?: OrcidAffiliationSummary[];
+}
+
+interface OrcidWorkTitle {
+	title?: { value?: string };
+}
+
+interface OrcidWorkSummary {
+	title?: OrcidWorkTitle;
+}
+
+interface OrcidWorkGroup {
+	"work-summary"?: OrcidWorkSummary[];
+}
+
+interface OrcidWorksContainer {
+	group?: OrcidWorkGroup[];
+}
+
+interface OrcidActivitiesSummary {
+	employments?: OrcidAffiliationsContainer;
+	educations?: OrcidAffiliationsContainer;
+	works?: OrcidWorksContainer;
+}
+
+interface OrcidRecord {
+	"orcid-identifier"?: { path?: string; uri?: string };
+	person?: OrcidPerson;
+	"activities-summary"?: OrcidActivitiesSummary;
+}
+
+function isOrcidHost(hostname: string): boolean {
+	return hostname === "orcid.org" || hostname === "www.orcid.org";
+}
+
+function extractOrcidId(pathname: string): string | null {
+	const match = pathname.match(ORCID_PATTERN);
+	return match?.[1] ?? null;
+}
+
+function formatName(name?: OrcidName): string | null {
+	const credit = name?.["credit-name"]?.value?.trim();
+	if (credit) return credit;
+
+	const given = name?.["given-names"]?.value?.trim();
+	const family = name?.["family-name"]?.value?.trim();
+	if (given && family) return `${given} ${family}`;
+	return given || family || null;
+}
+
+function formatDate(date?: OrcidSummaryDate): string | null {
+	const year = date?.year?.value;
+	if (!year) return null;
+
+	const month = date?.month?.value;
+	const day = date?.day?.value;
+	if (month && day) {
+		return `${year}-${month.padStart(2, "0")}-${day.padStart(2, "0")}`;
+	}
+	if (month) return `${year}-${month.padStart(2, "0")}`;
+	return year;
+}
+
+function collectAffiliations(
+	container: OrcidAffiliationsContainer | undefined,
+	key: "employment-summary" | "education-summary",
+): OrcidAffiliationSummary[] {
+	const summaries: OrcidAffiliationSummary[] = [];
+
+	if (!container) return summaries;
+
+	const direct = container[key];
+	if (direct?.length) summaries.push(...direct);
+
+	const groups = container["affiliation-group"];
+	if (groups?.length) {
+		for (const group of groups) {
+			const groupSummaries = group.summaries || [];
+			for (const summary of groupSummaries) {
+				const entry = summary[key];
+				if (entry) summaries.push(entry);
+			}
+		}
+	}
+
+	return summaries;
+}
+
+function formatAffiliation(summary: OrcidAffiliationSummary): string | null {
+	const organization = summary.organization?.name?.trim();
+	const role = summary["role-title"]?.trim();
+	const department = summary["department-name"]?.trim();
+
+	const address = summary.organization?.address;
+	const locationParts = [address?.city, address?.region, address?.country].filter(Boolean) as string[];
+	const location = locationParts.length > 0 ? locationParts.join(", ") : null;
+
+	const start = formatDate(summary["start-date"]);
+	const end = formatDate(summary["end-date"]);
+	let dates: string | null = null;
+	if (start && end) {
+		dates = `${start} - ${end}`;
+	} else if (start) {
+		dates = `${start} - Present`;
+	} else if (end) {
+		dates = `Until ${end}`;
+	}
+
+	const label = organization || role || department;
+	if (!label) return null;
+
+	const details: string[] = [];
+	if (organization && role) details.push(role);
+	if (!organization && role && department) details.push(department);
+	if (organization && department) details.push(`Dept: ${department}`);
+	if (location) details.push(`Location: ${location}`);
+	if (dates) details.push(`Dates: ${dates}`);
+
+	if (details.length === 0) return label;
+	return `${label} (${details.join("; ")})`;
+}
+
+function collectWorkTitles(container: OrcidWorksContainer | undefined): string[] {
+	const titles: string[] = [];
+	const seen = new Set<string>();
+	const groups = container?.group || [];
+
+	for (const group of groups) {
+		const summaries = group["work-summary"] || [];
+		for (const summary of summaries) {
+			const title = summary.title?.title?.value?.trim();
+			if (!title || seen.has(title)) continue;
+			seen.add(title);
+			titles.push(title);
+			if (titles.length >= MAX_WORKS) return titles;
+		}
+	}
+
+	return titles;
+}
+
+export const handleOrcid: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!isOrcidHost(parsed.hostname)) return null;
+
+		const orcid = extractOrcidId(parsed.pathname);
+		if (!orcid) return null;
+
+		const fetchedAt = new Date().toISOString();
+		const apiUrl = `https://pub.orcid.org/v3.0/${orcid}/record`;
+
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { Accept: "application/json" },
+			signal,
+		});
+
+		if (!result.ok || !result.content) return null;
+
+		let record: OrcidRecord;
+		try {
+			record = JSON.parse(result.content) as OrcidRecord;
+		} catch {
+			return null;
+		}
+
+		const personName = formatName(record.person?.name);
+		const biography = record.person?.biography?.content?.trim();
+
+		const activities = record["activities-summary"];
+		const employments = collectAffiliations(activities?.employments, "employment-summary");
+		const educations = collectAffiliations(activities?.educations, "education-summary");
+		const works = collectWorkTitles(activities?.works);
+
+		let md = `# ${personName || "ORCID Profile"}\n\n`;
+		md += `**ORCID:** ${orcid}\n`;
+		md += `**ORCID Profile:** https://orcid.org/${orcid}\n\n`;
+
+		md += "## Biography\n\n";
+		md += biography ? `${biography}\n\n` : "No biography available.\n\n";
+
+		md += "## Affiliations\n\n";
+		let hasAffiliations = false;
+
+		if (employments.length > 0) {
+			hasAffiliations = true;
+			md += "### Employment\n\n";
+			for (const summary of employments) {
+				const line = formatAffiliation(summary);
+				if (line) md += `- ${line}\n`;
+			}
+			md += "\n";
+		}
+
+		if (educations.length > 0) {
+			hasAffiliations = true;
+			md += "### Education\n\n";
+			for (const summary of educations) {
+				const line = formatAffiliation(summary);
+				if (line) md += `- ${line}\n`;
+			}
+			md += "\n";
+		}
+
+		if (!hasAffiliations) {
+			md += "No affiliations available.\n\n";
+		}
+
+		md += "## Works\n\n";
+		if (works.length > 0) {
+			for (const title of works) {
+				md += `- ${title}\n`;
+			}
+		} else {
+			md += "No works available.\n";
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "orcid-api",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via ORCID Public API"],
+		};
+	} catch {
+		return null;
+	}
+};

package/src/core/tools/{web-fetch-handlers → web-scrapers}/osv.ts

@@ -47,7 +47,11 @@ interface OsvVulnerability {
 /**
  * Handle OSV (Open Source Vulnerabilities) URLs
  */
-export const handleOsv: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleOsv: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "osv.dev") return null;
@@ -64,6 +68,7 @@ export const handleOsv: SpecialHandler = async (url: string, timeout: number): P
 		const result = await loadPage(apiUrl, {
 			timeout,
 			headers: { Accept: "application/json" },
+			signal,
 		});
 
 		if (!result.ok) return null;

package/src/core/tools/{web-fetch-handlers → web-scrapers}/packagist.ts

@@ -4,7 +4,11 @@ import { finalizeOutput, formatCount, loadPage } from "./types";
 /**
  * Handle Packagist URLs via JSON API
  */
-export const handlePackagist: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handlePackagist: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "packagist.org" && parsed.hostname !== "www.packagist.org") return null;
@@ -19,7 +23,7 @@ export const handlePackagist: SpecialHandler = async (url: string, timeout: numb
 
 		// Fetch from Packagist JSON API
 		const apiUrl = `https://packagist.org/packages/${vendor}/${packageName}.json`;
-		const result = await loadPage(apiUrl, { timeout });
+		const result = await loadPage(apiUrl, { timeout, signal });
 
 		if (!result.ok) return null;
 

package/src/core/tools/{web-fetch-handlers → web-scrapers}/pub-dev.ts

@@ -3,7 +3,7 @@ import { finalizeOutput, formatCount, loadPage, type SpecialHandler } from "./ty
 /**
  * Handle pub.dev URLs via API
  */
-export const handlePubDev: SpecialHandler = async (url: string, timeout: number) => {
+export const handlePubDev: SpecialHandler = async (url: string, timeout: number, signal?: AbortSignal) => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "pub.dev" && parsed.hostname !== "www.pub.dev") return null;
@@ -17,7 +17,7 @@ export const handlePubDev: SpecialHandler = async (url: string, timeout: number)
 
 		// Fetch from pub.dev API
 		const apiUrl = `https://pub.dev/api/packages/${encodeURIComponent(packageName)}`;
-		const result = await loadPage(apiUrl, { timeout });
+		const result = await loadPage(apiUrl, { timeout, signal });
 
 		if (!result.ok) return null;
 
@@ -122,7 +122,7 @@ export const handlePubDev: SpecialHandler = async (url: string, timeout: number)
 		// Try to fetch README from pub.dev
 		const readmeUrl = `https://pub.dev/packages/${encodeURIComponent(packageName)}/versions/${encodeURIComponent(latest.version)}/readme`;
 		try {
-			const readmeResult = await loadPage(readmeUrl, { timeout: Math.min(timeout, 10) });
+			const readmeResult = await loadPage(readmeUrl, { timeout: Math.min(timeout, 10), signal });
 			if (readmeResult.ok) {
 				// Extract README content from HTML
 				const readmeMatch = readmeResult.content.match(

package/src/core/tools/{web-fetch-handlers → web-scrapers}/pubmed.ts

@@ -8,7 +8,11 @@ import { finalizeOutput, loadPage } from "./types";
 /**
  * Handle PubMed URLs - fetch article metadata, abstract, MeSH terms
  */
-export const handlePubMed: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handlePubMed: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 
@@ -39,7 +43,7 @@ export const handlePubMed: SpecialHandler = async (url: string, timeout: number)
 
 		// Fetch summary metadata
 		const summaryUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=${pmid}&retmode=json`;
-		const summaryResult = await loadPage(summaryUrl, { timeout });
+		const summaryResult = await loadPage(summaryUrl, { timeout, signal });
 
 		if (!summaryResult.ok) return null;
 
@@ -70,7 +74,7 @@ export const handlePubMed: SpecialHandler = async (url: string, timeout: number)
 
 		// Fetch abstract
 		const abstractUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pubmed&id=${pmid}&rettype=abstract&retmode=text`;
-		const abstractResult = await loadPage(abstractUrl, { timeout });
+		const abstractResult = await loadPage(abstractUrl, { timeout, signal });
 
 		let abstractText = "";
 		if (abstractResult.ok) {
@@ -133,7 +137,7 @@ export const handlePubMed: SpecialHandler = async (url: string, timeout: number)
 		// Try to fetch MeSH terms
 		try {
 			const meshUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pubmed&id=${pmid}&rettype=medline&retmode=text`;
-			const meshResult = await loadPage(meshUrl, { timeout: Math.min(timeout, 5) });
+			const meshResult = await loadPage(meshUrl, { timeout: Math.min(timeout, 5), signal });
 
 			if (meshResult.ok) {
 				const meshTerms: string[] = [];

package/src/core/tools/{web-fetch-handlers → web-scrapers}/pypi.ts

@@ -4,7 +4,11 @@ import { finalizeOutput, formatCount, loadPage } from "./types";
 /**
  * Handle PyPI URLs via JSON API
  */
-export const handlePyPI: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handlePyPI: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "pypi.org" && parsed.hostname !== "www.pypi.org") return null;
@@ -22,8 +26,8 @@ export const handlePyPI: SpecialHandler = async (url: string, timeout: number):
 
 		// Fetch package info and download stats in parallel
 		const [result, downloadsResult] = await Promise.all([
-			loadPage(apiUrl, { timeout }),
-			loadPage(downloadsUrl, { timeout: Math.min(timeout, 5) }),
+			loadPage(apiUrl, { timeout, signal }),
+			loadPage(downloadsUrl, { timeout: Math.min(timeout, 5), signal }),
 		]);
 
 		if (!result.ok) return null;

package/src/core/tools/web-scrapers/rawg.ts

@@ -0,0 +1,124 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, htmlToBasicMarkdown, loadPage } from "./types";
+
+interface RawgPlatformEntry {
+	platform?: {
+		name?: string;
+	};
+}
+
+interface RawgGenreEntry {
+	name?: string;
+}
+
+interface RawgGameResponse {
+	name?: string;
+	released?: string;
+	rating?: number;
+	platforms?: RawgPlatformEntry[];
+	genres?: RawgGenreEntry[];
+	description?: string;
+	description_raw?: string;
+	detail?: string;
+	error?: string;
+}
+
+export const handleRawg: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (!isRawgHostname(parsed.hostname)) return null;
+
+		const slug = extractGameSlug(parsed.pathname);
+		if (!slug) return null;
+
+		const fetchedAt = new Date().toISOString();
+		const apiUrl = `https://api.rawg.io/api/games/${encodeURIComponent(slug)}`;
+		const result = await loadPage(apiUrl, { timeout, signal, headers: { Accept: "application/json" } });
+
+		if (!result.ok) return null;
+
+		let game: RawgGameResponse;
+		try {
+			game = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		if (requiresApiKey(game)) return null;
+
+		const title = game.name?.trim() || slug;
+		let md = `# ${title}\n\n`;
+
+		if (game.released) md += `**Released:** ${game.released}\n`;
+		if (typeof game.rating === "number" && !Number.isNaN(game.rating)) {
+			md += `**Rating:** ${game.rating.toFixed(2)} / 5\n`;
+		}
+
+		const platforms = collectNames(game.platforms?.map((entry) => entry.platform?.name));
+		if (platforms.length) md += `**Platforms:** ${platforms.join(", ")}\n`;
+
+		const genres = collectNames(game.genres?.map((entry) => entry.name));
+		if (genres.length) md += `**Genres:** ${genres.join(", ")}\n`;
+
+		md += `**RAWG:** https://rawg.io/games/${encodeURIComponent(slug)}\n`;
+		md += "\n";
+
+		const description = extractDescription(game);
+		if (description) {
+			md += `## Description\n\n${description}\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "rawg",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via RAWG API"],
+		};
+	} catch {}
+
+	return null;
+};
+
+function isRawgHostname(hostname: string): boolean {
+	return hostname === "rawg.io" || hostname === "www.rawg.io";
+}
+
+function extractGameSlug(pathname: string): string | null {
+	const match = pathname.match(/^\/games\/([^/?#]+)/);
+	if (!match) return null;
+
+	const slug = decodeURIComponent(match[1]);
+	return slug ? slug.trim() : null;
+}
+
+function requiresApiKey(game: RawgGameResponse): boolean {
+	const detail = `${game.detail ?? ""} ${game.error ?? ""}`.toLowerCase();
+	return detail.includes("api key") || detail.includes("key is required") || detail.includes("apikey");
+}
+
+function extractDescription(game: RawgGameResponse): string | null {
+	if (game.description_raw) return game.description_raw.trim();
+	if (!game.description) return null;
+
+	const markdown = htmlToBasicMarkdown(game.description).trim();
+	return markdown || null;
+}
+
+function collectNames(values?: Array<string | undefined>): string[] {
+	if (!values?.length) return [];
+	const names = new Set<string>();
+	for (const value of values) {
+		const trimmed = value?.trim();
+		if (trimmed) names.add(trimmed);
+	}
+	return Array.from(names);
+}

package/src/core/tools/{web-fetch-handlers → web-scrapers}/readthedocs.ts

@@ -6,7 +6,11 @@ import { parse as parseHtml } from "node-html-parser";
 import type { RenderResult, SpecialHandler } from "./types";
 import { finalizeOutput, htmlToBasicMarkdown, loadPage } from "./types";
 
-export const handleReadTheDocs: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleReadTheDocs: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	// Check if URL matches Read the Docs patterns
 	const urlObj = new URL(url);
 	const isReadTheDocs =
@@ -22,7 +26,7 @@ export const handleReadTheDocs: SpecialHandler = async (url: string, timeout: nu
 	const fetchedAt = new Date().toISOString();
 
 	// Fetch the page
-	const result = await loadPage(url, { timeout });
+	const result = await loadPage(url, { timeout, signal });
 	if (!result.ok) {
 		return {
 			url,
@@ -86,7 +90,7 @@ export const handleReadTheDocs: SpecialHandler = async (url: string, timeout: nu
 	// Try to fetch raw source if available
 	if (sourceUrl) {
 		try {
-			const sourceResult = await loadPage(sourceUrl, { timeout: Math.min(timeout, 10) });
+			const sourceResult = await loadPage(sourceUrl, { timeout: Math.min(timeout, 10), signal });
 			if (sourceResult.ok && sourceResult.content.length > 0 && sourceResult.content.length < 1_000_000) {
 				content = sourceResult.content;
 				notes.push(`Fetched raw source from ${sourceUrl}`);

package/src/core/tools/{web-fetch-handlers → web-scrapers}/reddit.ts

@@ -24,7 +24,11 @@ interface RedditComment {
 /**
  * Handle Reddit URLs via JSON API
  */
-export const handleReddit: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleReddit: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (!parsed.hostname.includes("reddit.com")) return null;
@@ -37,7 +41,7 @@ export const handleReddit: SpecialHandler = async (url: string, timeout: number)
 			jsonUrl = `${url.replace(/\/$/, "").replace(parsed.search, "")}.json${parsed.search}`;
 		}
 
-		const result = await loadPage(jsonUrl, { timeout });
+		const result = await loadPage(jsonUrl, { timeout, signal });
 		if (!result.ok) return null;
 
 		const data = JSON.parse(result.content);

package/src/core/tools/{web-fetch-handlers → web-scrapers}/repology.ts

@@ -102,7 +102,11 @@ function prettifyRepo(repo: string): string {
 /**
  * Handle Repology URLs via API
  */
-export const handleRepology: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleRepology: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "repology.org" && parsed.hostname !== "www.repology.org") return null;
@@ -119,6 +123,7 @@ export const handleRepology: SpecialHandler = async (url: string, timeout: numbe
 		const result = await loadPage(apiUrl, {
 			timeout,
 			headers: { Accept: "application/json" },
+			signal,
 		});
 
 		if (!result.ok) return null;

package/src/core/tools/{web-fetch-handlers → web-scrapers}/rfc.ts

@@ -90,7 +90,11 @@ function cleanRfcText(text: string): string {
 /**
  * Handle RFC Editor URLs - fetches IETF RFCs
  */
-export const handleRfc: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleRfc: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		const rfcNumber = extractRfcNumber(parsed);
@@ -105,8 +109,8 @@ export const handleRfc: SpecialHandler = async (url: string, timeout: number): P
 		const textUrl = `https://www.rfc-editor.org/rfc/rfc${rfcNumber}.txt`;
 
 		const [metaResult, textResult] = await Promise.all([
-			loadPage(metadataUrl, { timeout: Math.min(timeout, 10) }),
-			loadPage(textUrl, { timeout }),
+			loadPage(metadataUrl, { timeout: Math.min(timeout, 10), signal }),
+			loadPage(textUrl, { timeout, signal }),
 		]);
 
 		// We need at least the text content

package/src/core/tools/{web-fetch-handlers → web-scrapers}/rubygems.ts

@@ -30,7 +30,11 @@ interface RubyGemsResponse {
 /**
  * Handle RubyGems URLs via API
  */
-export const handleRubyGems: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleRubyGems: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "rubygems.org" && parsed.hostname !== "www.rubygems.org") return null;
@@ -46,6 +50,7 @@ export const handleRubyGems: SpecialHandler = async (url: string, timeout: numbe
 		const apiUrl = `https://rubygems.org/api/v1/gems/${encodeURIComponent(gemName)}.json`;
 		const result = await loadPage(apiUrl, {
 			timeout,
+			signal,
 			headers: { Accept: "application/json" },
 		});