caelum0x 4f7ba29383 feat: production hardening — real Python engines, no-stub verify guard, console UI kit
Backend (make everything real, no stubs):
- Implement all 10 Python engine scripts (scispacy, pymare, pytrials, minicheck,
  indra, openalex, paperqa, pykeen, storm, asreview) behind the existing lib/engines
  bridges. openalex + pytrials are zero-dep (stdlib urllib, work out of the box); the
  8 heavy engines run the real library when installed and emit an honest structured
  error envelope when absent — no phantom capability, no faked outputs.
- /api/verify: hard production guard so the offline fixture path can NEVER activate in
  production (MOCK_MODE gated to NODE_ENV!=production); prod always runs the real
  retrieve→extract→verify pipeline.
- /api/auth/google: wrap the OAuth entrypoint in try/catch — fail closed to /login.
- MoA: wire the previously-dangling design_priors artifact into the multivers
  cross-source verifier as a mean-preserving, clamped (+/-25%) design-credibility
  weight; exact no-op when absent, so the benchmark verdict mix is protected.

Frontend (enterprise-grade polish):
- New shared console UI kit (components/console/ui.tsx): Skeleton, Card, Badge,
  Button, StatCard, EmptyState — one source for the house tokens.
- Skeleton shimmer keyframe; LoadingBanner now renders shimmer instead of plain text
  (propagates to ~29 tool pages, signature unchanged).
- Real workspace overview landing page: live stats (fixes a phantom 'claims' field
  the old page always rendered as 0), recent verifications with permalinks, quick
  actions, skeleton loading + empty + error states.

Verified: tsc clean, 10/10 verify integration tests pass, production build compiles
all 417 pages.
2026-07-11 21:46:23 +03:00

182 lines
6.5 KiB
Python
Executable File

#!/usr/bin/env python3
"""STORM long-form cited synthesis — stdin/stdout bridge.
Bridge: lib/engines/storm.ts (generateStormArticle). Reads a JSON job on stdin
{"topic": str, "sources": [{"title"?, "url"?, "text"?, "snippets"?, "description"?}]}
and emits exactly one JSON object on stdout:
success: {"ok": true, "outline": [str, ...], "article": str,
"citations": [{"title": str, "url": str}, ...]}
handled error: {"ok": false, "error": "..."} (exit 1)
Dep-gated: requires `knowledge-storm` (pip install knowledge-storm) and an Anthropic
key. When absent the script emits an honest error envelope and exits 1 — never a fake
article. STORM is pointed at PaperTrail's own pre-vetted sources via a custom retrieval
module so the synthesis stays inside PaperTrail's evidence boundary. Topic/source text
is read from stdin only and is never logged.
"""
import json
import os
import sys
import tempfile
DEFAULT_MODEL = "anthropic/claude-3-5-sonnet-20241022"
def _digest_sources(sources):
"""Normalize caller sources into STORM's {url,title,description,snippets} shape."""
digested = []
for index, src in enumerate(sources):
if not isinstance(src, dict):
continue
url = src.get("url") or f"papertrail://source/{index}"
title = src.get("title") or url
text = src.get("text") if isinstance(src.get("text"), str) else ""
snippets = src.get("snippets")
if not isinstance(snippets, list) or not snippets:
snippets = [text] if text else []
snippets = [s for s in snippets if isinstance(s, str) and s]
description = src.get("description")
if not isinstance(description, str) or not description:
description = snippets[0] if snippets else title
digested.append({
"url": url,
"title": title,
"description": description,
"snippets": snippets or [title],
})
return digested
def _read_first(directory, filenames):
"""Return the contents of the first existing file among filenames (walking dir)."""
for root, _dirs, files in os.walk(directory):
for candidate in filenames:
if candidate in files:
with open(os.path.join(root, candidate), encoding="utf-8") as handle:
return handle.read()
return ""
def _parse_outline(outline_text):
outline = []
for line in outline_text.splitlines():
stripped = line.strip()
if stripped.startswith("#"):
heading = stripped.lstrip("#").strip()
if heading:
outline.append(heading)
return outline
def _parse_citations(directory):
for root, _dirs, files in os.walk(directory):
if "url_to_info.json" in files:
with open(os.path.join(root, "url_to_info.json"), encoding="utf-8") as handle:
data = json.load(handle)
info = data.get("url_to_info", data) if isinstance(data, dict) else {}
citations = []
if isinstance(info, dict):
for url, meta in info.items():
title = meta.get("title") if isinstance(meta, dict) else None
citations.append({"title": title or url, "url": url})
return citations
return []
def synthesize(job):
topic = job.get("topic")
if not isinstance(topic, str) or not topic.strip():
return {"ok": False, "error": "storm: a non-empty 'topic' is required"}
sources = job.get("sources")
sources = sources if isinstance(sources, list) else []
digested_sources = _digest_sources(sources)
if not digested_sources:
return {"ok": False, "error": "storm: at least one usable source is required"}
try:
import dspy
from knowledge_storm import (
STORMWikiLMConfigs,
STORMWikiRunner,
STORMWikiRunnerArguments,
)
from knowledge_storm.lm import LitellmModel
except ImportError:
return {"ok": False, "error": "knowledge-storm not installed; install knowledge-storm to enable this engine"}
class CachedSourceRM(dspy.Retrieve):
"""Retrieval module that returns PaperTrail's pre-vetted sources only.
STORM dedupes returned results by url, so returning the full pre-vetted set
for every query keeps the synthesis strictly inside the evidence boundary.
"""
def __init__(self, prevetted, k):
super().__init__(k=k)
self._prevetted = prevetted
def forward(self, query_or_queries, exclude_urls=None): # noqa: ARG002
excluded = set(exclude_urls or [])
return [row for row in self._prevetted if row["url"] not in excluded]
model_name = os.environ.get("STORM_MODEL", DEFAULT_MODEL)
lm_configs = STORMWikiLMConfigs()
lm = LitellmModel(model=model_name, max_tokens=2000)
lm_configs.set_conv_simulator_lm(lm)
lm_configs.set_question_asker_lm(lm)
lm_configs.set_outline_gen_lm(lm)
lm_configs.set_article_gen_lm(lm)
lm_configs.set_article_polish_lm(lm)
with tempfile.TemporaryDirectory(prefix="storm_") as tmpdir:
engine_args = STORMWikiRunnerArguments(
output_dir=tmpdir,
max_conv_turn=2,
max_perspective=2,
search_top_k=len(digested_sources),
max_thread_num=1,
)
retriever = CachedSourceRM(digested_sources, k=len(digested_sources))
runner = STORMWikiRunner(engine_args, lm_configs, retriever)
runner.run(
topic=topic,
do_research=True,
do_generate_outline=True,
do_generate_article=True,
do_polish_article=True,
)
runner.post_run()
article = _read_first(
tmpdir,
["storm_gen_article_polished.txt", "storm_gen_article.txt"],
)
outline_text = _read_first(tmpdir, ["storm_gen_outline.txt"])
citations = _parse_citations(tmpdir)
return {
"ok": True,
"outline": _parse_outline(outline_text),
"article": article,
"citations": citations,
}
def main():
try:
raw = sys.stdin.read()
job = json.loads(raw) if raw.strip() else {}
out = synthesize(job)
print(json.dumps(out))
return 0 if out.get("ok") else 1
except Exception as exc: # noqa: BLE001 — surface every failure as a JSON envelope
print(json.dumps({"ok": False, "error": f"{type(exc).__name__}: {exc}"}))
return 1
if __name__ == "__main__":
raise SystemExit(main())