@fbraza/pi-cite 0.1.0

package/src/rendering.ts

@@ -0,0 +1,311 @@
+import { Text } from "@earendil-works/pi-tui";
+import type { PaperRecord } from "./types.ts";
+
+export const MAX_STREAMED_PAPERS_PER_QUERY = 5;
+export const MAX_FINAL_MERGED_PAPERS = 20;
+
+type ThemeLike = {
+  fg?: (color: string, text: string) => string;
+  bold?: (text: string) => string;
+};
+
+export type CompactPaperForDisplay = {
+  first_author: string;
+  title: string;
+  id: string;
+  source: string;
+  year?: number;
+  journal?: string;
+  citation_count?: number;
+};
+
+export type LiteratureSearchDisplayEvent =
+  | { phase: "start" }
+  | {
+      phase: "query_start";
+      provider: "pubmed" | "semantic_scholar";
+      query_index: number;
+      query: string;
+    }
+  | {
+      phase: "query_results";
+      provider: "pubmed" | "semantic_scholar";
+      query_index: number;
+      query: string;
+      count: number;
+      papers: CompactPaperForDisplay[];
+    }
+  | {
+      phase: "query_error";
+      provider: "pubmed" | "semantic_scholar";
+      query_index: number;
+      query: string;
+      error: string;
+    }
+  | { phase: "dedupe" }
+  | { phase: "complete"; count: number; papers: CompactPaperForDisplay[] };
+
+export type LiteratureSearchDisplaySearch = {
+  provider: "pubmed" | "semantic_scholar";
+  query_index: number;
+  query: string;
+  count: number;
+  papers: CompactPaperForDisplay[];
+};
+
+function terminalText(text: string): Text {
+  return new Text(text, 0, 0);
+}
+
+function color(theme: ThemeLike | undefined, colorName: string, text: string): string {
+  try {
+    return theme?.fg ? theme.fg(colorName, text) : text;
+  } catch {
+    return text;
+  }
+}
+
+function bold(theme: ThemeLike | undefined, text: string): string {
+  try {
+    return theme?.bold ? theme.bold(text) : text;
+  } catch {
+    return text;
+  }
+}
+
+export function truncateText(value: unknown, maxLength: number): string {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+
+export function padText(value: unknown, width: number): string {
+  const text = truncateText(value, width);
+  return text + " ".repeat(Math.max(0, width - text.length));
+}
+
+function authorSurname(author: string): string {
+  const cleaned = author.trim();
+  if (!cleaned) return "Unknown";
+  const parts = cleaned.split(/\s+/);
+  return parts.length > 1 ? parts[parts.length - 1] : cleaned;
+}
+
+export function firstAuthor(paper: PaperRecord): string {
+  const authors = paper.authors ?? [];
+  if (authors.length === 0) return "Unknown";
+  return authorSurname(authors[0]);
+}
+
+export function authorRange(paper: PaperRecord): string {
+  const authors = paper.authors ?? [];
+  if (authors.length === 0) return "Unknown";
+  if (authors.length === 1) return authorSurname(authors[0]);
+  return `${authorSurname(authors[0])}→${authorSurname(authors[authors.length - 1])}`;
+}
+
+export function paperIdentifier(paper: PaperRecord): string {
+  if (paper.doi) return `DOI:${paper.doi}`;
+  if (paper.pmid) return `PMID:${paper.pmid}`;
+  if (paper.s2_id) return `S2:${paper.s2_id}`;
+  return "—";
+}
+
+export function sourceLabel(paper: PaperRecord): string {
+  const sources = new Set(
+    [
+      ...(paper.sources ?? []),
+      ...(paper.source ? paper.source.split(";") : []),
+    ]
+      .map((source) => source.trim())
+      .filter(Boolean),
+  );
+  const hasPubmed = sources.has("pubmed");
+  const hasS2 = sources.has("semantic_scholar");
+  if (hasPubmed && hasS2) return "PM+S2";
+  if (hasPubmed) return "PM";
+  if (hasS2) return "S2";
+  return paper.source ?? "—";
+}
+
+export function compactPaperForDisplay(paper: PaperRecord): CompactPaperForDisplay {
+  return {
+    first_author: firstAuthor(paper),
+    title: paper.title,
+    id: paperIdentifier(paper),
+    source: sourceLabel(paper),
+    year: paper.year,
+    journal: paper.journal,
+    citation_count: paper.citation_count,
+  };
+}
+
+export function compactPapersForDisplay(papers: PaperRecord[]): CompactPaperForDisplay[] {
+  return papers.map(compactPaperForDisplay);
+}
+
+function providerLabel(provider: "pubmed" | "semantic_scholar"): string {
+  return provider === "pubmed" ? "PubMed" : "Semantic Scholar";
+}
+
+function providerColor(provider: "pubmed" | "semantic_scholar"): string {
+  return provider === "pubmed" ? "success" : "accent";
+}
+
+export function formatFoundLine(
+  paper: CompactPaperForDisplay,
+  theme?: ThemeLike,
+): string {
+  const author = padText(paper.first_author, 10);
+  const title = padText(paper.title, 62);
+  const id = padText(paper.id, 28);
+  return `  ${color(theme, "success", "✓ found:")} ${author}  ${title}  ${color(theme, "muted", id)}`;
+}
+
+export function formatMergedLine(
+  paper: CompactPaperForDisplay,
+  index: number,
+  theme?: ThemeLike,
+): string {
+  const title = truncateText(paper.title, 72);
+  const source = color(theme, paper.source.includes("S2") ? "accent" : "success", `(${paper.source})`);
+  return `  ${color(theme, "success", "+")} ${index + 1}. ${title} ${source}`;
+}
+
+function renderEvent(
+  event: LiteratureSearchDisplayEvent,
+  theme?: ThemeLike,
+): string[] {
+  if (event.phase === "start") {
+    return [`${color(theme, "accent", "●")} ${color(theme, "toolTitle", "literature_search")} starting`];
+  }
+  if (event.phase === "query_start") {
+    return [
+      `${color(theme, providerColor(event.provider), "→")} ${color(theme, providerColor(event.provider), providerLabel(event.provider))} q${event.query_index}: ${event.query}`,
+    ];
+  }
+  if (event.phase === "query_results") {
+    const lines = event.papers
+      .slice(0, MAX_STREAMED_PAPERS_PER_QUERY)
+      .map((paper) => formatFoundLine(paper, theme));
+    const hidden = event.count - Math.min(event.count, MAX_STREAMED_PAPERS_PER_QUERY);
+    if (hidden > 0) lines.push(`  ${color(theme, "dim", "…")} ${hidden} more candidate papers`);
+    if (event.count === 0) lines.push(`  ${color(theme, "muted", "no candidate papers found")}`);
+    return lines;
+  }
+  if (event.phase === "query_error") {
+    return [
+      `  ${color(theme, "error", "! failed:")} ${providerLabel(event.provider)} q${event.query_index}: ${truncateText(event.error, 96)}`,
+    ];
+  }
+  if (event.phase === "dedupe") {
+    return [`${color(theme, "warning", "→")} deduplicating by DOI / PMID / title-year`];
+  }
+  const lines = event.papers
+    .slice(0, MAX_FINAL_MERGED_PAPERS)
+    .map((paper, index) => formatMergedLine(paper, index, theme));
+  const hidden = event.count - Math.min(event.count, MAX_FINAL_MERGED_PAPERS);
+  if (hidden > 0) lines.push(`  ${color(theme, "dim", "…")} ${hidden} more merged papers`);
+  lines.push(`${color(theme, "success", "✓")} done: ${event.count} merged papers`);
+  return lines;
+}
+
+export function renderLiteratureEventTranscript(
+  events: LiteratureSearchDisplayEvent[] | undefined,
+  theme?: ThemeLike,
+): string {
+  if (!events?.length) return "";
+  return events.flatMap((event) => renderEvent(event, theme)).join("\n");
+}
+
+type RenderOptions = { expanded?: boolean; isPartial?: boolean };
+
+type TextContentResult = { type: string; text?: string };
+
+type ToolRenderResult<TDetails> = {
+  content?: TextContentResult[];
+  details?: TDetails;
+};
+
+type ProviderSearchSummary = {
+  searched?: boolean;
+  count?: number;
+};
+
+type LiteratureResultDetails = {
+  count?: number;
+  papers?: PaperRecord[];
+  providers?: {
+    pubmed?: ProviderSearchSummary;
+    semantic_scholar?: ProviderSearchSummary;
+  };
+  events?: LiteratureSearchDisplayEvent[];
+};
+
+type ProviderResultDetails = {
+  papers?: PaperRecord[];
+  query?: string;
+  params?: { query?: string };
+};
+
+function renderCollapsedLiteratureResult(details: LiteratureResultDetails, theme?: ThemeLike): string {
+  const pubmed = details?.providers?.pubmed;
+  const s2 = details?.providers?.semantic_scholar;
+  const pubmedText = pubmed?.searched ? `PubMed: ${pubmed.count}` : "PubMed: —";
+  const s2Text = s2?.searched ? `S2: ${s2.count}` : "S2: skipped";
+  const count = details?.count ?? details?.papers?.length ?? 0;
+  return `${color(theme, "success", "✓")} ${color(theme, "toolTitle", "literature_search")} ${color(theme, "success", pubmedText)} | ${color(theme, "accent", s2Text)} | merged: ${count}`;
+}
+
+export function renderLiteratureSearchResult(
+  result: ToolRenderResult<LiteratureResultDetails>,
+  options: RenderOptions,
+  theme?: ThemeLike,
+): Text {
+  const details = result.details ?? {};
+  const transcript = renderLiteratureEventTranscript(details.events, theme);
+  if (options.isPartial) {
+    return terminalText(transcript || color(theme, "warning", "Searching literature..."));
+  }
+  if (!options.expanded) {
+    return terminalText(renderCollapsedLiteratureResult(details, theme));
+  }
+  if (transcript) return terminalText(transcript);
+
+  const papers = compactPapersForDisplay(details.papers ?? []);
+  const lines = [
+    `${color(theme, "accent", "●")} ${color(theme, "toolTitle", "literature_search")} result`,
+    renderCollapsedLiteratureResult(details, theme),
+    `${color(theme, "warning", "→")} deduplicating by DOI / PMID / title-year`,
+    ...papers.slice(0, MAX_FINAL_MERGED_PAPERS).map((paper, index) => formatMergedLine(paper, index, theme)),
+    `${color(theme, "success", "✓")} done: ${papers.length} merged papers`,
+  ];
+  return terminalText(lines.join("\n"));
+}
+
+export function renderProviderSearchResult(
+  provider: "pubmed" | "semantic_scholar",
+  result: ToolRenderResult<ProviderResultDetails>,
+  options: RenderOptions,
+  theme?: ThemeLike,
+): Text {
+  const providerName = providerLabel(provider);
+  const details = result.details ?? {};
+  const papers = compactPapersForDisplay(details.papers ?? []);
+  const query = details.query ?? details.params?.query ?? "";
+  if (options.isPartial) {
+    const text = result.content?.[0]?.type === "text" ? result.content[0].text ?? "" : `Searching ${providerName}...`;
+    return terminalText(color(theme, "warning", text));
+  }
+  if (!options.expanded) {
+    return terminalText(`${color(theme, "success", "✓")} ${color(theme, "toolTitle", provider === "pubmed" ? "pubmed_search" : "semantic_scholar_search")} ${papers.length} papers`);
+  }
+  const lines = [
+    `${color(theme, providerColor(provider), "→")} ${color(theme, providerColor(provider), providerName)} q1: ${query}`,
+    ...papers.slice(0, MAX_STREAMED_PAPERS_PER_QUERY).map((paper) => formatFoundLine(paper, theme)),
+  ];
+  const hidden = papers.length - Math.min(papers.length, MAX_STREAMED_PAPERS_PER_QUERY);
+  if (hidden > 0) lines.push(`  ${color(theme, "dim", "…")} ${hidden} more candidate papers`);
+  lines.push(`${color(theme, "success", "✓")} done: ${papers.length} papers`);
+  return terminalText(lines.join("\n"));
+}

package/src/semantic-scholar.ts

@@ -0,0 +1,199 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type, type Static } from "typebox";
+import { renderProviderSearchResult } from "./rendering.ts";
+import { emitProgress, textResult, type TextToolUpdate } from "./tool-output.ts";
+import { fetchJson, formatPaperText, normalizeDoi } from "./shared.ts";
+import type { FullTextRouteResult, PaperRecord } from "./types.ts";
+
+export const SEMANTIC_SCHOLAR_PARAMS = Type.Object({
+  query: Type.String({ description: "Search query" }),
+  max_results: Type.Optional(
+    Type.Number({
+      description: "Maximum results to return (default 20, max 100)",
+    }),
+  ),
+  year_from: Type.Optional(
+    Type.Number({ description: "Minimum publication year" }),
+  ),
+  year_to: Type.Optional(
+    Type.Number({ description: "Maximum publication year" }),
+  ),
+  fields_of_study: Type.Optional(
+    Type.Array(Type.String({ description: "Field of study" })),
+  ),
+  min_citation_count: Type.Optional(
+    Type.Number({ description: "Minimum citation count" }),
+  ),
+  open_access_only: Type.Optional(
+    Type.Boolean({ description: "Only keep open access papers" }),
+  ),
+});
+
+export type SemanticScholarSearchParams = Static<typeof SEMANTIC_SCHOLAR_PARAMS>;
+
+type SemanticScholarPaperResponse = {
+  paperId?: string;
+  title?: string;
+  abstract?: string | null;
+  year?: number | null;
+  citationCount?: number | null;
+  tldr?: { text?: string | null } | null;
+  externalIds?: Record<string, string | undefined>;
+  openAccessPdf?: { url?: string | null } | null;
+  fieldsOfStudy?: string[] | null;
+  authors?: Array<{ name?: string | null }> | null;
+};
+
+export async function trySemanticScholarOpenAccess(
+  doi: string,
+  signal?: AbortSignal,
+): Promise<FullTextRouteResult> {
+  const url = new URL("https://api.semanticscholar.org/graph/v1/paper/search");
+  url.searchParams.set("query", doi);
+  url.searchParams.set("limit", "5");
+  url.searchParams.set(
+    "fields",
+    "title,openAccessPdf,externalIds,isOpenAccess",
+  );
+  const data = await fetchJson<{
+    data?: Array<{
+      openAccessPdf?: { url?: string };
+      externalIds?: Record<string, string>;
+    }>;
+  }>(url.toString(), signal);
+  const match = (data.data ?? []).find(
+    (item) =>
+      normalizeDoi(item.externalIds?.DOI) === normalizeDoi(doi) &&
+      item.openAccessPdf?.url,
+  );
+  const pdfUrl = match?.openAccessPdf?.url;
+  if (!pdfUrl) {
+    return {
+      source: "not_found",
+      access_note: "No open-access PDF found via Semantic Scholar",
+    };
+  }
+  return {
+    source: "semantic_scholar_oa",
+    pdf_url: pdfUrl,
+    access_note: "Open-access PDF found via Semantic Scholar openAccessPdf",
+  };
+}
+
+export type SemanticScholarSearchResult = {
+  count: number;
+  papers: PaperRecord[];
+  query?: string;
+};
+
+export async function searchSemanticScholar(
+  params: SemanticScholarSearchParams,
+  signal?: AbortSignal,
+  onUpdate?: TextToolUpdate,
+): Promise<SemanticScholarSearchResult> {
+  const maxResults = Math.min(
+    100,
+    Math.max(1, Math.floor(params.max_results ?? 20)),
+  );
+  const url = new URL(
+    "https://api.semanticscholar.org/graph/v1/paper/search",
+  );
+  url.searchParams.set("query", params.query);
+  url.searchParams.set("limit", String(maxResults));
+  url.searchParams.set(
+    "fields",
+    [
+      "paperId",
+      "title",
+      "abstract",
+      "year",
+      "citationCount",
+      "tldr",
+      "externalIds",
+      "openAccessPdf",
+      "fieldsOfStudy",
+      "isOpenAccess",
+      "authors",
+    ].join(","),
+  );
+  if (params.year_from)
+    url.searchParams.set(
+      "year",
+      `${params.year_from}-${params.year_to ?? ""}`,
+    );
+  emitProgress(onUpdate, `Searching Semantic Scholar for: ${params.query}`);
+  const apiKey = process.env.SEMANTIC_SCHOLAR_API_KEY?.trim();
+  const response = await fetchJson<{ data?: SemanticScholarPaperResponse[] }>(
+    url.toString(),
+    signal,
+    apiKey ? { "x-api-key": apiKey } : undefined,
+  );
+  let papers: PaperRecord[] = (response.data ?? []).map((item) => ({
+    s2_id: item.paperId,
+    title: item.title ?? "Untitled",
+    abstract: item.abstract ?? undefined,
+    year: item.year ?? undefined,
+    citation_count: item.citationCount ?? undefined,
+    tldr: item.tldr?.text ?? undefined,
+    open_access_pdf: item.openAccessPdf?.url ?? undefined,
+    external_ids: item.externalIds ?? undefined,
+    doi: normalizeDoi(item.externalIds?.DOI),
+    pmid: item.externalIds?.PubMed ?? item.externalIds?.PMID,
+    authors: Array.isArray(item.authors)
+      ? item.authors.map((author) => author.name).filter(Boolean)
+      : [],
+    source: "semantic_scholar",
+  }));
+  if (params.fields_of_study?.length) {
+    const wanted = new Set(
+      params.fields_of_study.map((item: string) => item.toLowerCase()),
+    );
+    papers = papers.filter((paper, index) => {
+      const fields = (response.data?.[index]?.fieldsOfStudy ?? []).map(
+        (item: string) => item.toLowerCase(),
+      );
+      return fields.some((item: string) => wanted.has(item));
+    });
+  }
+  if (params.min_citation_count !== undefined)
+    papers = papers.filter(
+      (paper) => (paper.citation_count ?? 0) >= params.min_citation_count,
+    );
+  if (params.open_access_only)
+    papers = papers.filter((paper) => !!paper.open_access_pdf);
+  if (params.year_from !== undefined)
+    papers = papers.filter((paper) => (paper.year ?? 0) >= params.year_from);
+  if (params.year_to !== undefined)
+    papers = papers.filter((paper) => (paper.year ?? 9999) <= params.year_to);
+  return { count: papers.length, papers, query: params.query };
+}
+
+export function createSemanticScholarSearchTool() {
+  return {
+    name: "semantic_scholar_search",
+    label: "Semantic Scholar Search",
+    description:
+      "Search Semantic Scholar for relevance-ranked papers, citation counts, and open-access metadata.",
+    parameters: SEMANTIC_SCHOLAR_PARAMS,
+    async execute(
+      _toolCallId: string,
+      params: SemanticScholarSearchParams,
+      signal?: AbortSignal,
+      onUpdate?: TextToolUpdate,
+    ) {
+      const result = await searchSemanticScholar(params, signal, onUpdate);
+      return textResult(formatPaperText(result.papers), result);
+    },
+    renderResult(
+      result: Parameters<typeof renderProviderSearchResult>[1],
+      options: Parameters<typeof renderProviderSearchResult>[2],
+      theme: Parameters<typeof renderProviderSearchResult>[3],
+    ) {
+      return renderProviderSearchResult("semantic_scholar", result, options, theme);
+    },
+  };
+}
+
+export function registerSemanticScholarSearchTool(pi: ExtensionAPI): void {
+  pi.registerTool(createSemanticScholarSearchTool());
+}

package/src/shared.ts

@@ -0,0 +1,103 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { PaperRecord } from "./types.ts";
+
+export const USER_AGENT = "research-skills-literature-tools/0.1 (+https://github.com/fbraza/research-skills)";
+
+export function unique<T>(items: T[]): T[] {
+	return [...new Set(items.filter((item) => item !== undefined && item !== null && item !== ""))];
+}
+
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(resolve, ms);
+		if (!signal) return;
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(new Error("Request aborted"));
+		};
+		if (signal.aborted) onAbort();
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+
+export function htmlDecode(text: string): string {
+	return text
+		.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1")
+		.replace(/&lt;/g, "<")
+		.replace(/&gt;/g, ">")
+		.replace(/&amp;/g, "&")
+		.replace(/&quot;/g, '"')
+		.replace(/&#39;/g, "'")
+		.replace(/<[^>]+>/g, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+export function normalizeDoi(raw?: string): string | undefined {
+	if (!raw) return undefined;
+	return raw
+		.trim()
+		.replace(/^doi:\s*/i, "")
+		.replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, "")
+		.trim() || undefined;
+}
+
+export function xmlDecode(text: string): string {
+	return htmlDecode(text);
+}
+
+export function pickAll(regex: RegExp, text: string): string[] {
+	const matches: string[] = [];
+	for (const match of text.matchAll(regex)) {
+		if (match[1]) matches.push(xmlDecode(match[1]));
+	}
+	return matches;
+}
+
+export function pickOne(regex: RegExp, text: string): string | undefined {
+	const match = regex.exec(text);
+	return match?.[1] ? xmlDecode(match[1]) : undefined;
+}
+
+export async function fetchText(url: string, signal?: AbortSignal, headers?: Record<string, string>): Promise<string> {
+	const response = await fetch(url, {
+		headers: {
+			"user-agent": USER_AGENT,
+			accept: "application/json, text/xml, application/xml, text/html;q=0.9, */*;q=0.8",
+			...headers,
+		},
+		signal,
+		redirect: "follow",
+	});
+	if (!response.ok) throw new Error(`${response.status} ${response.statusText} for ${url}`);
+	return await response.text();
+}
+
+export async function fetchJson<T>(url: string, signal?: AbortSignal, headers?: Record<string, string>): Promise<T> {
+	const text = await fetchText(url, signal, headers);
+	return JSON.parse(text) as T;
+}
+
+export function formatPaperText(papers: PaperRecord[]): string {
+	return JSON.stringify(papers, null, 2);
+}
+
+export function sanitizeFilename(value: string): string {
+	return value.replace(/[^a-z0-9._-]+/gi, "_").replace(/^_+|_+$/g, "") || "paper";
+}
+
+export async function savePdf(pdfUrl: string, outputDir: string, preferredId: string, signal?: AbortSignal): Promise<string> {
+	await mkdir(outputDir, { recursive: true });
+	const response = await fetch(pdfUrl, {
+		method: "GET",
+		signal,
+		headers: { "user-agent": USER_AGENT, accept: "application/pdf,*/*" },
+		redirect: "follow",
+	});
+	if (!response.ok) throw new Error(`Failed to download PDF (${response.status})`);
+	const bytes = Buffer.from(await response.arrayBuffer());
+	const filePath = path.resolve(outputDir, `${sanitizeFilename(preferredId)}.pdf`);
+	await writeFile(filePath, bytes);
+	return filePath;
+}

package/src/tool-output.ts

@@ -0,0 +1,47 @@
+export type TextToolBlock = {
+	type: "text";
+	text: string;
+};
+
+export type TextToolPayload<TDetails extends Record<string, unknown> = Record<string, unknown>> = {
+	content: TextToolBlock[];
+	details: TDetails;
+	isError?: boolean;
+};
+
+export type TextToolUpdate<TDetails extends Record<string, unknown> = Record<string, unknown>> = (
+	update: TextToolPayload<TDetails>,
+) => void;
+
+export function textBlock(text: string): TextToolBlock {
+	return { type: "text", text };
+}
+
+export function textResult<TDetails extends Record<string, unknown> = Record<string, unknown>>(
+	text: string,
+	details?: TDetails,
+): TextToolPayload<TDetails> {
+	return {
+		content: [textBlock(text)],
+		details: (details ?? {}) as TDetails,
+	};
+}
+
+export function errorResult<TDetails extends Record<string, unknown> = Record<string, unknown>>(
+	text: string,
+	details?: TDetails,
+): TextToolPayload<TDetails> {
+	return {
+		content: [textBlock(text)],
+		details: (details ?? {}) as TDetails,
+		isError: true,
+	};
+}
+
+export function emitProgress<TDetails extends Record<string, unknown> = Record<string, unknown>>(
+	onUpdate: TextToolUpdate<TDetails> | undefined,
+	text: string,
+	details?: TDetails,
+): void {
+	onUpdate?.(textResult(text, details));
+}

package/src/types.ts

@@ -0,0 +1,30 @@
+export type PaperRecord = {
+	pmid?: string;
+	doi?: string;
+	s2_id?: string;
+	title: string;
+	abstract?: string;
+	authors?: string[];
+	journal?: string;
+	year?: number;
+	publication_types?: string[];
+	mesh_terms?: string[];
+	citation_count?: number;
+	tldr?: string;
+	open_access_pdf?: string;
+	external_ids?: Record<string, string>;
+	source?: string;
+	sources?: string[];
+	date?: string;
+	category?: string;
+	version?: string;
+	license?: string;
+	pdf_url?: string;
+};
+
+export type FullTextRouteResult = {
+	source: string;
+	pdf_url?: string;
+	access_note: string;
+	is_preprint?: boolean;
+};