@companion-ai/feynman 0.5.17 → 0.5.18

package/.feynman/agents/researcher.md

@@ -31,7 +31,7 @@ You are Feynman's evidence-gathering subagent.
 | Biomedical papers | `source: "pubmed"`, then `source: "europepmc"` for open-access full-text sections | `semanticscholar` for citation counts |
 | Citation graph | `source: "openalex"` with `openalex_citations:` / `openalex_references:` | `semanticscholar` citation counts to spot seminal work |
 | Conceptual or recent work that keyword search misses | `source: "openalex"` with a `semantic:` query prefix | `semanticscholar` with `sort: "relevance"` |
-| Web, docs, repos, grey literature | `web_search` (if the default provider fails or is rate-limited, retry with `provider: "parallel-mcp"`, which needs no key) | `fetch_content` on the best results |
+| Web, docs, repos, grey literature | `web_search` (if the default provider fails or is rate-limited, retry with `provider` set to the plain string `parallel-mcp`, not a JSON-encoded list; it needs no key) | `fetch_content` on the best results |
 | Known paper ID | `source: "arxiv"` for arXiv IDs, `source: "crossref"` for DOIs | `fetch_content` on `arxiv.org/html/<id>` for full text |
 
 Run 2–4 reworded queries for each question (synonyms, the method's name, the problem's name) and merge the results. Do not trust one query's ranking; seminal papers often appear only under one phrasing or one sort order.

package/RELEASES.md

@@ -6,6 +6,12 @@ GitHub release notes are generated from the matching `## vX.Y.Z` section in this
 
 ## Unreleased
 
+## v0.5.18 - 2026-09-30
+
+- **A rate-limited paper index no longer ends a research step.** When Semantic Scholar is rate-limited or down, a search is answered from OpenAlex, and an OpenAlex topic search that hits OpenAlex's anonymous rate limit or an outage is answered from Semantic Scholar. The result says first which index answered and why. Lookups by OpenAlex ID, DOI, author, venue, or citation still report the error, since the other index has no equivalent.
+- **alphaXiv tools answer when alphaXiv cannot.** If your alphaXiv login expired or alphaXiv does not respond, `alpha_search` returns OpenAlex semantic search results and `alpha_get_paper` returns the arXiv metadata and abstract for an arXiv ID, each marked as a fallback. Run `feynman alpha login` to get alphaXiv's reports back.
+- pi-web-access 0.35.0: OpenAI web search works when you signed in with ChatGPT (`feynman model login openai`), and Brave search keeps to its rate limits. The researcher is told to pass a search provider as a plain string, since some models sent `provider: "[\"parallel-mcp\"]"`, which `web_search` rejects; nicobailon/pi-web-access#491 makes `web_search` accept that form too.
+
 ## v0.5.17 - 2026-09-30
 
 - **`feynman model login openai` works again.** Since Pi 0.99, Sign in with ChatGPT needs a stable ID for the installation, which Feynman did not pass, so the login failed at once with "requires a device ID (UUID)". Feynman now shares the `deviceId` Pi's own `/login` keeps in `~/.feynman/agent/settings.json`.

package/extensions/research-tools/alpha.ts

@@ -13,6 +13,8 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
 import { extractPaperSections } from "./alpha-sections.js";
+import { searchArxiv } from "./science-database-arxiv.js";
+import { searchOpenAlex } from "./science-database-openalex.js";
 
 function formatText(value: unknown): string {
 	if (typeof value === "string") return value;
@@ -21,11 +23,23 @@ function formatText(value: unknown): string {
 
 // alphaXiv's API has changed without notice before; when a call fails, point
 // the model at the other paper sources instead of leaving it on a broken tool.
-async function withPaperFallback<T>(run: () => Promise<T>): Promise<T> {
+const ARXIV_ID = /(?:^|arxiv\.org\/(?:abs|pdf)\/|alphaxiv\.org\/(?:abs|overview)\/)(\d{4}\.\d{4,5}(?:v\d+)?|[a-z-]+(?:\.[A-Z]{2})?\/\d{7}(?:v\d+)?)/i;
+
+// When alphaXiv does not answer (expired login, outage), answer from another
+// paper source and say so first, instead of failing the research step.
+async function withPaperFallback<T>(
+	run: () => Promise<T>,
+	fallback?: { source: string; run: () => Promise<Record<string, unknown>> },
+): Promise<T | Record<string, unknown>> {
 	try {
 		return await run();
 	} catch (error) {
 		const message = (error instanceof Error ? error.message : String(error)).replace("`alpha login`", "`feynman alpha login`");
+		if (fallback) {
+			try {
+				return { fallbackNote: `alphaXiv did not answer (${message}); these results are from ${fallback.source}.`, ...(await fallback.run()) };
+			} catch {}
+		}
 		throw new Error(
 			`${message}\nalphaXiv did not answer this call. Use feynman_science_database_search (source "arxiv" or "semanticscholar") or fetch_content on https://arxiv.org/abs/<id> instead.`,
 		);
@@ -65,7 +79,10 @@ export function registerAlphaTools(pi: ExtensionAPI, signedIn = isLoggedIn()): v
 			),
 		}),
 		async execute(_toolCallId, params) {
-			const result = await withPaperFallback(() => searchPapers(params.query, params.mode?.trim() || "semantic"));
+			const result = await withPaperFallback(() => searchPapers(params.query, params.mode?.trim() || "semantic"), {
+				source: "OpenAlex semantic search",
+				run: () => searchOpenAlex({ source: "openalex", query: `semantic: ${params.query}`, limit: 10 }),
+			});
 			return { content: [{ type: "text", text: formatText(result) }], details: result };
 		},
 	});
@@ -87,7 +104,14 @@ export function registerAlphaTools(pi: ExtensionAPI, signedIn = isLoggedIn()): v
 			sections: Type.Optional(paperSectionsSchema),
 		}),
 		async execute(_toolCallId, params) {
-			const result = await withPaperFallback(() => getPaper(params.paper, { fullText: params.fullText }));
+			const arxivId = ARXIV_ID.exec(params.paper.trim())?.[1];
+			const result = await withPaperFallback(() => getPaper(params.paper, { fullText: params.fullText }), arxivId ? {
+				source: "arXiv metadata and abstract (no full text or sections)",
+				run: () => searchArxiv({ query: arxivId }),
+			} : undefined);
+			if ("fallbackNote" in result) {
+				return { content: [{ type: "text", text: formatText(result) }], details: result };
+			}
 			const extracted = extractPaperSections(result.content, params.section, params.sections);
 			const filteredResult = extracted.requested.length
 				? {

package/extensions/research-tools/science-databases.ts

@@ -380,19 +380,54 @@ async function searchSemanticScholar(params: ScienceDatabaseSearchParams): Promi
 	};
 }
 
+// OpenAlex lookups by ID, DOI, author, venue, or citation have no Semantic
+// Scholar equivalent; only plain topic searches fall back.
+const OPENALEX_LOOKUP_QUERY =
+	/^(?:openalex_\w+|rate-limit|authors?|author-search|sources?|venues?|citations?|references?|work|detail)(?::|\s|$)|^(?:W\d+|doi:\s*10\.|10\.\S+\/)/i;
+
+function isIndexUnavailable(error: unknown): boolean {
+	if (error instanceof ScienceDatabaseRequestError) return error.status === 429 || error.status >= 500;
+	return error instanceof Error && /^OpenAlex request failed: (?:429|5\d\d)\b/.test(error.message);
+}
+
+// A rate-limited or overloaded index should not end a research step: answer a
+// topic search from the other general index, and say so first in the result.
+async function withIndexFallback(
+	run: () => Promise<Record<string, unknown>>,
+	fallback: (() => Promise<Record<string, unknown>>) | undefined,
+	describe: (reason: string) => string,
+): Promise<Record<string, unknown>> {
+	try {
+		return await run();
+	} catch (error) {
+		if (!fallback || !isIndexUnavailable(error)) throw error;
+		let result: Record<string, unknown>;
+		try {
+			result = await fallback();
+		} catch {
+			throw error;
+		}
+		return { fallbackNote: describe(error instanceof Error ? error.message : String(error)), ...result };
+	}
+}
+
 async function scienceDatabaseSearch(params: ScienceDatabaseSearchParams): Promise<Record<string, unknown>> {
 	if (params.source === "arxiv") return searchArxiv(params);
 	if (params.source === "biorxiv") return searchPreprints(params, "biorxiv");
 	if (params.source === "medrxiv") return searchPreprints(params, "medrxiv");
 	if (params.source === "pubmed") return searchPubMed(params);
 	if (params.source === "crossref") return searchCrossref(params);
-	if (params.source === "semanticscholar") return searchSemanticScholar(params);
+	const openAlex = () => searchOpenAlex({ limit: params.limit, query: params.query, source: "openalex" });
+	const semanticScholar = () => searchSemanticScholar({ ...params, source: "semanticscholar" });
+	if (params.source === "semanticscholar") {
+		return withIndexFallback(semanticScholar, openAlex, (reason) => `Semantic Scholar was unavailable (${reason}); these results are from OpenAlex.`);
+	}
 	if (params.source === "openalex") {
-		return searchOpenAlex({
-			limit: params.limit,
-			query: params.query,
-			source: params.source,
-		});
+		return withIndexFallback(
+			openAlex,
+			OPENALEX_LOOKUP_QUERY.test(params.query.trim()) ? undefined : semanticScholar,
+			(reason) => `OpenAlex was unavailable (${reason}); these results are from Semantic Scholar.`,
+		);
 	}
 	return searchEuropePmc(params);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@companion-ai/feynman",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "description": "Research-first CLI agent built on Pi and alphaXiv",
   "license": "MIT",
   "type": "module",
@@ -83,7 +83,7 @@
     "pi-btw": "0.6.1",
     "pi-docparser": "4.0.0",
     "pi-subagents": "0.73.1",
-    "pi-web-access": "0.34.0",
+    "pi-web-access": "0.35.0",
     "posthog-node": "^5.53.0",
     "undici": "^8.11.2"
   },