Update app.py

app.py

@@ -445,64 +445,58 @@ def plan_explainer_tool(plan_json: str) -> str:
 def bottleneck_search_tool(forecast_json: str, policy_json: str = "") -> str:
     """
     Find the best practical lever to relax (within ~1 month) via small scenario probes.
+    Supports resource overtime, RM expedite (cap), and demand_lift (promo ROI-checked).
 
     Args:
         forecast_json (str): JSON from forecast_tool (first month per SKU used).
-        policy_json (str): Optional JSON with relaxable levers and costs.
-                           Defaults include overtime and RM expedite; blocks factory expansion.
+        policy_json (str): Optional JSON with levers and costs.
 
     Returns:
-        str: JSON {"status":"OK","recommendations":[{lever, recommended, est_profit_lift, est_net_gain, rationale}]}
+        str: JSON {"status":"OK","diagnostics":{...},"recommendations":[...]}
     """
+    import json, numpy as np
+    from scipy.optimize import linprog
+
     # --- Defaults (edit to your reality) ---
     policy = {
-        "R1_overtime": {"type":"resource","target":"R1","step":10.0,"max_delta":80.0,"unit_cost":600.0},
-        "R2_overtime": {"type":"resource","target":"R2","step":10.0,"max_delta":40.0,"unit_cost":800.0},
+        "R1_overtime":   {"type":"resource","target":"R1","step":10.0,"max_delta":80.0,"unit_cost":600.0},
+        "R2_overtime":   {"type":"resource","target":"R2","step":10.0,"max_delta":40.0,"unit_cost":800.0},
         "RM_A_expedite": {"type":"rm_expedite","target":"RM_A","step":200.0,"max_delta":1500.0,"unit_premium":8.0},
         "RM_B_expedite": {"type":"rm_expedite","target":"RM_B","step":100.0,"max_delta":800.0,"unit_premium":12.0},
         "Factory_expansion": {"type":"blocked","reason":"Not relaxable within 1 month"}
+        # You can add demand levers via policy_json:
+        # "promo_FG100": {"type":"demand_lift","target":"FG100","step":100,"max_delta":600,"unit_cost":10}
     }
     if policy_json:
-        try:
-            policy.update(json.loads(policy_json))
-        except Exception:
-            pass
-
-    # --- 1) Baseline solve ---
-    base_plan = json.loads(optimize_supply_tool(forecast_json))
-    if base_plan.get("status") != "OPTIMAL":
-        return json.dumps({"status":"FAILED","message":"Baseline plan not optimal."})
-    base_profit = float(base_plan["kpis"]["Profit"])
-
-    # --- 2) Helper to run a perturbed solve ---
-    def run_with(delta_map):
-        from scipy.optimize import linprog
+        try: policy.update(json.loads(policy_json))
+        except Exception: pass
 
-        rows = json.loads(forecast_json)
-        demand = {}
-        for r in rows:
-            p = r["product_id"]
-            if p not in demand:
-                demand[p] = float(r["forecast_qty"])
-        P = sorted(demand.keys()) or ["FG100","FG200"]
-        price = {"FG100":98.0,"FG200":120.0}
-        conv  = {"FG100":12.5,"FG200":15.0}
-        r1    = {"FG100":0.03,"FG200":0.05}
-        r2    = {"FG100":0.02,"FG200":0.01}
-        RMs = ["RM_A","RM_B"]
-        rm_cost = {"RM_A":20.0,"RM_B":30.0}
-        rm_start = {"RM_A":1000.0,"RM_B":100.0}
-        rm_cap   = {"RM_A":5000.0,"RM_B":5000.0}
-        bom = {"FG100":{"RM_A":0.8,"RM_B":0.204},"FG200":{"RM_A":1.0,"RM_B":0.1}}
-
-        # Apply deltas
-        r1_cap = 320.0 + delta_map.get("R1_cap",0.0)
-        r2_cap = 480.0 + delta_map.get("R2_cap",0.0)
-        rm_cap_adj = {
-            "RM_A": rm_cap["RM_A"] + delta_map.get("RM_A_cap",0.0),
-            "RM_B": rm_cap["RM_B"] + delta_map.get("RM_B_cap",0.0),
-        }
+    # --- Problem primitives (same as your optimizer) ---
+    rows = json.loads(forecast_json)
+    demand = {}
+    for r in rows:
+        p = r["product_id"]
+        if p not in demand:
+            demand[p] = float(r["forecast_qty"])
+    P = sorted(demand.keys()) or ["FG100","FG200"]
 
+    price = {"FG100":98.0,"FG200":120.0}
+    conv  = {"FG100":12.5,"FG200":15.0}
+    r1    = {"FG100":0.03,"FG200":0.05}
+    r2    = {"FG100":0.02,"FG200":0.01}
+    RMs = ["RM_A","RM_B"]
+    rm_cost = {"RM_A":20.0,"RM_B":30.0}
+    rm_start = {"RM_A":1000.0,"RM_B":100.0}
+    rm_cap   = {"RM_A":5000.0,"RM_B":5000.0}
+    bom = {"FG100":{"RM_A":0.8,"RM_B":0.204},"FG200":{"RM_A":1.0,"RM_B":0.1}}
+    r1_cap0, r2_cap0 = 320.0, 480.0
+
+    # Helpful unit margin for demand_lift (approx variable cost)
+    unit_var_cost = {p: conv[p] + sum(bom[p].get(rm,0.0)*rm_cost[rm] for rm in RMs) for p in P}
+    unit_margin   = {p: price[p] - unit_var_cost[p] for p in P}
+
+    # --- LP builder (inner solve) ---
+    def solve(dem, r1_cap, r2_cap, rm_cap_adj):
         nP, nR = len(P), len(RMs)
         pidx = {p:i for i,p in enumerate(P)}; ridx = {r:i for i,r in enumerate(RMs)}
         def i_prod(p): return pidx[p]
@@ -510,6 +504,7 @@ def bottleneck_search_tool(forecast_json: str, policy_json: str = "") -> str:
         def i_einv(p): return 2*nP + pidx[p]
         def i_pur(r):  return 3*nP + ridx[r]
         def i_einr(r): return 3*nP + nR + ridx[r]
+
         n_vars = 3*nP + 2*nR
         c = np.zeros(n_vars); bounds=[None]*n_vars
 
@@ -517,7 +512,7 @@ def bottleneck_search_tool(forecast_json: str, policy_json: str = "") -> str:
             c[i_prod(p)] += conv[p]
             c[i_sell(p)] -= price[p]
             bounds[i_prod(p)] = (0,None)
-            bounds[i_sell(p)] = (0,demand[p])
+            bounds[i_sell(p)] = (0, dem[p])
             bounds[i_einv(p)] = (0,None)
         for r in RMs:
             c[i_pur(r)]  += rm_cost[r]
@@ -543,54 +538,86 @@ def bottleneck_search_tool(forecast_json: str, policy_json: str = "") -> str:
             return None
         x = res.x
         def v(idx): return float(x[idx])
+
         revenue = sum(price[p]*v(i_sell(p)) for p in P)
         conv_cost = sum(conv[p]*v(i_prod(p)) for p in P)
         rm_purch_cost = sum(v(i_pur(r))*rm_cost[r] for r in RMs)
-        profit = revenue - conv_cost - rm_purch_cost
-        return profit
+        r1_used = sum(r1[p]*v(i_prod(p)) for p in P)
+        r2_used = sum(r2[p]*v(i_prod(p)) for p in P)
+        return {
+            "profit": revenue - conv_cost - rm_purch_cost,
+            "r1_used": r1_used, "r2_used": r2_used,
+        }
+
+    # Baseline
+    base = solve(demand, r1_cap0, r2_cap0, rm_cap.copy())
+    if base is None:
+        return json.dumps({"status":"FAILED","message":"Baseline infeasible."})
+    base_profit = float(base["profit"])
+    diag = {
+        "demand_met": True,  # sells hit demand ceiling in this model
+        "r1_slack": round(r1_cap0 - base["r1_used"], 2),
+        "r2_slack": round(r2_cap0 - base["r2_used"], 2),
+        "rm_caps_hit": {rm: False for rm in RMs}
+    }
+    # If everything is slack, tell the user plainly
+    all_slack = (diag["r1_slack"] > 1e-3 and diag["r2_slack"] > 1e-3)
 
-    # --- 3) Probe levers; compute net gain ---
+    # --- Probe levers ---
     recs = []
     for name, cfg in policy.items():
         if cfg.get("type") == "blocked":
             recs.append({"lever":name,"recommended":0,"est_profit_lift":0,"est_net_gain":0,
                          "rationale":cfg.get("reason","Not feasible in horizon")})
             continue
-        step = float(cfg["step"]); maxd = float(cfg["max_delta"])
-        best_gain = 0.0; best_delta = 0.0; best_profit_lift = 0.0
+
+        best_gain = 0.0; best_delta = 0.0; best_lift = 0.0
+        step = float(cfg.get("step",0)); maxd = float(cfg.get("max_delta",0))
         d = 0.0
         while d <= maxd + 1e-6:
-            delta_map = {}
+            dem = demand.copy()
+            r1_cap = r1_cap0; r2_cap = r2_cap0
+            rm_cap_adj = rm_cap.copy()
             relax_cost = 0.0
-            if cfg["type"] == "resource" and cfg["target"]=="R1":
-                delta_map["R1_cap"] = d; relax_cost = d * float(cfg["unit_cost"])
-            elif cfg["type"] == "resource" and cfg["target"]=="R2":
-                delta_map["R2_cap"] = d; relax_cost = d * float(cfg["unit_cost"])
-            elif cfg["type"] == "rm_expedite":
-                key = "RM_A_cap" if cfg["target"]=="RM_A" else "RM_B_cap"
-                delta_map[key] = d; relax_cost = d * float(cfg["unit_premium"])
+
+            t = cfg["type"]
+            if t == "resource" and cfg["target"] == "R1":
+                r1_cap += d; relax_cost = d * float(cfg["unit_cost"])
+            elif t == "resource" and cfg["target"] == "R2":
+                r2_cap += d; relax_cost = d * float(cfg["unit_cost"])
+            elif t == "rm_expedite":
+                key = "RM_A" if cfg["target"]=="RM_A" else "RM_B"
+                rm_cap_adj[key] = rm_cap[key] + d
+                relax_cost = d * float(cfg["unit_premium"])
+            elif t == "demand_lift":
+                sku = cfg["target"]
+                if sku in dem:
+                    dem[sku] = dem[sku] + d
+                    relax_cost = d * float(cfg["unit_cost"])
+                else:
+                    d += step; continue
             else:
                 d += step; continue
 
-            prof = run_with(delta_map)
-            if prof is None:
+            res = solve(dem, r1_cap, r2_cap, rm_cap_adj)
+            if res is None:
                 d += step; continue
-            lift = prof - base_profit
+            lift = float(res["profit"] - base_profit)
             net = lift - relax_cost
             if net > best_gain:
-                best_gain, best_delta, best_profit_lift = net, d, lift
+                best_gain, best_delta, best_lift = net, d, lift
             d += step
 
-        rationale = ("Beneficial at small Δ" if best_gain>0 else "No positive net gain within feasible range")
-        recs.append({"lever":name,"recommended":best_delta,"est_profit_lift":best_profit_lift,
-                     "est_net_gain":best_gain,"rationale":rationale})
+        rationale = ("Beneficial at small Δ" if best_gain>0 else
+                     ("Capacity not binding; try demand/cost levers" if all_slack else
+                      "No positive net gain within feasible range"))
+        recs.append({"lever":name,"recommended":round(best_delta,2),
+                     "est_profit_lift":round(best_lift,2),
+                     "est_net_gain":round(best_gain,2),
+                     "rationale":rationale})
 
     recs.sort(key=lambda r: r["est_net_gain"], reverse=True)
-    for r in recs:
-        for k in ["recommended","est_profit_lift","est_net_gain"]:
-            if r[k] is not None:
-                r[k] = round(float(r[k]), 2)
-    return json.dumps({"status":"OK","recommendations":recs})
+    return json.dumps({"status":"OK","diagnostics":diag,"recommendations":recs})
 
 # ==== Agent (end-to-end) ======================================================
 def make_agent():