Upload app.py

app.py

@@ -669,72 +669,7 @@ async def find_repository(req: RepoRequest, request: Request):
             "fairsharing": f"https://fairsharing.org/search?q={clean_name}",
         }
 
-    # Inject UW-Madison repos first if institution is UW-Madison
-    institution = (req.dataset.institution or "").lower()
-    is_uw = any(k in institution for k in ["wisconsin", "uw-madison", "uw madison", "uwmadison"])
-    if is_uw:
-        uw_repos = [
-            {
-                "name": "Dryad",
-                "type": "Generalist",
-                "url": "https://datadryad.org/stash",
-                "scope": "Open-access data repository for research data across all disciplines.",
-                "fit_reason": "Free for UW-Madison researchers through the institutional membership. Provides DOI, long-term stewardship, and publisher integrations.",
-                "data_types_accepted": "All types — tabular, images, genomics, climate, social science, and more",
-                "max_file_size": "300GB per deposit",
-                "licences_supported": "CC0 only",
-                "persistent_identifier": "DOI",
-                "versioning": "Yes",
-                "embargo_support": "No",
-                "access_model": "Open",
-                "cost": "Free (UW-Madison institutional membership)",
-                "certification": "None",
-                "fair_alignment": "High",
-                "funder_compliance_note": "Meets NSF, NIH, and most publisher data sharing mandates. UW-Madison membership covers all costs.",
-                "sensitive_data_suitable": "No — open access only, no PII or sensitive data",
-                "confidence": "High",
-                "verification_status": "Confirmed — UW-Madison institutional repository",
-                "risk_flag": None,
-                "verify_links": {
-                    "re3data": "https://www.re3data.org/repository/r3d100000044",
-                    "fairsharing": "https://fairsharing.org/FAIRsharing.wkggtx",
-                },
-                "uw_note": "UW-Madison institutional member — free to deposit. Requires ORCID iD and NetID.",
-            },
-            {
-                "name": "MINDS@UW",
-                "type": "Institutional",
-                "url": "https://minds.wisconsin.edu",
-                "scope": "UW-Madison's institutional repository for research papers, datasets, theses, preprints and digital materials.",
-                "fit_reason": "UW-Madison's own institutional repository — ideal for larger datasets or combining publications and data in one collection. Contact the team first to set up your collection.",
-                "data_types_accepted": "All types — datasets, articles, theses, reports, preprints, born-digital materials",
-                "max_file_size": "Case-by-case — good for large datasets exceeding Dryad's 300GB limit",
-                "licences_supported": "Open access (contact team for specifics)",
-                "persistent_identifier": "DOI",
-                "versioning": "Yes",
-                "embargo_support": "Yes",
-                "access_model": "Open",
-                "cost": "Free (UW-Madison affiliation required)",
-                "certification": "Institutional",
-                "fair_alignment": "High",
-                "funder_compliance_note": "Satisfies UW-Madison institutional OA and data management requirements.",
-                "sensitive_data_suitable": "No — open access only, no PII or sensitive data",
-                "confidence": "High",
-                "verification_status": "Confirmed — UW-Madison institutional repository",
-                "risk_flag": None,
-                "verify_links": {
-                    "re3data": "https://www.re3data.org/search?query=MINDS+UW+Madison",
-                    "fairsharing": "https://fairsharing.org/search?q=MINDS+UW+Madison",
-                },
-                "uw_note": "Contact minds.wisconsin.edu/contact to get started. Team will guide setup and deposit.",
-            },
-        ]
-        # Remove any LLM-suggested Dryad/MINDS duplicates, then prepend UW repos
-        repos = [r for r in repos if not any(
-            uw in r.get("name", "").lower() for uw in ["dryad", "minds@uw", "minds@"]
-        )]
-        repos = uw_repos + repos
-
+    # Khazna is always prepended above
     parsed["repositories"] = repos
     return {"result": parsed}
 
@@ -915,26 +850,8 @@ async def chat(req: ChatRequest, request: Request):
     # ── Layer 3: LLM streaming ────────────────────────────────────────────
     client = get_client()
 
-    # Only inject full UW knowledge when question is UW/OA-institution related
-    # For general questions keep system prompt lean to avoid token overflow
-    uw_triggers = [
-        "uw", "wisconsin", "madison", "dryad", "minds", "apc",
-        "article processing", "publishing fee", "waiver", "agreement",
-        "support oa", "cover the fee", "pay for", "free to publish",
-        "carrie nelson", "library support"
-    ]
-    last_lower = last_msg.lower()
-    inject_knowledge = any(t in last_lower for t in uw_triggers)
-
-    knowledge_section = get_knowledge() if inject_knowledge else (
-        "UW-Madison has APC agreements with 13 publishers (ACS, ACM, Cambridge, Springer hybrid, "
-        "Wiley, IOP, ASM, Biochemical Society, Canadian Science Publishing, De Gruyter Brill, "
-        "Microbiology Society, PLoS, SCOAP3). Dryad and MINDS@UW are free institutional repositories. "
-        "For details: library.wisc.edu/research-support/scholarly-communication/open-access/publishing-support"
-    )
-
     system = CHAT_SYSTEM_PROMPT_BASE.replace(
-        "{KU_KNOWLEDGE}", knowledge_section
+        "{KU_KNOWLEDGE}", get_knowledge()
     ).replace(
         "{OPF_DATA}", opf_data if opf_data else "No Open Policy Finder data retrieved for this query."
     )
@@ -945,80 +862,52 @@ async def chat(req: ChatRequest, request: Request):
     messages = [{"role": "system", "content": system}]
     messages += [{"role": m.role, "content": m.content} for m in req.messages]
 
-    async def stream_response() -> AsyncGenerator[str, None]:
-        full_text = ""
-        try:
-            # ── Call 1: Stream the answer with optional web search ──────────
-            # Try with web search first, fall back to plain if not supported
+    def extract_route(text: str):
+        """Brace-counting extraction of routing JSON from end of reply."""
+        starts = [m.start() for m in re.finditer(r'\{', text)]
+        for start in reversed(starts):
+            candidate = text[start:]
+            depth = 0; end = None
+            for i, ch in enumerate(candidate):
+                if ch == '{': depth += 1
+                elif ch == '}':
+                    depth -= 1
+                    if depth == 0: end = i + 1; break
+            if end is None: continue
             try:
-                response = await client.chat.completions.create(
-                    model=MODEL,
-                    messages=messages,
-                    max_tokens=1200,
-                    temperature=0.4,
-                    stream=True,
-                    tools=[{"type": "web_search_preview"}],
-                    tool_choice="auto",
-                )
+                parsed = json.loads(candidate[:end])
+                if "route" in parsed:
+                    return text[:start].strip(), parsed.get("route"), parsed.get("prefill", {})
             except Exception:
-                # Fallback: plain streaming without web search
-                response = await client.chat.completions.create(
-                    model=MODEL,
-                    messages=messages,
-                    max_tokens=1200,
-                    temperature=0.4,
-                    stream=True,
-                )
+                continue
+        return text.strip(), None, {}
 
-            async for chunk in response:
-                token = chunk.choices[0].delta.content if chunk.choices else None
-                if token:
-                    full_text += token
-                    yield f'data: {json.dumps({"token": token, "done": False})}\n\n'
-
-            # ── Call 2: Classify route (small, fast, non-streaming) ─────────
-            route = None
-            prefill = {}
-            try:
-                classification_messages = [
-                    {
-                        "role": "system",
-                        "content": (
-                            "You are a routing classifier. Given a user message, "
-                            "determine if it needs one of these tools:\n"
-                            "- 'journals': user wants to find/recommend a journal, browse by subject, or analyse a manuscript\n"
-                            "- 'license': user wants to check self-archiving rights, deposit a paper, check embargo or OA policy for a specific journal\n"
-                            "- 'data': user wants to find a data repository or deposit a dataset\n"
-                            "- null: general question, greeting, concept explanation — no tool needed\n\n"
-                            "Reply with ONLY valid JSON: "
-                            '{\"route\": \"journals\"|\"license\"|\"data\"|null, \"prefill\": {}}\n'
-                            "No other text. No explanation."
-                        )
-                    },
-                    {"role": "user", "content": last_msg}
-                ]
-                route_resp = await client.chat.completions.create(
-                    model="gpt-4o-mini",
-                    messages=classification_messages,
-                    max_tokens=60,
-                    temperature=0.0,
-                )
-                route_text = route_resp.choices[0].message.content.strip()
-                parsed_route = json.loads(route_text)
-                candidate = parsed_route.get("route")
-                if candidate in ("journals", "license", "data"):
-                    route = candidate
-                    prefill = parsed_route.get("prefill") or {}
-            except Exception as re:
-                logger.warning(f"[Chat route classification] {re}")
+    async def stream_response() -> AsyncGenerator[str, None]:
+        full_text = ""
+        try:
+            # Plain streaming — no tool calls
+            async with client.chat.completions.stream(
+                model=MODEL,
+                messages=messages,
+                max_tokens=600,
+                temperature=0.3,
+            ) as stream:
+                async for chunk in stream:
+                    token = chunk.choices[0].delta.content if chunk.choices else None
+                    if token:
+                        full_text += token
+                        yield f'data: {json.dumps({"token": token, "done": False})}\n\n'
+
+            # Extract route from reply using brace-counting
+            reply, route, prefill = extract_route(full_text)
+            if route not in ("journals", "license", "data", None):
                 route = None
-                prefill = {}
 
             done_payload = json.dumps({
                 "token": "", "done": True,
-                "reply": full_text.strip(),
+                "reply": reply,
                 "route": route,
-                "prefill": prefill,
+                "prefill": prefill or {},
             })
             yield f"data: {done_payload}\n\n"