refactor json parsing to be consistent across agents

app/agents/claims.py

@@ -1,24 +1,156 @@
-# app/agents/claims.py
-from typing import List, Dict
+# app/agents/ibm_client.py
+from __future__ import annotations
+import os, json, re, time, requests
+from typing import Dict, Any, List
+
+from app.core.config import WATSONX_BASE_URL, WATSONX_PROJECT, IBM_CLAIM_MODEL_ID
+from app.utils.auth import get_ibm_iam_token
 from app.schemas.claim import Claim
-from app.agents.ibm_client import run_claim_extractor
+from app.utils.parse_json import parse_json_anywhere
+
+GEN_URL = f"{WATSONX_BASE_URL.rstrip('/')}/ml/v1/text/generation?version=2023-05-29"
+
+def _gen_post(payload: Dict[str, Any], retries: int = 4, timeout: int = 90) -> str:
+    """
+    POST to watsonx text/generation with basic retries for 429/5xx.
+    Returns the text (generated_text/output_text) or raises.
+    """
+    headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {get_ibm_iam_token()}",
+    }
+    backoff = 1.5
+    for attempt in range(retries):
+        r = requests.post(GEN_URL, headers=headers, json=payload, timeout=timeout)
+        if r.status_code in (429, 500, 502, 503, 504):
+            time.sleep(backoff * (2 ** attempt))
+            continue
+        r.raise_for_status()
+        data = r.json()
+        results = data.get("results") or []
+        if results and isinstance(results, list):
+            return (results[0].get("generated_text") or results[0].get("output_text") or "").strip()
+        return (data.get("generated_text") or "").strip()
+    # final raise
+    r.raise_for_status()
+    return ""  # unreachable, keeps linters happy
+
+
+# =========================
+# Claims Extraction (prompt + call)
+# =========================
+
+PROMPT_TEMPLATE = r"""
+You extract factual claims from messy spoken transcripts.
+Return strict JSON with this shape:
+{
+  "claims": [
+    {"text": str, "speaker": str|null, "start": float, "end": float, "confidence": float}
+  ]
+}
+
+Guidelines:
+- A "claim" is a checkable factual assertion (metrics, quantities, time-bound facts).
+- Prefer sentences with numbers, percentages, dates, quantities, KPIs.
+- Split multiple claims in one sentence into separate objects.
+- If unsure about speaker or timestamps, set speaker=null and start/end=0.
+- Do NOT include opinions, greetings, or questions unless they state a checkable fact.
+- Output ONLY JSON. No prose.
+
+Input: We grew forty percent quarter over quarter in Q2. Customer churn fell to two percent. According to the CRM, Q2 growth was twelve percent. Churn stabilized at four percent in Q2.
+Output: {
+  "claims": [
+    {"text":"We grew 40% quarter over quarter in Q2","speaker":null,"start":0.0,"end":0.0,"confidence":0.55},
+    {"text":"Customer churn fell to 2%","speaker":null,"start":0.0,"end":0.0,"confidence":0.55},
+    {"text":"Q2 growth was 12%","speaker":null,"start":0.0,"end":0.0,"confidence":0.7},
+    {"text":"Churn stabilized at 4% in Q2","speaker":null,"start":0.0,"end":0.0,"confidence":0.7}
+  ]
+}
+
+Input: We expanded into three new regions this year. Our operating margin improved by five points since Q1.
+Output: {
+  "claims": [
+    {"text":"We expanded into 3 new regions this year","speaker":null,"start":0.0,"end":0.0,"confidence":0.6},
+    {"text":"Operating margin improved by 5 percentage points since Q1","speaker":null,"start":0.0,"end":0.0,"confidence":0.7}
+  ]
+}
+
+Input: {TRANSCRIPT}
+Output:
+""".strip()
+
+def _build_claims_payload(transcript: str) -> Dict[str, Any]:
+    prompt = PROMPT_TEMPLATE.replace("{TRANSCRIPT}", transcript.strip())
+    return {
+        "input": prompt,
+        "parameters": {
+            "decoding_method": "greedy",
+            "max_new_tokens": 1000,
+            "min_new_tokens": 0,
+            "temperature": 0.0,
+            "repetition_penalty": 1.0,
+            "stop_sequences": ["\n\nInput:", "\nInput:"]
+        },
+        "model_id": IBM_CLAIM_MODEL_ID,
+        "project_id": WATSONX_PROJECT,
+        "moderations": {
+            "hap": {"input": {"enabled": False}, "output": {"enabled": False}},
+            "pii": {"input": {"enabled": False}, "output": {"enabled": False}}
+        }
+    }
+
+def run_claim_extractor(transcript: str) -> Dict[str, Any]:
+    """
+    Calls watsonx to turn a transcript into {"claims":[...]} with robust parsing + auto-repair.
+    """
+    txt = _gen_post(_build_claims_payload(transcript))
+    parsed = parse_json_anywhere(txt, root_key="claims")
+    if parsed and parsed.get("claims"):
+        return parsed
+
+    # One-shot repair prompt (coerce to strict JSON) if the model added prose noise
+    repair_payload = {
+        "input": f"Return ONLY valid JSON object with key 'claims'. Fix and output JSON:\n\n{txt}",
+        "parameters": {"decoding_method": "greedy", "max_new_tokens": 400, "temperature": 0.0},
+        "model_id": CLAIM_MODEL_ID,
+        "project_id": WATSONX_PROJECT
+    }
+    repaired = _gen_post(repair_payload)
+    parsed2 = parse_json_anywhere(repaired, root_key="claims")
+    if parsed2 and parsed2.get("claims"):
+        return parsed2
+
+    # Debug preview (short) to help diagnose prompt drift
+    print("[claims][RAW OUTPUT]", (txt or repaired)[:600])
+    return {"claims": []}
+
+
+# =========================
+# Public: extract_claims (used by orchestrator)
+# =========================
 
 def extract_claims(segments: List[Dict]) -> List[Claim]:
-    transcript = " ".join(s.get("text","") for s in segments).strip()
+    """
+    Aggregates segment texts -> calls run_claim_extractor -> returns List[Claim]
+    """
+    transcript = " ".join(s.get("text", "") for s in segments).strip()
     if not transcript:
         return []
+
     data = run_claim_extractor(transcript)
-    items = data.get("claims", [])
-    claims: List[Claim] = []
+    items = (data or {}).get("claims", [])
+    out: List[Claim] = []
+
     for i, c in enumerate(items):
         text = (c.get("text") or "").strip()
         if not text:
             continue
-        claims.append(Claim(
+        out.append(Claim(
             id=f"c{i}",
             text=text,
             speaker=c.get("speaker"),
-            segment_idx=0,  # map to real segment later using start/end
-            confidence=float(c.get("confidence", 0.6))
+            segment_idx=0,  # TODO: map to true segment via start/end if available
+            confidence=float(c.get("confidence", 0.6)),
         ))
-    return claims
+    return out

app/agents/ibm_client.py

@@ -1,108 +0,0 @@
-# app/agents/ibm_client.py
-import os, json, re, requests
-from typing import Dict, Any
-from app.core.config import WATSONX_BASE_URL, WATSONX_PROJECT
-from app.core.ibm_auth import ibm_iam_token  # we wrote this earlier
-
-GEN_URL = f"{WATSONX_BASE_URL}/ml/v1/text/generation?version=2023-05-29"
-MODEL_ID = os.getenv("IBM_CLAIM_EXTRACTOR_MODEL", "ibm/granite-3-8b-instruct")
-
-# Few-shot, strict-JSON prompt. We’ll append the runtime transcript at the end.
-PROMPT_TEMPLATE = r"""
-You extract factual claims from messy spoken transcripts.
-Return strict JSON with this shape:
-{
-  "claims": [
-    {"text": str, "speaker": str|null, "start": float, "end": float, "confidence": float}
-  ]
-}
-
-Guidelines:
-- A "claim" is a checkable factual assertion (metrics, quantities, time-bound facts).
-- Prefer sentences with numbers, percentages, dates, quantities, KPIs.
-- Split multiple claims in one sentence into separate objects.
-- If unsure about speaker or timestamps, set speaker=null and start/end=0.
-- Do NOT include opinions, greetings, or questions unless they state a checkable fact.
-- Output ONLY JSON. No prose.
-
-Input: We grew forty percent quarter over quarter in Q2. Customer churn fell to two percent. According to the CRM, Q2 growth was twelve percent. Churn stabilized at four percent in Q2.
-Output: {
-  "claims": [
-    {"text":"We grew 40% quarter over quarter in Q2","speaker":null,"start":0.0,"end":0.0,"confidence":0.55},
-    {"text":"Customer churn fell to 2%","speaker":null,"start":0.0,"end":0.0,"confidence":0.55},
-    {"text":"Q2 growth was 12%","speaker":null,"start":0.0,"end":0.0,"confidence":0.7},
-    {"text":"Churn stabilized at 4% in Q2","speaker":null,"start":0.0,"end":0.0,"confidence":0.7}
-  ]
-}
-
-Input: We expanded into three new regions this year. Our operating margin improved by five points since Q1.
-Output: {
-  "claims": [
-    {"text":"We expanded into 3 new regions this year","speaker":null,"start":0.0,"end":0.0,"confidence":0.6},
-    {"text":"Operating margin improved by 5 percentage points since Q1","speaker":null,"start":0.0,"end":0.0,"confidence":0.7}
-  ]
-}
-
-Input: {TRANSCRIPT}
-Output:
-""".strip()
-
-def _build_payload(transcript: str) -> Dict[str, Any]:
-    prompt = PROMPT_TEMPLATE.replace("{TRANSCRIPT}", transcript.strip())
-    return {
-        "input": prompt,
-        "parameters": {
-            "decoding_method": "greedy",
-            "max_new_tokens": 200,
-            "min_new_tokens": 0,
-            "repetition_penalty": 1.0,
-            # Stop when it tries to start another example
-            "stop_sequences": ["\n\nInput:", "\nInput:"]
-        },
-        "model_id": MODEL_ID,
-        "project_id": WATSONX_PROJECT,
-        # Keep moderations minimal; you can re-enable if your org requires it
-        "moderations": {
-            "hap": {"input": {"enabled": False}, "output": {"enabled": False}},
-            "pii": {"input": {"enabled": False}, "output": {"enabled": False}}
-        }
-    }
-
-def _post_generation(payload: Dict[str, Any]) -> str:
-    headers = {
-        "Accept": "application/json",
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {ibm_iam_token()}",
-    }
-    r = requests.post(GEN_URL, headers=headers, json=payload, timeout=90)
-    if r.status_code != 200:
-        raise RuntimeError(f"watsonx generation error: {r.status_code} {r.text}")
-    data = r.json()
-    # watsonx usually returns {"results":[{"generated_text":"..."}], ...}
-    txt = ""
-    if isinstance(data, dict) and "results" in data and data["results"]:
-        txt = data["results"][0].get("generated_text", "")
-    elif isinstance(data, dict) and "generated_text" in data:
-        txt = data["generated_text"]
-    return txt.strip()
-
-def _extract_json_block(text: str) -> Dict[str, Any]:
-    """
-    Try direct JSON parse; if that fails, find the first {...} block and parse it.
-    """
-    try:
-        return json.loads(text)
-    except Exception:
-        pass
-    m = re.search(r"\{.*\}", text, flags=re.DOTALL)
-    if not m:
-        return {"claims": []}
-    try:
-        return json.loads(m.group(0))
-    except Exception:
-        return {"claims": []}
-
-def run_claim_extractor(transcript: str) -> Dict[str, Any]:
-    payload = _build_payload(transcript)
-    out_text = _post_generation(payload)
-    return _extract_json_block(out_text)

app/agents/retriever.py

@@ -4,55 +4,19 @@ import os, json, numpy as np, faiss, requests
 
 from app.schemas.claim import Claim
 from app.schemas.evidence import Evidence
-from app.core.config import WATSONX_BASE_URL as _BASE, WATSONX_PROJECT as _PROJECT, WATSONX_API_KEY as _APIKEY
-
-BASE_URL = (_BASE or "").rstrip("/")          # avoid //ml
-PROJECT_ID = _PROJECT
-API_KEY = _APIKEY
-EMB_MODEL_ID = os.getenv("IBM_EMBEDDINGS_MODEL_ID", "").strip()   # <-- REQUIRED
-RERANK_MODEL_ID = os.getenv("IBM_RERANK_MODEL_ID", "").strip()    # optional
+from app.core.config import WATSONX_BASE_URL as BASE, WATSONX_PROJECT as PROJECT_ID, WATSONX_API_KEY as APIKEY, IBM_EMBEDDINGS_MODEL_ID as EMB_MODEL_ID, IBM_RERANK_MODEL_ID as RERANK_MODEL_ID, IBM_API_VERSION as VERSION, IBM_EMBEDDINGS_MODEL_ID as EMB_MODEL_ID, IBM_RERANK_MODEL_ID as RERANK_MODEL_ID, WATSONX_API_KEY as API_KEY
+from app.utils.auth import get_ibm_iam_token
 
+BASE_URL = (BASE or "").rstrip("/")
 IDX_DIR   = "kb/index"
 IDX_PATH  = f"{IDX_DIR}/kb.index"
 META_PATH = f"{IDX_DIR}/kb_meta.json"
 SNIPPETS  = "kb/snippets.jsonl"
-
-# ---------- IBM helpers ----------
-_tok, _exp = None, 0
-def _ibm_token():
-    import time
-    global _tok, _exp
-    now = time.time()
-    if _tok and now < _exp - 60:
-        return _tok
-    r = requests.post(
-        "https://iam.cloud.ibm.com/identity/token",
-        data={
-            "grant_type": "urn:ibm:params:oauth:grant-type:apikey",
-            "apikey": API_KEY
-        },
-        headers={"Content-Type": "application/x-www-form-urlencoded"},
-        timeout=30
-    )
-    r.raise_for_status()
-    data = r.json(); _tok = data["access_token"]; _exp = now + 3000
-    return _tok
-
-def _assert_ibm_ready():
-    missing = []
-    if not BASE_URL: missing.append("WATSONX_BASE_URL")
-    if not PROJECT_ID: missing.append("WATSONX_PROJECT_ID")
-    if not API_KEY: missing.append("WATSONX_API_KEY")
-    if not EMB_MODEL_ID: missing.append("IBM_EMBEDDINGS_MODEL_ID")
-    if missing:
-        raise RuntimeError(f"IBM embeddings not configured. Missing: {', '.join(missing)}")
-
-VERSION = os.getenv("IBM_API_VERSION", "2023-05-29")
 BASE_URL = BASE_URL.rstrip("/")
 
 def _ibm_embed(texts: list[str]) -> np.ndarray:
     url = f"{BASE_URL}/ml/v1/text/embeddings?version={VERSION}"
-    hdr = {"Authorization": f"Bearer {_ibm_token()}",
+    hdr = {"Authorization": f"Bearer {get_ibm_iam_token()}",
            "Accept": "application/json",
            "Content-Type": "application/json"}
     payload = {
@@ -91,7 +55,7 @@ def _ibm_rerank(query: str, docs: list[dict], top_n: int = 5) -> list[dict]:
     if not docs or not RERANK_MODEL_ID:
         return docs
     url = f"{BASE_URL}/ml/v1/text/rerank?version={VERSION}"
-    hdr = {"Authorization": f"Bearer {_ibm_token()}",
+    hdr = {"Authorization": f"Bearer {get_ibm_iam_token()}",
            "Accept":"application/json","Content-Type":"application/json"}
     payload = {
         "input": {
@@ -118,6 +82,7 @@ def _ibm_rerank(query: str, docs: list[dict], top_n: int = 5) -> list[dict]:
 
 # ---------- Local embeddings fallback ----------
 _embedder = None
+
 def _local_embed(texts: list[str]) -> np.ndarray:
     global _embedder
     if _embedder is None:

app/agents/summarizer.py

@@ -1,48 +1,81 @@
 # app/agents/summarizer.py
 from __future__ import annotations
-import os, json, requests, re
+import os, json, time, requests
 from typing import List, Dict, Any
+
 from app.schemas.report import CallReport
 from app.schemas.claim import Claim
 from app.schemas.evidence import Evidence
 from app.schemas.verdict import Verdict
-from app.core.config import WATSONX_BASE_URL, WATSONX_PROJECT, WATSONX_API_KEY
-from app.core.json_utils import extract_json_obj
-
-VERSION = os.getenv("IBM_API_VERSION", "2023-05-29")
-MODEL_ID = os.getenv("IBM_SUMMARY_MODEL_ID", "ibm/granite-3-8b-instruct")
-
-def _iam_token() -> str:
-    r = requests.post(
-        "https://iam.cloud.ibm.com/identity/token",
-        data={"grant_type":"urn:ibm:params:oauth:grant-type:apikey","apikey":WATSONX_API_KEY},
-        headers={"Content-Type":"application/x-www-form-urlencoded"},
-        timeout=30
-    )
-    r.raise_for_status()
-    return r.json()["access_token"]
+from app.core.config import (
+    WATSONX_BASE_URL,
+    WATSONX_PROJECT,
+    IBM_SUMMARY_MODEL_ID as MODEL_ID,
+    IBM_API_VERSION,
+)
+from app.utils.auth import get_ibm_iam_token
+from app.utils.parse_json import parse_json_anywhere
 
-_JSON = re.compile(r"\{[\s\S]*\}\s*$")
 
+# -------- Helpers --------
+
+def _compact_segments(segments: List[Dict[str, Any]], max_chars: int = 6000) -> List[Dict[str, Any]]:
+    """
+    Keep the last ~N characters of transcript text to stay under token limits,
+    preserving structure (start, end, speaker, text).
+    """
+    if not segments:
+        return []
+    # Prefer the tail of the conversation (most recent context is more salient)
+    out = []
+    total = 0
+    for seg in reversed(segments):
+        t = seg.get("text", "") or ""
+        total += len(t)
+        out.append({"start": seg.get("start", 0.0),
+                    "end": seg.get("end", 0.0),
+                    "speaker": seg.get("speaker"),
+                    "text": t})
+        if total >= max_chars:
+            break
+    return list(reversed(out))
 
-# Replace _safe_json with:
-def _safe_json(s: str) -> dict:
-    return extract_json_obj(s)
+def _verdict_stats(verdicts: List[Verdict]) -> Dict[str, int]:
+    s = sum(1 for v in verdicts if v.label == "supported")
+    r = sum(1 for v in verdicts if v.label == "refuted")
+    i = sum(1 for v in verdicts if v.label == "insufficient")
+    return {"supported": s, "refuted": r, "insufficient": i, "total": len(verdicts)}
+
+def _http_post_with_retry(url: str, headers: dict, body: dict, timeout: int = 120, tries: int = 4, backoff: float = 1.5):
+    for attempt in range(tries):
+        r = requests.post(url, headers=headers, json=body, timeout=timeout)
+        if r.status_code not in (429, 500, 502, 503, 504):
+            r.raise_for_status()
+            return r
+        time.sleep(backoff * (2 ** attempt))
+    # last try result:
+    r.raise_for_status()
+    return r
+
+
+# -------- Prompt (kept tight & structured) --------
 
-# ---- Prompt for structured output ----
 PROMPT = """You are a precise meeting summarizer for sales/stakeholder calls.
 Given transcript segments, normalized claims, and their verification labels, produce a concise executive summary.
 
 Return STRICT JSON only with:
 {
-  "call_summary": "string, <= 6 sentences, neutral, factual",
-  "action_items": ["string", "..."]            // 1-6 bullets, imperative
+  "call_summary": "string (<= 6 sentences, neutral, factual, cites concrete numbers/dates/KPIs when present)",
+  "action_items": ["string", "..."]  // 1-6 imperative bullets; each starts with a verb
 }
 
-Guidelines:
+Guidance:
 - Emphasize mismatches between stated claims and evidence.
-- Mention concrete metrics (%, $, dates) when present.
-- Avoid fluff and opinions; be concise and factual.
+- Prioritize concrete, verifiable metrics (%, $, dates, counts).
+- Be concise; avoid fluff and opinions.
+
+Context stats (for your awareness; do not invent numbers):
+{VERDICT_STATS}
 
 Segments (JSON):
 {SEGMENTS_JSON}
@@ -53,10 +86,12 @@ Claims (JSON):
 Verdicts (JSON):
 {VERDICTS_JSON}
 
-Now return JSON only:
+Output JSON only (no extra text, no markdown, no backticks):
 """
 
-# ---- Public API ----
+
+# -------- Public API --------
+
 def make_report(
     segments: List[Dict[str, Any]],
     claims: List[Claim],
@@ -65,28 +100,43 @@ def make_report(
 ) -> CallReport:
     """
     Build a CallReport:
-      - call_summary + action_items from IBM LLM
-      - claim_table from verdicts (+ best evidence id)
+      - call_summary + action_items from IBM LLM (robust parse)
+      - claim_table derived from verdicts (+ best evidence id)
     """
-    # ---- Prepare claim_table from verdicts
-    # Map claim_id -> claim text
+
+    # 1) Build claim table from verdicts (always succeeds)
     id2claim = {c.id: c.text for c in claims}
     claim_table: List[Dict[str, Any]] = []
     for v in verdicts:
         claim_text = id2claim.get(v.claim_id, "")
-        row = {
+        claim_table.append({
             "claim": claim_text,
             "status": v.label.capitalize(),
             "evidence_source": v.best_evidence_id or ""
-        }
-        claim_table.append(row)
+        })
+
+    # 2) Short-circuit if we have no content to summarize
+    if not segments and not claims:
+        return CallReport(
+            call_summary="",
+            claim_table=claim_table,
+            action_items=["Review claims vs. evidence and confirm metrics in source-of-truth."],
+            claims=claims,
+            verdicts=verdicts,
+            evidence=evidence_flat
+        )
+
+    # 3) Prepare compact context + stats
+    compact = _compact_segments(segments, max_chars=6000)
+    stats = _verdict_stats(verdicts)
 
-    # ---- Try IBM Granite for summary/action items
+    # 4) Call IBM Granite (watsonx) for structured summary
     call_summary = ""
     action_items: List[str] = []
+
     try:
-        tok = _iam_token()
-        url = f"{WATSONX_BASE_URL.rstrip('/')}/ml/v1/text/generation?version={VERSION}"
+        tok = get_ibm_iam_token()
+        url = f"{WATSONX_BASE_URL.rstrip('/')}/ml/v1/text/generation?version={IBM_API_VERSION}"
         headers = {
             "Authorization": f"Bearer {tok}",
             "Accept": "application/json",
@@ -94,7 +144,8 @@ def make_report(
         }
         body = {
             "input": PROMPT \
-                .replace("{SEGMENTS_JSON}", json.dumps(segments, ensure_ascii=False)) \
+                .replace("{VERDICT_STATS}", json.dumps(stats, ensure_ascii=False)) \
+                .replace("{SEGMENTS_JSON}", json.dumps(compact, ensure_ascii=False)) \
                 .replace("{CLAIMS_JSON}", json.dumps([{"id": c.id, "text": c.text} for c in claims], ensure_ascii=False)) \
                 .replace("{VERDICTS_JSON}", json.dumps([{
                     "claim_id": v.claim_id,
@@ -108,31 +159,40 @@ def make_report(
             "parameters": {
                 "decoding_method": "greedy",
                 "temperature": 0.0,
-                "max_new_tokens": 300,
+                "max_new_tokens": 400,
                 "min_new_tokens": 0,
-                "repetition_penalty": 1.0
+                "repetition_penalty": 1.0,
+                "stop_sequences": ["\n\n", "\nOutput JSON", "\nSegments (JSON):"]
             }
         }
-        r = requests.post(url, headers=headers, json=body, timeout=120)
-        r.raise_for_status()
-        out = r.json()
-        gen = (out.get("results") or [{}])[0].get("generated_text", "")
-        parsed = _safe_json(gen)
-        call_summary = (parsed.get("call_summary") or "").strip()
-        action_items = parsed.get("action_items") or []
+
+        resp = _http_post_with_retry(url, headers, body, timeout=120)
+        out = resp.json()
+        gen = (out.get("results") or [{}])[0].get("generated_text", "") or ""
+
+        # Robust parse (accepts full JSON, partials, or multiple JSON objects)
+        parsed = parse_json_anywhere(gen, root_key=None)  # expecting a single dict with keys above
+        if isinstance(parsed, dict):
+            call_summary = (parsed.get("call_summary") or "").strip()
+            action_items = parsed.get("action_items") or []
+        else:
+            # If parse returns a list (rare), try first dict
+            if parsed and isinstance(parsed, list) and isinstance(parsed[0], dict):
+                call_summary = (parsed[0].get("call_summary") or "").strip()
+                action_items = parsed[0].get("action_items") or []
+
         if not isinstance(action_items, list):
             action_items = [str(action_items)]
+
     except Exception as e:
-        # Fallback: extract a terse summary from first few segments
+        # 5) Fallback: build a terse summary from first few segments and stats
         print(f"[summarizer] watsonx generation failed: {e}")
-        texts = [s.get("text","") for s in segments if s.get("text")]
+        texts = [s.get("text","") for s in compact if s.get("text")]
         joined = " ".join(texts)[:450].strip()
         call_summary = (joined + "…") if joined else ""
-        if not action_items:
-            action_items = ["Review claims vs. evidence and confirm metrics in source-of-truth."]
 
-    # ---- Build CallReport dataclass (schema)
-    report = CallReport(
+    # 6) Return CallReport
+    return CallReport(
         call_summary=call_summary,
         claim_table=claim_table,
         action_items=action_items,
@@ -140,4 +200,3 @@ def make_report(
         verdicts=verdicts,
         evidence=evidence_flat
     )
-    return report

app/agents/verifier.py

@@ -1,32 +1,15 @@
 # app/agents/verifier.py
 from __future__ import annotations
-import os, json, re, requests
+import os, json, requests
 from typing import List, Dict
+
 from app.schemas.claim import Claim
 from app.schemas.evidence import Evidence
 from app.schemas.verdict import Verdict
-from app.core.config import WATSONX_BASE_URL, WATSONX_PROJECT, WATSONX_API_KEY
-from app.core.json_utils import extract_json_obj
-
-
-VERSION = os.getenv("IBM_API_VERSION", "2023-05-29")
-MODEL_ID = os.getenv("IBM_VERIFIER_MODEL_ID", "ibm/granite-3-8b-instruct")
-# ---- IAM helper ----
-def _iam_token() -> str:
-    r = requests.post(
-        "https://iam.cloud.ibm.com/identity/token",
-        data={
-            "grant_type": "urn:ibm:params:oauth:grant-type:apikey",
-            "apikey": WATSONX_API_KEY,
-        },
-        headers={"Content-Type": "application/x-www-form-urlencoded"},
-        timeout=30,
-    )
-    r.raise_for_status()
-    return r.json()["access_token"]
+from app.core.config import WATSONX_BASE_URL, WATSONX_PROJECT, IBM_VERIFIER_MODEL_ID, IBM_API_VERSION
+from app.utils.auth import get_ibm_iam_token
+from app.utils.parse_json import parse_json_anywhere 
 
-
-# Strengthen the prompt header:
 PROMPT = """You are a precise fact verifier.
 Return STRICT JSON ONLY. Your first character MUST be '{' and your last character MUST be '}'.
 Schema:
@@ -53,44 +36,63 @@ Evidence catalog (doc_id -> snippet) as JSON:
 Output JSON:
 """
 
-# Replace _safe_json with:
-def _safe_json(s: str) -> dict:
-    return extract_json_obj(s)
-
-# In _post_generation() keep as-is, but add debug preview if parse fails:
-def _post_generation(prompt: str) -> dict:
-    url = f"{WATSONX_BASE_URL.rstrip('/')}/ml/v1/text/generation?version={VERSION}"
-    tok = _iam_token()
+def _gen(url: str, body: dict, timeout: int = 120) -> str:
+    """Low-level call to watsonx text/generation; returns raw model text."""
+    tok = get_ibm_iam_token()
     headers = {
         "Authorization": f"Bearer {tok}",
         "Accept": "application/json",
         "Content-Type": "application/json",
     }
+    r = requests.post(url, headers=headers, json=body, timeout=timeout)
+    r.raise_for_status()
+    j = r.json()
+    res = j.get("results") or []
+    return (res[0].get("generated_text") if res else "") or ""
+
+def _post_generation(prompt: str) -> dict:
+    """Call model → parse with parse_json_anywhere(root='verdicts') → repair once if needed."""
+    url = f"{WATSONX_BASE_URL.rstrip('/')}/ml/v1/text/generation?version={IBM_API_VERSION}"
     body = {
         "input": prompt,
-        "model_id": MODEL_ID,
+        "model_id": IBM_VERIFIER_MODEL_ID,
         "project_id": WATSONX_PROJECT,
         "parameters": {
             "decoding_method": "greedy",
-            "max_new_tokens": 400,
+            "max_new_tokens": 600,
             "min_new_tokens": 0,
             "repetition_penalty": 1.0,
             "temperature": 0.0,
         },
     }
-    r = requests.post(url, headers=headers, json=body, timeout=120)
-    r.raise_for_status()
-    out = r.json()
-    results = out.get("results") or []
-    text = (results[0] or {}).get("generated_text", "") if results else ""
-    if not text:
-        raise RuntimeError(f"Empty generation response: {out}")
-    try:
-        return _safe_json(text)
-    except Exception as e:
-        print("[verifier] RAW OUTPUT >>>", text[:1000])
-        raise
 
+    text = _gen(url, body)
+    parsed = parse_json_anywhere(text, root_key="verdicts")
+    if parsed and parsed.get("verdicts"):
+        return parsed
+
+    # One-shot repair: coerce to strict JSON with 'verdicts' root
+    repair_body = {
+        "input": (
+            "Return ONLY valid JSON object with root key 'verdicts' "
+            "(no prose, no markdown). If invalid, fix and output JSON:\n\n" + text
+        ),
+        "model_id": IBM_VERIFIER_MODEL_ID,
+        "project_id": WATSONX_PROJECT,
+        "parameters": {
+            "decoding_method": "greedy",
+            "max_new_tokens": 400,
+            "temperature": 0.0,
+        },
+    }
+    repaired = _gen(url, repair_body)
+    reparsed = parse_json_anywhere(repaired, root_key="verdicts")
+    if reparsed and reparsed.get("verdicts"):
+        return reparsed
+
+    # Debug preview if still not parsable
+    print("[verifier] RAW OUTPUT >>>", (text or repaired)[:1000])
+    return {"verdicts": []}
 
 def verify(claims: List[Claim], evidence_map: Dict[str, List[Evidence]]) -> List[Verdict]:
     """
@@ -98,25 +100,27 @@ def verify(claims: List[Claim], evidence_map: Dict[str, List[Evidence]]) -> List
     evidence_map: claim_id -> List[Evidence] (must have .doc_id, .snippet)
     returns: List[Verdict]
     """
-    # 1) Flatten evidence to a doc_id -> snippet map (only those we surfaced)
+    # 1) Flatten evidence to a doc_id -> snippet catalog
     doc_catalog: Dict[str, str] = {}
     for lst in evidence_map.values():
         for e in lst:
-            # Don't overwrite if duplicate doc_ids appear across claims
             doc_catalog.setdefault(e.doc_id, e.snippet)
 
     # 2) Minimal claims JSON for the LLM
     claims_json = [{"id": c.id, "text": c.text} for c in claims]
 
-    # 3) Render prompt
-    prompt = PROMPT.replace("{CLAIMS_JSON}", json.dumps(claims_json, ensure_ascii=False)) \
-                   .replace("{EVIDENCE_JSON}", json.dumps(doc_catalog, ensure_ascii=False))
+    # 3) Build prompt
+    prompt = (
+        PROMPT
+        .replace("{CLAIMS_JSON}", json.dumps(claims_json, ensure_ascii=False))
+        .replace("{EVIDENCE_JSON}", json.dumps(doc_catalog, ensure_ascii=False))
+    )
 
-    # 4) Call watsonx
+    # 4) Call model + robust parse
     try:
         parsed = _post_generation(prompt)
     except Exception as e:
-        # Fallback: everything "insufficient"
+        # Fail-safe: mark all as insufficient
         print(f"[verifier] generation failed: {e}")
         return [
             Verdict(
@@ -125,45 +129,40 @@ def verify(claims: List[Claim], evidence_map: Dict[str, List[Evidence]]) -> List
                 confidence=0.4,
                 best_evidence_id="",
                 rationale="Verifier offline; defaulting to insufficient."
-            ) for c in claims
+            )
+            for c in claims
         ]
 
-    # 5) Validate + convert to Verdict[]
-    out: List[Verdict] = []
+    # 5) Convert to Verdict[]
     allowed = {"supported", "refuted", "insufficient"}
-    items = parsed.get("verdicts", [])
-    # Build a quick lookup of top evidence per claim (by retriever score) as tiebreaker
+    items = parsed.get("verdicts", []) or []
+
+    # Tiebreaker: top retrieved evidence per claim
     top_ev: Dict[str, str] = {}
     for c in claims:
         evs = evidence_map.get(c.id, [])
         best = max(evs, key=lambda e: e.score, default=None)
         top_ev[c.id] = best.doc_id if best else ""
 
+    out: List[Verdict] = []
     for it in items:
         cid = it.get("claim_id", "")
         label = (it.get("label") or "").lower()
         conf = float(it.get("confidence", 0.5))
         cites = it.get("citation_ids") or []
-        rationale = it.get("rationale") or ""
-
+        rationale = (it.get("rationale") or "")[:300]
         if label not in allowed:
             label = "insufficient"
 
-        # Choose best_evidence_id:
-        best_id = ""
-        for d in cites:
-            if d in doc_catalog:
-                best_id = d
-                break
-        if not best_id:
-            best_id = top_ev.get(cid, "")
+        # choose best_evidence_id from cited doc_ids or fallback to top_ev
+        best_id = next((d for d in cites if d in doc_catalog), "") or top_ev.get(cid, "")
 
         out.append(Verdict(
             claim_id=cid,
             label=label,
             confidence=conf,
             best_evidence_id=best_id,
-            rationale=rationale[:300]
+            rationale=rationale
         ))
 
     # Ensure every claim has a verdict

app/core/config.py

@@ -9,3 +9,9 @@ WHISPER_MODEL_SIZE = os.getenv("WHISPER_MODEL_SIZE", "")
 WATSONX_BASE_URL = os.getenv("WATSONX_BASE_URL", "")
 WATSONX_PROJECT  = os.getenv("WATSONX_PROJECT_ID", "")
 WATSONX_API_KEY  = os.getenv("WATSONX_API_KEY", "")
+IBM_API_VERSION = os.getenv("IBM_API_VERSION", "")
+IBM_EMBEDDINGS_MODEL_ID = os.getenv("IBM_EMBEDDINGS_MODEL_ID", "")
+IBM_RERANK_MODEL_ID = os.getenv("IBM_RERANK_MODEL_ID", "")
+IBM_CLAIM_MODEL_ID = os.getenv("IBM_CLAIM_MODEL_ID", "")
+IBM_VERIFIER_MODEL_ID = os.getenv("IBM_VERIFIER_MODEL_ID", "")
+IBM_SUMMARY_MODEL_ID = os.getenv("IBM_SUMMARY_MODEL_ID", "")

app/core/ibm_auth.py

@@ -1,20 +0,0 @@
-# app/core/ibm_auth.py
-import requests, time, os
-from app.core.config import WATSONX_API_KEY
-
-_iam = {"tok": None, "exp": 0}
-
-def ibm_iam_token():
-    now = time.time()
-    if _iam["tok"] and now < _iam["exp"] - 60:
-        return _iam["tok"]
-    r = requests.post(
-        "https://iam.cloud.ibm.com/identity/token",
-        data={"grant_type":"urn:ibm:params:oauth:grant-type:apikey","apikey":WATSONX_API_KEY},
-        headers={"Content-Type":"application/x-www-form-urlencoded"}
-    )
-    r.raise_for_status()
-    tok = r.json()["access_token"]
-    _iam["tok"] = tok
-    _iam["exp"] = now + 3000  # ~50 min
-    return tok

app/core/ibm_sanity.py

@@ -1,24 +1,16 @@
 # app/core/ibm_sanity.py
 import os, requests, json, numpy as np
 from app.core.config import WATSONX_BASE_URL, WATSONX_PROJECT, WATSONX_API_KEY
+from app.utils.auth import get_ibm_iam_token
 
 VERSION = os.getenv("IBM_API_VERSION", "2023-05-29")
 EMB = os.getenv("IBM_EMBEDDINGS_MODEL_ID", "")
 CLAIM = os.getenv("IBM_CLAIM_MODEL_ID", "")
 VERIFY = os.getenv("IBM_VERIFIER_MODEL_ID", "")
 
-def _iam_token() -> str:
-    r = requests.post(
-        "https://iam.cloud.ibm.com/identity/token",
-        data={"grant_type":"urn:ibm:params:oauth:grant-type:apikey","apikey":WATSONX_API_KEY},
-        headers={"Content-Type":"application/x-www-form-urlencoded"},
-        timeout=30
-    )
-    r.raise_for_status()
-    return r.json()["access_token"]
 
 def sanity_embeddings():
-    tok = _iam_token()
+    tok = get_ibm_iam_token()
     r = requests.post(
         f"{WATSONX_BASE_URL.rstrip('/')}/ml/v1/text/embeddings?version={VERSION}",
         headers={"Authorization":f"Bearer {tok}","Accept":"application/json","Content-Type":"application/json"},
@@ -28,11 +20,12 @@ def sanity_embeddings():
     r.raise_for_status()
     j = r.json()
     items = j.get("data") or j.get("results") or []
-    dim = len(items[0]["embedding"])
+    dim = len(items[0]["embedding"]) if items else 0
     return {"ok": True, "dim": dim}
 
+
 def sanity_generation(model_id: str, prompt: str):
-    tok = _iam_token()
+    tok = get_ibm_iam_token()
     r = requests.post(
         f"{WATSONX_BASE_URL.rstrip('/')}/ml/v1/text/generation?version={VERSION}",
         headers={"Authorization":f"Bearer {tok}","Accept":"application/json","Content-Type":"application/json"},

app/core/json_utils.py

@@ -1,48 +0,0 @@
-# app/core/json_utils.py
-from __future__ import annotations
-import json, re
-
-# Fast path: last {...} block
-_LAST_JSON = re.compile(r"\{[\s\S]*\}\s*$")
-
-def extract_json_obj(text: str) -> dict:
-    s = text.strip()
-    # 1) Try last-JSON regex (often enough)
-    m = _LAST_JSON.search(s)
-    if m:
-        try:
-            return json.loads(m.group(0))
-        except Exception:
-            pass
-
-    # 2) Balanced-brace scan: find the largest valid JSON object
-    best = None
-    stack = 0
-    start = None
-    for i, ch in enumerate(s):
-        if ch == '{':
-            if stack == 0:
-                start = i
-            stack += 1
-        elif ch == '}':
-            if stack > 0:
-                stack -= 1
-                if stack == 0 and start is not None:
-                    candidate = s[start:i+1]
-                    try:
-                        obj = json.loads(candidate)
-                        best = obj  # keep last valid (usually the largest)
-                    except Exception:
-                        pass
-    if best is not None:
-        return best
-
-    # 3) Try to strip common wrappers like code fences
-    s2 = s.strip("` \n\t")
-    try:
-        return json.loads(s2)
-    except Exception:
-        pass
-
-    # 4) Give up with a readable error
-    raise ValueError("Could not extract JSON object from model text")

app/utils/auth.py

@@ -0,0 +1,29 @@
+import time
+import requests
+from app.core.config import WATSONX_API_KEY
+
+
+_iam_cache = {"token": None, "expiry": 0.0}
+
+
+def get_ibm_iam_token() -> str:
+    now = time.time()
+    token = _iam_cache.get("token")
+    expiry = _iam_cache.get("expiry", 0.0)
+    if token and now < (expiry - 60):
+        return token
+
+    response = requests.post(
+        "https://iam.cloud.ibm.com/identity/token",
+        data={
+            "grant_type": "urn:ibm:params:oauth:grant-type:apikey",
+            "apikey": WATSONX_API_KEY,
+        },
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        timeout=30,
+    )
+    response.raise_for_status()
+    token = response.json()["access_token"]
+    _iam_cache["token"] = token
+    _iam_cache["expiry"] = now + 3000  # ~50 minutes
+    return token 

app/utils/parse_json.py

@@ -0,0 +1,172 @@
+import json
+import re
+from typing import Any, Optional, Union
+
+
+def _strip_trailing_commas(s: str) -> str:
+    """Remove trailing commas before ] or }"""
+    return re.sub(r',\s*(\]|\})', r'\1', s)
+
+
+def _balance_brackets(s: str) -> str:
+    """Balance unclosed braces/brackets for incomplete JSON."""
+    opens = {"{": "}", "[": "]"}
+    stack = []
+    for ch in s:
+        if ch in opens:
+            stack.append(opens[ch])
+        elif ch in opens.values() and stack and ch == stack[-1]:
+            stack.pop()
+    return s + "".join(reversed(stack))
+
+
+def _find_json_like(text: str) -> Optional[str]:
+    """
+    Finds the first plausible JSON substring in the text.
+    Can match dict `{...}` or list `[...]`.
+    """
+    m = re.search(r'(\{|\[)', text)
+    if not m:
+        return None
+    start = m.start()
+
+    # Try to find last closing bracket
+    last_brace = max(text.rfind("}"), text.rfind("]"))
+    if last_brace == -1:
+        last_brace = len(text)
+
+    candidate = text[start:last_brace + 1]
+    return candidate.strip()
+
+
+def parse_json_anywhere(
+    text: str,
+    root_key: Optional[str] = None
+) -> Union[dict, list, None]:
+    """
+    Universal JSON parser for LLM output.
+    - Accepts JSON object or array
+    - Repairs common LLM formatting issues
+    - Optionally extracts by `root_key`
+    - Handles incomplete JSON (unbalanced braces/brackets)
+
+    Args:
+        text: raw LLM output
+        root_key: if provided, returns only the value at that key
+                  (works even if wrapped in an array)
+
+    Returns:
+        Parsed JSON object, list, or None if all parsing fails
+    """
+    if not text:
+        return None
+
+    # 1) Direct parse attempt
+    try:
+        data = json.loads(text)
+        return _extract_root(data, root_key)
+    except Exception:
+        pass
+
+    # 2) Extract JSON-ish substring from text
+    candidate = _find_json_like(text)
+    if candidate:
+        # repair commas & bracket balance
+        repaired = _balance_brackets(_strip_trailing_commas(candidate))
+
+        for blob in (candidate, repaired):
+            try:
+                data = json.loads(blob)
+                return _extract_root(data, root_key)
+            except Exception:
+                continue
+
+    return None
+
+
+def _extract_root(data: Any, root_key: Optional[str]) -> Any:
+    """Get data by root key if needed; handle array-wrapped objects."""
+    if not root_key:
+        return data
+
+    if isinstance(data, dict) and root_key in data:
+        return data
+    if isinstance(data, list):
+        for item in data:
+            if isinstance(item, dict) and root_key in item:
+                return item
+    return {root_key: []}
+
+
+import re, json
+from json import JSONDecoder
+from typing import Any, Optional
+
+_JSON_OBJ = re.compile(r'\{')
+
+def iter_json_objects(s: str):
+    """Yield every JSON object found in a string."""
+    dec = JSONDecoder()
+    for m in _JSON_OBJ.finditer(s or ""):
+        try:
+            obj, _ = dec.raw_decode(s, m.start())
+            yield obj
+        except Exception:
+            continue
+
+def strip_footers(text: str) -> str:
+    """Remove common model footnotes like '*Note:' or 'Note:'."""
+    lines = (text or "").splitlines()
+    clean = []
+    for ln in lines:
+        if ln.lstrip().lower().startswith(("*note", "note:")):
+            break
+        clean.append(ln)
+    return "\n".join(clean)
+
+def merge_json_blocks(blocks: list[dict], root_key: str) -> dict:
+    """
+    Merge multiple dicts with the same list-valued root_key, 
+    de-dupe by object identity (stringified) for now.
+    """
+    merged = []
+    seen = set()
+    for b in blocks:
+        vals = b.get(root_key) or []
+        if not isinstance(vals, list):
+            continue
+        for v in vals:
+            key = json.dumps(v, sort_keys=True)
+            if key not in seen:
+                merged.append(v)
+                seen.add(key)
+    return {root_key: merged}
+
+def parse_json_anywhere(text: str, root_key: Optional[str] = None) -> dict[str, Any]:
+    """
+    Parse potentially messy LLM output into JSON. If root_key is given, 
+    only keep JSON objects that have that key (list-valued).
+    """
+    if not text:
+        return {root_key or "": []}
+    text = strip_footers(text.strip())
+
+    # try naive load first
+    try:
+        obj = json.loads(text)
+        if not root_key or root_key in obj:
+            return obj
+    except Exception:
+        pass
+
+    blocks = []
+    for obj in iter_json_objects(text):
+        if not isinstance(obj, dict):
+            continue
+        if root_key and root_key not in obj:
+            continue
+        blocks.append(obj)
+
+    if not blocks:
+        return {root_key or "": []}
+    return merge_json_blocks(blocks, root_key) if root_key else blocks[0]