Demo A + Demo B

data/run_logs.jsonl

@@ -0,0 +1,5 @@
+{"run_id": "run_20260227T075002Z_6e0866a2", "agent_id": "demo_agent", "model_id": "workflow_demo_model", "version_id": "0.1.0", "policy_id": "hitl_and_pricing_policy", "policy_version": "1.0", "task_type": "fintech_credit_risk", "timestamps": {"created_at": "2026-02-27T07:50:02+00:00"}, "decision": "Decision Draft", "result": {"risk_score_pd": 0.32, "requested_amount": 250000.0, "routing_reason": "LOW_RISK", "explainability": {"formula": "risk = 0.6*(debt/income) + 0.4*((850-credit_score)/850)", "intermediates": {"debt_to_income": 0.4, "score_gap": 0.2}, "how_to_read": "Higher risk_score_pd means higher predicted risk (baseline, not calibrated)."}}, "evidence": {"steps": [{"step_id": "step_20260227T075002Z_e0111644", "name": "memory_touch", "started_at": "2026-02-27T07:50:02+00:00", "ended_at": "2026-02-27T07:50:02+00:00", "duration_ms": 25, "inputs": {"thread_id": "demo_thread"}, "outputs": {"thread_state": {"note": "no_state_returned", "thread_id": "demo_thread"}}, "evidence": {"checkpointer": "sqlite"}, "error": null}, {"step_id": "step_20260227T075002Z_14980458", "name": "risk_scoring", "started_at": "2026-02-27T07:50:02+00:00", "ended_at": "2026-02-27T07:50:02+00:00", "duration_ms": 0, "inputs": {"income": 75000.0, "debt": 30000.0, "credit_score": 680}, "outputs": {"risk_score_pd": 0.32, "intermediates": {"debt_to_income": 0.4, "score_gap": 0.2}, "formula": "risk = 0.6*(debt/income) + 0.4*((850-credit_score)/850)"}, "evidence": {}, "error": null}, {"step_id": "step_20260227T075002Z_bde83fbe", "name": "hitl_policy", "started_at": "2026-02-27T07:50:02+00:00", "ended_at": "2026-02-27T07:50:02+00:00", "duration_ms": 0, "inputs": {"risk_score_pd": 0.32, "requested_amount": 250000.0}, "outputs": {"decision": "Decision Draft", "reason": "LOW_RISK", "threshold": 0.5, "band": 0.05}, "evidence": {"policy": {"threshold": 0.5, "border_band": 0.05, "high_impact_amount": 1000000.0}}, "error": null}]}}
+{"run_id": "run_20260227T075133Z_54f884cf", "agent_id": "demo_agent", "model_id": "workflow_demo_model", "version_id": "0.1.0", "policy_id": "hitl_and_pricing_policy", "policy_version": "1.0", "task_type": "te_pricing", "timestamps": {"created_at": "2026-02-27T07:51:33+00:00"}, "decision": "Pricing Draft", "result": {"brand_context": "TE", "pricing": {"presale_price": 41.99, "retail_price": 51.99, "unit_margin_presale": 31.990000000000002, "unit_margin_retail": 41.99, "assumptions": {"alpha": 120.0, "beta": 0.08, "discount": 0.2}, "optimization": {"presale": 42.0, "demand": 4.168231073368628, "objective_profit": 133.3833943477961}, "policy_checks": {"presale_ge_floor": false, "presale_ge_7xcogs": false, "retail_gt_presale": true}, "benchmark_placeholder": [{"category": "smart_plug", "brand": "TP-Link Kasa"}, {"category": "smart_plug", "brand": "Amazon Smart Plug"}, {"category": "in_wall_outlet", "brand": "Leviton Decora Smart"}, {"category": "premium", "brand": "Eve (Matter/Thread)"}], "limitations": "Benchmark list is a placeholder. Replace with a curated dataset for evidence."}, "explainability": {"objective": "(price - landed) * demand(price)", "demand_curve": "alpha * exp(-beta * price) (placeholder)", "why_placeholder": "Replace alpha/beta using real presale conversion data."}}, "evidence": {"steps": [{"step_id": "step_20260227T075133Z_a29bd2d9", "name": "memory_touch", "started_at": "2026-02-27T07:51:33+00:00", "ended_at": "2026-02-27T07:51:33+00:00", "duration_ms": 9, "inputs": {"thread_id": "demo_thread"}, "outputs": {"thread_state": {"note": "no_state_returned", "thread_id": "demo_thread"}}, "evidence": {"checkpointer": "sqlite"}, "error": null}, {"step_id": "step_20260227T075133Z_72e0332c", "name": "pricing_optimization", "started_at": "2026-02-27T07:51:33+00:00", "ended_at": "2026-02-27T07:51:33+00:00", "duration_ms": 0, "inputs": {"cogs": 6.0, "landed": 10.0, "presale_mult": 7.0, "discount": 0.2}, "outputs": {"presale_price": 41.99, "retail_price": 51.99, "policy_checks": {"presale_ge_floor": false, "presale_ge_7xcogs": false, "retail_gt_presale": true}}, "evidence": {}, "error": null}], "brand_rule": "TE naming only on this tab."}}
+{"run_id": "run_20260227T082015Z_b59ab55a", "agent_id": "nexdatawork_demo_agent", "model_id": "framework_langgraph_agent", "version_id": "1.0.0", "policy_id": "hitl_and_pricing_policy", "policy_version": "1.0", "llm_model": "gpt-4o-mini", "task_type": "fintech_credit_risk", "timestamps": {"created_at": "2026-02-27T08:20:15+00:00"}, "decision": "Draft", "result": {"raw_text": "### Decision Summary\n- **Decision**: Decision Draft\n- **Reason**: LOW_RISK (The risk score is below the threshold of 0.5)\n\n### Tool JSON Outputs\n1. **fintech_score Output**:\n   ```json\n   {\n     \"risk_score_pd\": 0.32,\n     \"intermediates\": {\n       \"debt_to_income\": 0.4,\n       \"score_gap\": 0.2\n     },\n     \"formula\": \"risk = 0.6*(debt/income) + 0.4*((850-credit_score)/850)\"\n   }\n   ```\n\n2. **hitl_route Output**:\n   ```json\n   {\n     \"decision\": \"Decision Draft\",\n     \"reason\": \"LOW_RISK\",\n     \"threshold\": 0.5,\n     \"band\": 0.05\n   }\n   ```", "error": null}, "evidence": {"steps": [{"step_id": "step_20260227T082015Z_ef940f31", "name": "memory_scope", "started_at": "2026-02-27T08:20:15+00:00", "ended_at": "2026-02-27T08:20:15+00:00", "duration_ms": 0, "inputs": {"thread_id": "demo_thread"}, "outputs": {"checkpointer_kind": "sqlite"}, "evidence": {"note": "Memory is keyed by thread_id via LangGraph checkpointer."}, "error": null}, {"step_id": "step_20260227T082027Z_9b64b7ef", "name": "agent_invoke", "started_at": "2026-02-27T08:20:27+00:00", "ended_at": "2026-02-27T08:20:27+00:00", "duration_ms": 6241, "inputs": {"task_type": "fintech_credit_risk"}, "outputs": {"raw_text_preview": "### Decision Summary\n- **Decision**: Decision Draft\n- **Reason**: LOW_RISK (The risk score is below the threshold of 0.5)\n\n### Tool JSON Outputs\n1. **fintech_score Output**:\n   ```json\n   {\n     \"risk_score_pd\": 0.32,\n     \"intermediates\": {\n       \"debt_to_income\": 0.4,\n       \"score_gap\": 0.2\n     },\n     \"formula\": \"risk = 0.6*(debt/income) + 0.4*((850-credit_score)/850)\"\n   }\n   ```\n\n2. **hitl_route Output**:\n   ```json\n   {\n     \"decision\": \"Decision Draft\",\n     \"reason\": \"LOW_RISK\",\n     \"threshold\": 0.5,\n     \"band\": 0.05\n   }\n   ```"}, "evidence": {"llm_model": "gpt-4o-mini"}, "error": null}]}}
+{"run_id": "run_20260227T082059Z_9a7de9cf", "agent_id": "nexdatawork_demo_agent", "model_id": "framework_langgraph_agent", "version_id": "1.0.0", "policy_id": "hitl_and_pricing_policy", "policy_version": "1.0", "llm_model": "gpt-4o-mini", "task_type": "te_pricing", "timestamps": {"created_at": "2026-02-27T08:20:59+00:00"}, "decision": "Draft", "result": {"raw_text": "### Suggested Prices\n- **Presale Price**: $41.99\n- **Retail Price**: $51.99\n\n### Policy Checks Status\n- **Presale >= 7 * COGS**: **False** (The presale price does not meet the required minimum based on COGS)\n- **Retail > Presale**: **True** (The retail price is greater than the presale price)\n\n### Note on Demand Model Accuracy\nTo make the demand model more accurate, we need to replace the placeholder values for alpha and beta with real presale conversion rates or fitted demand model data. This will help in better predicting demand based on pricing strategies.\n\n### Benchmark Information\n- **Placeholder Competitors**:\n  - Smart Plug: TP-Link Kasa\n  - Smart Plug: Amazon Smart Plug\n  - In-Wall Outlet: Leviton Decora Smart\n  - Premium: Eve (Matter/Thread)\n\n**Limitations**: The benchmark data is a placeholder and should be verified with real market data.", "error": null}, "evidence": {"steps": [{"step_id": "step_20260227T082059Z_d4dbe67e", "name": "memory_scope", "started_at": "2026-02-27T08:20:59+00:00", "ended_at": "2026-02-27T08:20:59+00:00", "duration_ms": 0, "inputs": {"thread_id": "demo_thread"}, "outputs": {"checkpointer_kind": "sqlite"}, "evidence": {"note": "Memory is keyed by thread_id via LangGraph checkpointer."}, "error": null}, {"step_id": "step_20260227T082106Z_e1ccf5d1", "name": "agent_invoke", "started_at": "2026-02-27T08:21:06+00:00", "ended_at": "2026-02-27T08:21:06+00:00", "duration_ms": 7382, "inputs": {"task_type": "te_pricing"}, "outputs": {"raw_text_preview": "### Suggested Prices\n- **Presale Price**: $41.99\n- **Retail Price**: $51.99\n\n### Policy Checks Status\n- **Presale >= 7 * COGS**: **False** (The presale price does not meet the required minimum based on COGS)\n- **Retail > Presale**: **True** (The retail price is greater than the presale price)\n\n### Note on Demand Model Accuracy\nTo make the demand model more accurate, we need to replace the placeholder values for alpha and beta with real presale conversion rates or fitted demand model data. This will help in better predicting demand based on pricing strategies.\n\n### Benchmark Information\n- **Placeholder Competitors**:\n  - Smart Plug: TP-Link Kasa\n  - Smart Plug: Amazon Smart Plug\n  - In-Wall Outlet: Leviton Decora Smart\n  - Premium: Eve (Matter/Thread)\n\n**Limitations**: The benchmark data is a placeholder and should be verified with real market data."}, "evidence": {"llm_model": "gpt-4o-mini"}, "error": null}]}}
+{"run_id": "run_20260227T082224Z_6b27b255", "agent_id": "nexdatawork_demo_agent", "model_id": "framework_langgraph_agent", "version_id": "1.0.0", "policy_id": "hitl_and_pricing_policy", "policy_version": "1.0", "llm_model": "gpt-4o-mini", "task_type": "te_pricing", "timestamps": {"created_at": "2026-02-27T08:22:24+00:00"}, "decision": "Draft", "result": {"raw_text": "### Suggested Prices\n- **Presale Price**: $41.99\n- **Retail Price**: $59.99\n\n### Policy Checks Status\n- **Presale >= 7 * COGS**: **False** (The presale price does not meet the required minimum based on COGS)\n- **Retail > Presale**: **True** (The retail price is greater than the presale price)\n\n### Note on Demand Model Accuracy\nTo improve the accuracy of the demand model, we need to replace the placeholder values for alpha and beta with actual presale conversion rates or fitted demand model data. This will enhance our ability to predict demand based on pricing strategies.\n\n### Benchmark Information\n- **Placeholder Competitors**:\n  - Smart Plug: TP-Link Kasa\n  - Smart Plug: Amazon Smart Plug\n  - In-Wall Outlet: Leviton Decora Smart\n  - Premium: Eve (Matter/Thread)\n\n**Limitations**: The benchmark data is a placeholder and should be verified with real market data.", "error": null}, "evidence": {"steps": [{"step_id": "step_20260227T082224Z_7ad1d6de", "name": "memory_scope", "started_at": "2026-02-27T08:22:24+00:00", "ended_at": "2026-02-27T08:22:24+00:00", "duration_ms": 0, "inputs": {"thread_id": "demo_thread"}, "outputs": {"checkpointer_kind": "sqlite"}, "evidence": {"note": "Memory is keyed by thread_id via LangGraph checkpointer."}, "error": null}, {"step_id": "step_20260227T082231Z_a15bc842", "name": "agent_invoke", "started_at": "2026-02-27T08:22:31+00:00", "ended_at": "2026-02-27T08:22:31+00:00", "duration_ms": 6833, "inputs": {"task_type": "te_pricing"}, "outputs": {"raw_text_preview": "### Suggested Prices\n- **Presale Price**: $41.99\n- **Retail Price**: $59.99\n\n### Policy Checks Status\n- **Presale >= 7 * COGS**: **False** (The presale price does not meet the required minimum based on COGS)\n- **Retail > Presale**: **True** (The retail price is greater than the presale price)\n\n### Note on Demand Model Accuracy\nTo improve the accuracy of the demand model, we need to replace the placeholder values for alpha and beta with actual presale conversion rates or fitted demand model data. This will enhance our ability to predict demand based on pricing strategies.\n\n### Benchmark Information\n- **Placeholder Competitors**:\n  - Smart Plug: TP-Link Kasa\n  - Smart Plug: Amazon Smart Plug\n  - In-Wall Outlet: Leviton Decora Smart\n  - Premium: Eve (Matter/Thread)\n\n**Limitations**: The benchmark data is a placeholder and should be verified with real market data."}, "evidence": {"llm_model": "gpt-4o-mini"}, "error": null}]}}

framework_demo_v2.py → framework_demo_a.py

@@ -524,7 +524,7 @@ def build_gradio_app():
     def view_logs(n):
         return json.dumps(LOGGER.tail(int(n)), indent=2)
 
-    with gr.Blocks(title="Framework Demo (LangGraph + Traceable)") as demo:
+    with gr.Blocks(title="Demo A") as demo:
         gr.Markdown(
             "## Framework Demo (LangGraph + Traceable)\n"
             "- FinTech tab: single-case credit risk + HITL routing\n"
@@ -585,8 +585,10 @@ def build_gradio_app():
 
 def main():
     demo = build_gradio_app()
-    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")))
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860"), shared=True))
 
 
 if __name__ == "__main__":
     main()
+
+# http://127.0.0.1:7860/

framework_demo_b.py

@@ -0,0 +1,561 @@
+"""
+LangGraph + LangChain Framework Demo (Stateful + Traceable) with OpenAI
+
+This version is closer to LangChain/LangGraph "agent + memory" patterns:
+- LangGraph ReAct agent (tool-calling) with short-term memory via checkpointer (thread_id)
+- Traceable run logs: run_id, model_id, version_id, policy_id, step traces, evidence
+- Two business workflows:
+  1) FinTech credit risk demo (single case) + HITL policy routing
+  2) TE consumer product pricing (presale + retail) + constraint checks + benchmark draft (LLM, no web)
+
+Gradio:
+- Tab 1: FinTech (form -> agent decides tools -> structured output + explanation)
+- Tab 2: TE Pricing (form -> agent decides tools -> structured output + explanation)
+- Tab 3: Logs (tail)
+
+Hugging Face:
+- Rename this file to app.py
+- Use requirements_langgraph.txt as requirements.txt
+- Add OPENAI_API_KEY in Space secrets
+
+Security:
+- This file redacts API keys from logs and UI outputs.
+
+Note:
+- "Benchmark research" here is AI-generated only. No browsing. Treat as draft until verified.
+
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+import uuid
+import sqlite3
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+# =========================
+# IDs + versions (traceable)
+# =========================
+
+AGENT_ID = os.getenv("AGENT_ID", "nexdatawork_demo_agent")
+MODEL_ID = os.getenv("MODEL_ID", "framework_langgraph_agent")
+VERSION_ID = os.getenv("VERSION_ID", "1.0.0")
+
+POLICY_ID = os.getenv("POLICY_ID", "hitl_and_pricing_policy")
+POLICY_VERSION = os.getenv("POLICY_VERSION", "1.0")
+
+LLM_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+# Artifacts for HF Spaces
+DATA_DIR = Path(os.getenv("DATA_DIR", "./data"))
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+RUN_LOG_PATH = DATA_DIR / os.getenv("RUN_LOG_PATH", "run_logs.jsonl")
+CHECKPOINT_PATH = DATA_DIR / os.getenv("CHECKPOINT_PATH", "checkpoints.sqlite")
+
+# FinTech policy knobs
+RISK_THRESHOLD = float(os.getenv("RISK_THRESHOLD", "0.50"))
+BORDER_BAND = float(os.getenv("BORDER_BAND", "0.05"))
+HIGH_IMPACT_AMOUNT = float(os.getenv("HIGH_IMPACT_AMOUNT", "1000000"))
+
+# TE pricing defaults
+DEFAULT_COGS = float(os.getenv("DEFAULT_COGS", "6"))
+DEFAULT_LANDED = float(os.getenv("DEFAULT_LANDED", "10"))
+DEFAULT_PRESALE_MULT = float(os.getenv("DEFAULT_PRESALE_MULT", "7"))
+DEFAULT_PRESALE_DISCOUNT = float(os.getenv("DEFAULT_PRESALE_DISCOUNT", "0.20"))
+DEFAULT_PRICE_GRID = [x for x in range(42, 121, 1)]  # 42..120 (demo grid)
+
+
+# =========================
+# Helpers
+# =========================
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+def new_id(prefix: str) -> str:
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return f"{prefix}_{ts}_{uuid.uuid4().hex[:8]}"
+
+def run_metadata(task_type: str) -> Dict[str, Any]:
+    return {
+        "run_id": new_id("run"),
+        "agent_id": AGENT_ID,
+        "model_id": MODEL_ID,
+        "version_id": VERSION_ID,
+        "policy_id": POLICY_ID,
+        "policy_version": POLICY_VERSION,
+        "llm_model": LLM_MODEL,
+        "task_type": task_type,
+        "timestamps": {"created_at": utc_now()},
+    }
+
+
+# =========================
+# Redaction (API key safety)
+# =========================
+
+_API_KEY_PATTERN = re.compile(r"sk-[A-Za-z0-9_\-]{20,}")
+
+def redact_text(s: str) -> str:
+    if not isinstance(s, str):
+        return s
+    return _API_KEY_PATTERN.sub("sk-REDACTED", s)
+
+def redact(obj: Any) -> Any:
+    if isinstance(obj, str):
+        return redact_text(obj)
+    if isinstance(obj, list):
+        return [redact(x) for x in obj]
+    if isinstance(obj, dict):
+        return {k: redact(v) for k, v in obj.items()}
+    return obj
+
+
+# =========================
+# Traceable logs
+# =========================
+
+@dataclass
+class StepTrace:
+    step_id: str
+    name: str
+    started_at: str
+    ended_at: str
+    duration_ms: int
+    inputs: Dict[str, Any] = field(default_factory=dict)
+    outputs: Dict[str, Any] = field(default_factory=dict)
+    evidence: Dict[str, Any] = field(default_factory=dict)
+    error: Optional[str] = None
+
+class TraceLogger:
+    def __init__(self, path: Path):
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def log(self, payload: Dict[str, Any]) -> None:
+        payload = redact(payload)
+        with self.path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+    def tail(self, n: int = 30) -> List[Dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        lines = self.path.read_text(encoding="utf-8").splitlines()
+        out: List[Dict[str, Any]] = []
+        for ln in lines[-n:]:
+            try:
+                out.append(json.loads(ln))
+            except Exception:
+                continue
+        return out
+
+LOGGER = TraceLogger(RUN_LOG_PATH)
+
+
+# =========================
+# Deterministic "model tools" (evidence-friendly)
+# =========================
+
+def fintech_score_tool(income: float, debt: float, credit_score: int) -> Dict[str, Any]:
+    """
+    Baseline, interpretable risk score:
+    risk = 0.6*(debt/income) + 0.4*((850-credit_score)/850)
+    """
+    if income <= 0:
+        raise ValueError("income must be > 0")
+    if debt < 0:
+        raise ValueError("debt must be >= 0")
+    if not (300 <= credit_score <= 850):
+        raise ValueError("credit_score must be between 300 and 850")
+
+    dti = debt / income
+    gap = (850 - credit_score) / 850
+    risk = (0.6 * dti) + (0.4 * gap)
+
+    return {
+        "risk_score_pd": float(risk),
+        "intermediates": {"debt_to_income": float(dti), "score_gap": float(gap)},
+        "formula": "risk = 0.6*(debt/income) + 0.4*((850-credit_score)/850)",
+    }
+
+def hitl_policy(risk_score_pd: float, requested_amount: float) -> Dict[str, Any]:
+    """
+    HITL gating:
+    - High impact -> review
+    - High risk -> review
+    - Borderline -> review
+    - Else -> draft
+    """
+    thr = RISK_THRESHOLD
+    band = BORDER_BAND
+    hi = requested_amount >= HIGH_IMPACT_AMOUNT
+
+    if hi:
+        return {"decision": "Needs Human Review", "reason": "HIGH_IMPACT_CASE", "threshold": thr, "band": band}
+    if risk_score_pd >= (thr + band):
+        return {"decision": "Needs Human Review", "reason": "HIGH_RISK", "threshold": thr, "band": band}
+    if (thr - band) <= risk_score_pd < (thr + band):
+        return {"decision": "Needs Human Review", "reason": "BORDERLINE_SCORE", "threshold": thr, "band": band}
+    return {"decision": "Decision Draft", "reason": "LOW_RISK", "threshold": thr, "band": band}
+
+def te_pricing_tool(
+    cogs: float,
+    landed: float,
+    presale_mult: float,
+    discount: float,
+    alpha: float = 120.0,
+    beta: float = 0.08,
+) -> Dict[str, Any]:
+    """
+    Consumer product pricing demo (predictive modeling placeholder):
+    - Demand curve placeholder: demand = alpha * exp(-beta * price)
+    - Objective: maximize (price - landed) * demand across a grid
+    - Constraint: presale >= presale_mult * cogs, and presale >= 7*cogs (company rule)
+    - Retail: retail = presale / (1 - discount), retail > presale
+    """
+    if cogs <= 0:
+        raise ValueError("cogs must be > 0")
+    if landed <= 0:
+        raise ValueError("landed must be > 0")
+    if presale_mult < 1:
+        raise ValueError("presale_mult must be >= 1")
+    if not (0.0 < discount < 0.9):
+        raise ValueError("discount must be in (0, 0.9)")
+
+    floor = presale_mult * cogs
+    grid = [p for p in DEFAULT_PRICE_GRID if p >= floor]
+
+    # exp without extra deps
+    def exp(x: float) -> float:
+        return float((2.718281828459045) ** x)
+
+    best = None
+    for p in grid:
+        demand = float(alpha * exp(-beta * p))
+        profit = (p - landed) * demand
+        if best is None or profit > best["objective_profit"]:
+            best = {"presale": float(p), "demand": float(demand), "objective_profit": float(profit)}
+
+    presale = float(best["presale"]) if best else float(floor)
+    retail = presale / (1.0 - discount)
+
+    # round to .99
+    def as_99(x: float) -> float:
+        v = round(x)
+        return float(f"{max(v, 1) - 0.01:.2f}")
+
+    presale = as_99(presale)
+    retail = as_99(retail)
+
+    checks = {
+        "presale_ge_floor": bool(presale >= floor),
+        "presale_ge_7xcogs": bool(presale >= 7.0 * cogs),
+        "retail_gt_presale": bool(retail > presale),
+    }
+
+    return {
+        "inputs": {"cogs": cogs, "landed": landed, "presale_mult": presale_mult, "discount": discount, "alpha": alpha, "beta": beta},
+        "presale_price": presale,
+        "retail_price": retail,
+        "unit_margin_presale": presale - landed,
+        "unit_margin_retail": retail - landed,
+        "optimization": best,
+        "policy_checks": checks,
+        "demand_model": "alpha * exp(-beta * price) (placeholder)",
+        "notes": "Replace alpha/beta with real presale conversion or fitted demand model.",
+    }
+
+def te_benchmark_placeholder() -> Dict[str, Any]:
+    """
+    No browsing in this demo. Provide a safe placeholder list.
+    The OpenAI agent can draft an unverified benchmark list (marked as draft).
+    """
+    return {
+        "benchmark_items": [
+            {"category": "smart_plug", "brand": "TP-Link Kasa"},
+            {"category": "smart_plug", "brand": "Amazon Smart Plug"},
+            {"category": "in_wall_outlet", "brand": "Leviton Decora Smart"},
+            {"category": "premium", "brand": "Eve (Matter/Thread)"},
+        ],
+        "limitations": "Placeholder only. Verify with real market data.",
+    }
+
+
+# =========================
+# LangChain tools (for ReAct agent)
+# =========================
+
+def build_tools():
+    from langchain_core.tools import tool
+
+    @tool("fintech_score")
+    def fintech_score(income: float, debt: float, credit_score: int) -> str:
+        """Compute a baseline risk score (PD) with intermediates. Returns JSON string."""
+        out = fintech_score_tool(income, debt, credit_score)
+        return json.dumps(out)
+
+    @tool("hitl_route")
+    def hitl_route(score_pd: float, requested_amount: float) -> str:
+        """Apply HITL policy routing. Returns JSON string."""
+        out = hitl_policy(score_pd, requested_amount)
+        return json.dumps(out)
+
+    @tool("te_pricing")
+    def te_pricing(cogs: float, landed: float, presale_mult: float, discount: float) -> str:
+        """Compute presale + retail pricing under constraints. Returns JSON string."""
+        out = te_pricing_tool(cogs, landed, presale_mult, discount)
+        return json.dumps(out)
+
+    @tool("te_benchmark_placeholder")
+    def te_benchmark() -> str:
+        """Return a placeholder competitor benchmark list. Returns JSON string."""
+        return json.dumps(te_benchmark_placeholder())
+
+    return [fintech_score, hitl_route, te_pricing, te_benchmark]
+
+
+# =========================
+# LangGraph agent with memory (thread_id)
+# =========================
+
+def build_checkpointer():
+    """
+    Use SQLite checkpointer if available; otherwise memory.
+    We use SqliteSaver(conn) to avoid context-manager issues.
+    """
+    try:
+        from langgraph.checkpoint.sqlite import SqliteSaver
+        conn = sqlite3.connect(str(CHECKPOINT_PATH), check_same_thread=False)
+        return SqliteSaver(conn), "sqlite"
+    except Exception:
+        from langgraph.checkpoint.memory import InMemorySaver
+        return InMemorySaver(), "memory"
+
+CHECKPOINTER, CHECKPOINTER_KIND = build_checkpointer()
+
+def build_agent():
+    """
+    Create a tool-calling ReAct agent with memory.
+    This follows the LangGraph "add memory" pattern using a checkpointer keyed by thread_id.
+    """
+    from langchain_openai import ChatOpenAI
+
+    llm = ChatOpenAI(model=LLM_MODEL, temperature=0)
+
+    tools = build_tools()
+
+    # Compatibility: create_react_agent moved across versions.
+    try:
+        from langgraph.prebuilt import create_react_agent  # older path
+        agent = create_react_agent(llm, tools, checkpointer=CHECKPOINTER)
+        return agent
+    except Exception:
+        # Newer versions may not have prebuilt; fallback to langchain.agents
+        from langchain.agents import create_react_agent as lc_create_react_agent
+        agent = lc_create_react_agent(llm, tools)
+        return agent
+
+AGENT = None
+
+def get_agent():
+    global AGENT
+    if AGENT is None:
+        AGENT = build_agent()
+    return AGENT
+
+
+# =========================
+# Agent runner (traceable wrapper)
+# =========================
+
+def invoke_agent(thread_id: str, task_type: str, user_prompt: str) -> Dict[str, Any]:
+    """
+    Run the agent under a thread_id, record a traceable payload, return payload.
+    """
+    meta = run_metadata(task_type)
+    steps: List[StepTrace] = []
+
+    # Step: memory touch (invoke a noop by reading state indirectly)
+    # We rely on checkpointer in agent; we still record thread_id + checkpointer kind as evidence.
+    steps.append(StepTrace(
+        step_id=new_id("step"),
+        name="memory_scope",
+        started_at=utc_now(),
+        ended_at=utc_now(),
+        duration_ms=0,
+        inputs={"thread_id": thread_id},
+        outputs={"checkpointer_kind": CHECKPOINTER_KIND},
+        evidence={"note": "Memory is keyed by thread_id via LangGraph checkpointer."},
+    ))
+
+    agent = get_agent()
+
+    t0 = time.time()
+    err = None
+    raw = ""
+    try:
+        config = {"configurable": {"thread_id": thread_id}}
+        result = agent.invoke({"messages": [{"role": "user", "content": user_prompt}]}, config=config)
+        raw = result["messages"][-1].content if result and "messages" in result else ""
+        raw = redact_text(raw)
+    except Exception as e:
+        err = redact_text(str(e))
+
+    steps.append(StepTrace(
+        step_id=new_id("step"),
+        name="agent_invoke",
+        started_at=utc_now(),
+        ended_at=utc_now(),
+        duration_ms=int((time.time() - t0) * 1000),
+        inputs={"task_type": task_type},
+        outputs={"raw_text_preview": raw[:2000]},
+        error=err,
+        evidence={"llm_model": LLM_MODEL},
+    ))
+
+    payload = {
+        **meta,
+        "decision": "Needs Human Review" if err else "Draft",
+        "result": {"raw_text": raw, "error": err},
+        "evidence": {"steps": [asdict(s) for s in steps]},
+    }
+
+    LOGGER.log(payload)
+    return redact(payload)
+
+
+# =========================
+# Prompt templates (keep it simple + tool-focused)
+# =========================
+
+def fintech_prompt(income: float, debt: float, credit_score: int, requested_amount: float) -> str:
+    return f"""
+You are running the FinTech credit risk demo.
+Use tools in this order:
+1) fintech_score(income, debt, credit_score)
+2) hitl_route(score_pd, requested_amount)
+
+Then return:
+- A short decision summary (Decision Draft vs Needs Human Review) and the reason.
+- Include the tool JSON outputs in the response (copy them).
+Inputs:
+income={income}
+debt={debt}
+credit_score={credit_score}
+requested_amount={requested_amount}
+""".strip()
+
+def te_pricing_prompt(cogs: float, landed: float, mult: float, discount: float) -> str:
+    return f"""
+You are running the TE pricing demo (consumer product use case).
+Constraints:
+- presale >= 7 * COGS
+- retail > presale
+Use tools:
+1) te_pricing(cogs, landed, presale_mult, discount)
+2) te_benchmark_placeholder()
+
+Then return:
+- Suggested presale and retail prices (from tool output)
+- Policy checks status
+- A short note on what data we need to make the demand model more accurate
+Inputs:
+cogs={cogs}
+landed={landed}
+presale_mult={mult}
+discount={discount}
+""".strip()
+
+
+# =========================
+# Gradio UI
+# =========================
+
+def build_gradio_app():
+    import gradio as gr
+
+    def run_fintech(income, debt, credit_score, requested_amount, thread_id):
+        prompt = fintech_prompt(float(income), float(debt), int(credit_score), float(requested_amount))
+        payload = invoke_agent(thread_id=str(thread_id), task_type="fintech_credit_risk", user_prompt=prompt)
+        return payload["run_id"], json.dumps(payload, indent=2)
+
+    def run_te(cogs, landed, mult, discount, thread_id):
+        prompt = te_pricing_prompt(float(cogs), float(landed), float(mult), float(discount))
+        payload = invoke_agent(thread_id=str(thread_id), task_type="te_pricing", user_prompt=prompt)
+        return payload["run_id"], json.dumps(payload, indent=2)
+
+    def view_logs(n):
+        return json.dumps(LOGGER.tail(int(n)), indent=2)
+
+    with gr.Blocks(title="Demo B") as demo:
+        gr.Markdown(
+            "## LangGraph Memory + Traceable Demo\n"
+            "This demo shows a LangGraph/LangChain agent with memory (thread_id) and traceable run logs.\n"
+            f"- Checkpointer: **{CHECKPOINTER_KIND}**\n"
+        )
+
+        with gr.Row():
+            thread_id = gr.Textbox(value="demo_thread", label="thread_id (memory scope)")
+            gr.Markdown(f"Logs: `{RUN_LOG_PATH}`  \nCheckpoints: `{CHECKPOINT_PATH}`")
+
+        with gr.Tabs():
+            with gr.Tab("FinTech: Credit Risk Demo"):
+                gr.Markdown("Simple form. Agent calls tools and returns a traceable payload.")
+                with gr.Row():
+                    income = gr.Number(value=75000, label="Income (annual)")
+                    debt = gr.Number(value=30000, label="Debt (total)")
+                    credit_score = gr.Number(value=680, label="Credit score (300-850)")
+                    requested_amount = gr.Number(value=250000, label="Requested amount")
+                btn = gr.Button("Run FinTech agent")
+                out_run = gr.Textbox(label="run_id")
+                out_json = gr.Textbox(label="traceable output JSON", lines=22)
+                btn.click(fn=run_fintech, inputs=[income, debt, credit_score, requested_amount, thread_id], outputs=[out_run, out_json])
+
+            with gr.Tab("TE: Pricing Demo"):
+                gr.Markdown(
+                    "Consumer product use case. Agent computes presale + retail under constraints and shows benchmark placeholder.\n"
+                    "For a real benchmark, replace placeholder with curated market dataset (or verified research)."
+                )
+                with gr.Row():
+                    cogs = gr.Number(value=DEFAULT_COGS, label="COGS per unit")
+                    landed = gr.Number(value=DEFAULT_LANDED, label="Landed cost per unit")
+                    mult = gr.Number(value=DEFAULT_PRESALE_MULT, label="Presale floor multiplier (>=7)")
+                    discount = gr.Slider(0.10, 0.40, value=DEFAULT_PRESALE_DISCOUNT, step=0.05, label="Presale discount vs retail")
+                btn2 = gr.Button("Run TE pricing agent")
+                out_run2 = gr.Textbox(label="run_id")
+                out_json2 = gr.Textbox(label="traceable output JSON", lines=22)
+                btn2.click(fn=run_te, inputs=[cogs, landed, mult, discount, thread_id], outputs=[out_run2, out_json2])
+
+            with gr.Tab("Trace Logs"):
+                n = gr.Slider(10, 200, value=30, step=10, label="show last N runs")
+                btn3 = gr.Button("Refresh logs")
+                logs_out = gr.Textbox(lines=24, label="logs (JSON list)")
+                btn3.click(fn=view_logs, inputs=[n], outputs=[logs_out])
+
+        gr.Markdown(
+            "### Hugging Face deploy\n"
+            "1) Rename this file to `app.py`\n"
+            "2) Use the provided requirements file as `requirements.txt`\n"
+            "3) Add `OPENAI_API_KEY` in Space Secrets\n\n"
+            "Note: I can't provide a Hugging Face account for org access. Use your own HF username and ask to be added."
+        )
+
+    return demo
+
+
+def main():
+    demo = build_gradio_app()
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")))
+
+
+if __name__ == "__main__":
+    main()
+
+# http://localhost:7860 

requirements_demo_b.txt

@@ -0,0 +1,7 @@
+gradio>=4.0.0
+langgraph>=1.0.0
+langgraph-checkpoint>=1.0.0
+langgraph-checkpoint-sqlite>=1.0.0
+langchain-core>=0.2.0
+langchain-openai>=0.1.0
+openai>=1.0.0