Add input price and fix uncached input calculation

- Add Input price field ($/1M) loaded from litellm
- Calculate uncached_input = prompt - cache_read - cache_creation per instance
- Fix bug: sum uncached per-instance instead of from totals
- Add Uncached Input to all token/cost charts
- Show ✅/❌ indicators for all 4 price fields

app.py

@@ -250,7 +250,7 @@ def load_all_trajectories(folder: str) -> pd.DataFrame:
     return df
 
 
-def create_basic_histograms(df: pd.DataFrame, cache_read_price: float, cache_creation_price: float, completion_price: float):
+def create_basic_histograms(df: pd.DataFrame, input_price: float, cache_read_price: float, cache_creation_price: float, completion_price: float):
     if df.empty:
         return None, None, None, None, None
 
@@ -294,14 +294,17 @@ def create_basic_histograms(df: pd.DataFrame, cache_read_price: float, cache_cre
         font=dict(size=12),
     )
 
-    total_prompt = df["prompt_tokens"].sum()
     total_completion = df["completion_tokens"].sum()
     total_cache_read = df["cache_read_tokens"].sum()
     total_cache_creation = df["cache_creation_tokens"].sum()
+    # Uncached input = prompt - cache_read - cache_creation (per instance, then sum)
+    df_temp = df.copy()
+    df_temp["uncached_input"] = (df_temp["prompt_tokens"] - df_temp["cache_read_tokens"] - df_temp["cache_creation_tokens"]).clip(lower=0)
+    total_uncached_input = df_temp["uncached_input"].sum()
 
     token_data = pd.DataFrame({
-        "Token Type": ["Prompt", "Completion", "Cache Read", "Cache Creation"],
-        "Total Tokens": [total_prompt, total_completion, total_cache_read, total_cache_creation],
+        "Token Type": ["Uncached Input", "Cache Read", "Cache Creation", "Completion"],
+        "Total Tokens": [total_uncached_input, total_cache_read, total_cache_creation, total_completion],
     })
 
     fig_tokens = px.bar(
@@ -310,7 +313,7 @@ def create_basic_histograms(df: pd.DataFrame, cache_read_price: float, cache_cre
         y="Total Tokens",
         title="Total Tokens by Type",
         color="Token Type",
-        color_discrete_sequence=["#EF553B", "#AB63FA", "#19D3F3", "#FFA15A"],
+        color_discrete_sequence=["#EF553B", "#19D3F3", "#FFA15A", "#AB63FA"],
     )
     fig_tokens.update_layout(
         xaxis_title="Token Type",
@@ -327,14 +330,15 @@ def create_basic_histograms(df: pd.DataFrame, cache_read_price: float, cache_cre
         font=dict(size=12),
     )
 
-    # Cost by token type (prompt tokens not billed separately, included in cache)
-    cost_completion = total_completion * completion_price / 1e6
+    # Cost by token type
+    cost_uncached_input = total_uncached_input * input_price / 1e6
     cost_cache_read = total_cache_read * cache_read_price / 1e6
     cost_cache_creation = total_cache_creation * cache_creation_price / 1e6
+    cost_completion = total_completion * completion_price / 1e6
 
     cost_data = pd.DataFrame({
-        "Token Type": ["Completion", "Cache Read", "Cache Creation"],
-        "Cost ($)": [cost_completion, cost_cache_read, cost_cache_creation],
+        "Token Type": ["Uncached Input", "Cache Read", "Cache Creation", "Completion"],
+        "Cost ($)": [cost_uncached_input, cost_cache_read, cost_cache_creation, cost_completion],
     })
 
     fig_tokens_cost = px.bar(
@@ -343,7 +347,7 @@ def create_basic_histograms(df: pd.DataFrame, cache_read_price: float, cache_cre
         y="Cost ($)",
         title="Total Cost by Token Type ($)",
         color="Token Type",
-        color_discrete_sequence=["#AB63FA", "#19D3F3", "#FFA15A"],
+        color_discrete_sequence=["#EF553B", "#19D3F3", "#FFA15A", "#AB63FA"],
     )
     fig_tokens_cost.update_layout(
         xaxis_title="Token Type",
@@ -352,7 +356,7 @@ def create_basic_histograms(df: pd.DataFrame, cache_read_price: float, cache_cre
         margin=dict(l=40, r=20, t=40, b=40),
     )
 
-    total_cost = cost_completion + cost_cache_read + cost_cache_creation
+    total_cost = cost_uncached_input + cost_cache_read + cost_cache_creation + cost_completion
     fig_tokens_cost.add_annotation(
         text=f"Total: ${total_cost:.2f}",
         xref="paper", yref="paper",
@@ -362,9 +366,19 @@ def create_basic_histograms(df: pd.DataFrame, cache_read_price: float, cache_cre
 
     df_sorted = df.sort_values("cache_read_tokens", ascending=False).reset_index(drop=True)
     df_sorted["instance_idx"] = range(len(df_sorted))
+    # Uncached input = prompt - cache_read - cache_creation
+    df_sorted["uncached_input_tokens"] = (df_sorted["prompt_tokens"] - df_sorted["cache_read_tokens"] - df_sorted["cache_creation_tokens"]).clip(lower=0)
 
     fig_stacked = go.Figure()
 
+    fig_stacked.add_trace(go.Bar(
+        name="Uncached Input",
+        x=df_sorted["instance_idx"],
+        y=df_sorted["uncached_input_tokens"],
+        marker_color="#EF553B",
+        hovertemplate="Instance: %{x}<br>Uncached Input: %{y:,.0f}<extra></extra>",
+    ))
+
     fig_stacked.add_trace(go.Bar(
         name="Cache Read",
         x=df_sorted["instance_idx"],
@@ -401,19 +415,31 @@ def create_basic_histograms(df: pd.DataFrame, cache_read_price: float, cache_cre
     return fig_steps, fig_cost, fig_tokens, fig_tokens_cost, fig_stacked
 
 
-def create_cost_breakdown(df: pd.DataFrame, cache_read_price: float, cache_creation_price: float, completion_price: float):
+def create_cost_breakdown(df: pd.DataFrame, input_price: float, cache_read_price: float, cache_creation_price: float, completion_price: float):
     if df.empty:
         return None
 
     df_sorted = df.sort_values("cache_read_tokens", ascending=False).reset_index(drop=True)
     df_sorted["instance_idx"] = range(len(df_sorted))
 
+    # Uncached input = prompt - cache_read - cache_creation
+    df_sorted["uncached_input_tokens"] = (df_sorted["prompt_tokens"] - df_sorted["cache_read_tokens"] - df_sorted["cache_creation_tokens"]).clip(lower=0)
+
+    df_sorted["cost_uncached_input"] = df_sorted["uncached_input_tokens"] * input_price / 1e6
     df_sorted["cost_cache_read"] = df_sorted["cache_read_tokens"] * cache_read_price / 1e6
     df_sorted["cost_cache_creation"] = df_sorted["cache_creation_tokens"] * cache_creation_price / 1e6
     df_sorted["cost_completion"] = df_sorted["completion_tokens"] * completion_price / 1e6
 
     fig = go.Figure()
 
+    fig.add_trace(go.Bar(
+        name=f"Uncached Input (${input_price:.2f}/1M)",
+        x=df_sorted["instance_idx"],
+        y=df_sorted["cost_uncached_input"],
+        marker_color="#EF553B",
+        hovertemplate="Instance: %{x}<br>Cost: $%{y:.4f}<extra></extra>",
+    ))
+
     fig.add_trace(go.Bar(
         name=f"Cache Read (${cache_read_price:.2f}/1M)",
         x=df_sorted["instance_idx"],
@@ -439,6 +465,7 @@ def create_cost_breakdown(df: pd.DataFrame, cache_read_price: float, cache_creat
     ))
 
     total_cost = (
+        df_sorted["cost_uncached_input"].sum() +
         df_sorted["cost_cache_read"].sum() +
         df_sorted["cost_cache_creation"].sum() +
         df_sorted["cost_completion"].sum()
@@ -474,20 +501,21 @@ def extract_model_from_folder(folder: str) -> str:
     return folder
 
 
-def get_prices_for_folder(folder: str) -> tuple[float, float, float, str]:
-    """Get prices from litellm based on folder name. Returns (cache_read, cache_creation, completion, model_name)"""
+def get_prices_for_folder(folder: str) -> tuple[float, float, float, float, str]:
+    """Get prices from litellm based on folder name. Returns (input, cache_read, cache_creation, completion, model_name)"""
     model_hint = extract_model_from_folder(folder)
     if not model_hint:
-        return 0, 0, 0, ""
+        return 0, 0, 0, 0, ""
 
     prices = get_model_prices(model_hint)
     if prices:
+        input_price = prices.get("input_cost_per_token", 0) * 1e6
         cache_read = prices.get("cache_read_input_token_cost", 0) * 1e6
         cache_creation = prices.get("cache_creation_input_token_cost", 0) * 1e6
         completion = prices.get("output_cost_per_token", 0) * 1e6
-        return cache_read, cache_creation, completion, model_hint
+        return input_price, cache_read, cache_creation, completion, model_hint
 
-    return 0, 0, 0, model_hint
+    return 0, 0, 0, 0, model_hint
 
 
 def on_row_select(evt: gr.SelectData, df: pd.DataFrame):
@@ -496,6 +524,7 @@ def on_row_select(evt: gr.SelectData, df: pd.DataFrame):
             "", "", 
             gr.update(interactive=False), 
             gr.update(visible=False), 
+            gr.update(value=0, label="💲 Input"),
             gr.update(value=0, label="💲 Cache Read"),
             gr.update(value=0, label="💲 Cache Creation"),
             gr.update(value=0, label="💲 Completion"),
@@ -509,7 +538,7 @@ def on_row_select(evt: gr.SelectData, df: pd.DataFrame):
 
     show_analyze = check_trajectories_downloaded(folder)
 
-    cache_read, cache_creation, completion, model_hint = get_prices_for_folder(folder)
+    input_price, cache_read, cache_creation, completion, model_hint = get_prices_for_folder(folder)
 
     def price_update(value, name):
         if value > 0:
@@ -521,6 +550,7 @@ def on_row_select(evt: gr.SelectData, df: pd.DataFrame):
         folder, name, 
         gr.update(interactive=True), 
         gr.update(visible=show_analyze), 
+        price_update(input_price, "Input"),
         price_update(cache_read, "Cache Read"),
         price_update(cache_creation, "Cache Creation"),
         price_update(completion, "Completion"),
@@ -576,6 +606,7 @@ def build_app():
                 gr.Markdown("---")
                 gr.Markdown("### 💰 Token Prices ($/1M) · *[litellm](https://github.com/BerriAI/litellm/blob/main/model_prices_and_context_window.json)*")
                 detected_model = gr.Textbox(label="Detected Model", interactive=False)
+                price_input = gr.Number(label="💲 Input", value=0, precision=2)
                 price_cache_read = gr.Number(label="💲 Cache Read", value=0, precision=2)
                 price_cache_creation = gr.Number(label="💲 Cache Creation", value=0, precision=2)
                 price_completion = gr.Number(label="💲 Completion", value=0, precision=2)
@@ -583,7 +614,7 @@ def build_app():
         leaderboard_table.select(
             fn=on_row_select,
             inputs=[leaderboard_table],
-            outputs=[selected_folder, selected_name, download_btn, analyze_btn, price_cache_read, price_cache_creation, price_completion, detected_model],
+            outputs=[selected_folder, selected_name, download_btn, analyze_btn, price_input, price_cache_read, price_cache_creation, price_completion, detected_model],
         )
 
         download_btn.click(
@@ -592,7 +623,7 @@ def build_app():
             outputs=[download_status, analyze_btn],
         )
 
-        def load_and_analyze(folder, cache_read_price, cache_creation_price, completion_price):
+        def load_and_analyze(folder, input_price, cache_read_price, cache_creation_price, completion_price):
             empty_result = (
                 gr.update(visible=False),
                 None, None, None, None, None, None,
@@ -613,9 +644,9 @@ def build_app():
                 return
 
             fig_steps, fig_cost, fig_tokens, fig_tokens_cost, fig_stacked = create_basic_histograms(
-                df, cache_read_price, cache_creation_price, completion_price
+                df, input_price, cache_read_price, cache_creation_price, completion_price
             )
-            fig_cost_breakdown = create_cost_breakdown(df, cache_read_price, cache_creation_price, completion_price)
+            fig_cost_breakdown = create_cost_breakdown(df, input_price, cache_read_price, cache_creation_price, completion_price)
 
             yield (
                 gr.update(visible=True),
@@ -624,7 +655,7 @@ def build_app():
 
         analyze_btn.click(
             fn=load_and_analyze,
-            inputs=[selected_folder, price_cache_read, price_cache_creation, price_completion],
+            inputs=[selected_folder, price_input, price_cache_read, price_cache_creation, price_completion],
             outputs=[
                 analysis_section,
                 plot_steps, plot_cost, plot_tokens, plot_tokens_cost, plot_stacked, plot_cost_breakdown,