Spaces:
Running
Running
| """Agent panel: live tool-trace feed, budget meter, verdict banner, charts. | |
| Consumes typed v2 agent events (``token | step | tool_call | tool_result | | |
| final | usage``) from :func:`ui._compat.agent_run_stream`. Every tool call | |
| renders as a trace card — pending while running, then done with a wall-time | |
| ms bar scaled to the slowest call this turn and an expandable payload | |
| preview. The budget meter ticks live (steps / tool calls / score_week cap / | |
| ≈tokens) against the slider-chosen tool budget, and the final answer's | |
| "Best: …" contract line is lifted into a verdict banner. Any ``score_week`` | |
| payload in a tool result is charted straight into the week strip (the LLM | |
| never owns numbers), and **every answered turn ends with a visualisation | |
| matched to the question**: recommendation questions close on the | |
| recommended-scores chart — a region-sweep leaderboard, or a side-by-side | |
| compare when several spots were scored this turn (a deterministic engine | |
| sweep fills in when the agent never ranked); climate / seafloor / similar / | |
| explain questions get their rose, depth map, similarity bars or component | |
| split; anything else falls back to the viewed spot's own scored week. | |
| User controls in the bar: a "max tool calls" slider (the per-turn step | |
| budget; token + score_week caps scale with it) and chained State → Region | |
| dropdowns — page-one style, the State pick rewrites the Region choices — | |
| that anchor "where should I surf" sweeps. Both are plain component inputs — | |
| session state stays at exactly three ``gr.State`` objects. Skill comes | |
| from the lens panel's Skill filter — one skill, whole page. | |
| The BYO HF token box is session-only: the value is passed straight to the | |
| agent factory per turn, never stored, never logged. | |
| """ | |
| from __future__ import annotations | |
| import html | |
| import json | |
| import re | |
| import gradio as gr | |
| from ui import _compat as C | |
| from ui.charts import climate as climate_chart | |
| from ui.charts import seafloor as seafloor_chart | |
| from ui.charts import score as score_chart | |
| from ui.charts import strip as strip_chart | |
| from ui.contracts import AGENT_KEYS, fill | |
| _TOOL_ICONS = { | |
| "score_week": "⚙", "rank_region_week": "🏆", "explain_score": "🔍", | |
| "find_best_windows": "🕐", "find_spots": "🔎", "find_similar_spots": "🧭", | |
| "get_spot_knowledge": "📖", "get_climate_profile": "🌡", | |
| "get_seafloor_profile": "🪨", "get_session_brief": "🤿", | |
| "list_regions": "🗺", | |
| } | |
| _MEDALS = ["🥇", "🥈", "🥉"] | |
| _VERDICT_RE = re.compile(r"Best:\s*(.+)", re.IGNORECASE) | |
| # Query intent (deterministic, on the user's text only): which end-of-turn | |
| # chart matches the question. Scores charts are the house default; the | |
| # specialties jump the queue only when the question asks for them. | |
| _REC_RE = re.compile( | |
| r"\bwhere\s+(?:should|to|can|shall|could)\b" | |
| r"|\bbest\s+(?:spots?|breaks?|beaches?|places?)\b" | |
| r"|\brecommend|\brank\w*|\btop\s*\d+" | |
| r"|\bcompare|\bversus\b|\bvs\b" | |
| r"|\bshould\s+i\s+(?:surf|go|paddle)\b", re.IGNORECASE) | |
| _CLIMATE_RE = re.compile( | |
| r"\bclimate\b|\bmonthly\b|\bmonths?\b|winter|summer|autumn|spring\b" | |
| r"|\bswell\s+direction\b|\bwhen\s+to\s+go\b", re.IGNORECASE) | |
| _SEAFLOOR_RE = re.compile( | |
| r"\bseafloor\b|\bsea\s?floor\b|\bsea\s?bed\b|\bbathymetry\b|\bdepths?\b" | |
| r"|\bstructure\b|\bsandbar\b|\breef\b", re.IGNORECASE) | |
| _SIMILAR_RE = re.compile( | |
| r"\b(?:spots?|breaks?|beaches?)\s+like\b|\bsimilar\s+to\b" | |
| r"|\balternatives?\s+to\b|\bquieter\b", re.IGNORECASE) | |
| _EXPLAIN_RE = re.compile( | |
| r"\bwhy\b|\bexplain\w*|\bcomponent\w*|\bbreakdown\b", re.IGNORECASE) | |
| _SPECIALTY_RE = ( | |
| ("get_climate_profile", _CLIMATE_RE), | |
| ("get_seafloor_profile", _SEAFLOOR_RE), | |
| ("find_similar_spots", _SIMILAR_RE), | |
| ("explain_score", _EXPLAIN_RE), | |
| ) | |
| _STATE_CODES = { | |
| "NSW": "New South Wales", "QLD": "Queensland", "VIC": "Victoria", | |
| "WA": "Western Australia", "SA": "South Australia", "TAS": "Tasmania", | |
| } | |
| _EMPTY_TRACE = ("<div class='trace-empty'>tool calls land here live — " | |
| "watch the engines work…</div>") | |
| _EMPTY_RANK_HTML = ("<div class='rank-empty'>leaderboard — ask " | |
| "“where should I surf in …” to rank a region.</div>") | |
| def _short_args(args: dict, limit: int = 120) -> str: | |
| try: | |
| text = json.dumps(args, ensure_ascii=False) | |
| except (TypeError, ValueError): | |
| text = str(args) | |
| return text if len(text) <= limit else text[: limit - 1] + "…" | |
| def _pretty_time(value) -> str: | |
| text = str(value or "") | |
| return text.replace("T", " ")[:16] | |
| def _trace_html(cards: list[dict], ask: str = "") -> str: | |
| """Render the live tool trace: cards + timing bars + payload previews.""" | |
| bits = [] | |
| if ask: | |
| bits.append(f"<div class='trace-ask'>ask: {html.escape(ask[:140])}</div>") | |
| if not cards: | |
| bits.append(_EMPTY_TRACE) | |
| return "".join(bits) if ask else _EMPTY_TRACE | |
| times = [c.get("ms") for c in cards | |
| if c.get("state") == "done" and isinstance(c.get("ms"), (int, float))] | |
| slowest = max(times) if times else 0.0 | |
| parts = list(bits) | |
| parts.append("<div class='trace'>") | |
| for c in cards: | |
| icon = _TOOL_ICONS.get(str(c.get("name")), "🔧") | |
| done = c.get("state") == "done" | |
| state_cls = "done" if done else "pending" | |
| ms = c.get("ms") | |
| ms_bit = ("<span class='trace-ms'>…running</span>" if not done | |
| else f"<span class='trace-ms'>⚡ {float(ms):.0f} ms</span>" | |
| if isinstance(ms, (int, float)) | |
| else "<span class='trace-ms'>done</span>") | |
| bar = "" | |
| if done and isinstance(ms, (int, float)) and slowest > 0: | |
| pct = max(6, int(round(100.0 * float(ms) / slowest))) | |
| bar = f"<div class='trace-bar'><i style='width:{pct}%'></i></div>" | |
| summary = (f"<div class='trace-summary'>{html.escape(str(c.get('summary') or ''))}</div>" | |
| if done and c.get("summary") else "") | |
| details = "" | |
| if done and c.get("preview"): | |
| details = ("<details><summary>payload</summary>" | |
| f"<pre>{html.escape(str(c['preview']))}</pre></details>") | |
| parts.append( | |
| f"<div class='trace-card {state_cls}'>" | |
| "<div class='trace-head'>" | |
| f"<span class='trace-icon'>{icon}</span>" | |
| f"<code>{html.escape(str(c.get('name', '?')))}" | |
| f"({html.escape(str(c.get('args', '')))})</code>" | |
| f"{ms_bit}</div>{bar}{summary}{details}</div>" | |
| ) | |
| parts.append("</div>") | |
| return "".join(parts) | |
| def _verdict_html(text: str) -> str: | |
| """Lift the answer's contract verdict line ("Best: …") into a banner.""" | |
| for line in (text or "").splitlines(): | |
| match = _VERDICT_RE.search(line) | |
| if match: | |
| clean = re.sub(r"\*", "", match.group(1)).strip() | |
| if clean: | |
| return (f"<div class='verdict-banner'>🏆 <b>Best:</b> " | |
| f"{html.escape(clean)}</div>") | |
| return "" | |
| def _format_rank_cards(rank: list[dict] | None) -> str: | |
| if not rank: | |
| return _EMPTY_RANK_HTML | |
| parts = ["<div class='rank-list'>"] | |
| for i, r in enumerate(rank): | |
| medal = _MEDALS[i] if i < len(_MEDALS) else str(i + 1) | |
| score = r.get("best_score", "") | |
| score_bit = f"{score}/10" if score not in ("", None) else "—" | |
| parts.append( | |
| "<div class='rank-card'>" | |
| f"<span class='rank-num'>{medal}</span>" | |
| "<span class='rank-name'>" | |
| f"<b>{html.escape(str(r.get('name', '?')))}</b> " | |
| f"<i>{html.escape(str(r.get('region', '') or ''))}</i></span>" | |
| f"<span class='rank-score'>{html.escape(score_bit)}</span>" | |
| f"<span class='rank-time'>{html.escape(_pretty_time(r.get('best_time')))}</span>" | |
| "</div>" | |
| ) | |
| parts.append("</div>") | |
| return "".join(parts) | |
| def _format_meter(usage: dict | None, source: str, | |
| caps: dict | None = None) -> str: | |
| """Final meter after a turn: exact tokens (when known) + steps + caps.""" | |
| if not usage: | |
| return "_Token meter — per-turn usage lands here._" | |
| model = str(usage.get("model") or "").split("/")[-1] | |
| profile = usage.get("profile") | |
| budget = usage.get("budget") or caps or {} | |
| tail = (f" · {profile} profile" if profile else "") \ | |
| + (f" · cap {budget.get('max_steps', '?')} steps" if budget else "") \ | |
| + (f" · {model}" if model else "") + f" (via {source})" | |
| if usage.get("prompt_tokens") is not None or usage.get("completion_tokens") is not None: | |
| p = usage.get("prompt_tokens", "?") | |
| c = usage.get("completion_tokens", "?") | |
| try: | |
| total = int(p) + int(c) | |
| except (TypeError, ValueError): | |
| total = "?" | |
| return f"🪙 **prompt {p} · completion {c} · total {total} tokens**{tail}" | |
| steps = usage.get("steps", "?") | |
| calls = usage.get("tool_calls") or {} | |
| n_calls = sum(calls.values()) if isinstance(calls, dict) else "?" | |
| return f"⚙️ **{steps} steps · {n_calls} tool call(s)**{tail}" | |
| def _live_meter(live: dict, caps: dict, source: str) -> str: | |
| """Mid-turn meter: running counts against the depth profile's caps.""" | |
| bits = [ | |
| f"⚙️ steps {live.get('steps', 0)}/{caps.get('max_steps', '?')}", | |
| f"🔧 {live.get('calls', 0)} call(s)", | |
| f"score_week {live.get('score_week', 0)}/{caps.get('score_week_calls', '?')}", | |
| f"≈{live.get('chars', 0) // 4} tokens", | |
| ] | |
| return " · ".join(bits) + f" — _via {source}_" | |
| def fresh_store() -> dict: | |
| return {"spots": [], "rank": None, "usage": None} | |
| def _build_strip(hours: list[dict], label: str, records: list[dict]): | |
| """Week strip + best-hour line for an agent-scored spot.""" | |
| spot_name = label.split(" (")[0] | |
| match = C.find_break(records, spot_name) | |
| fig = strip_chart.build_week_strip(hours, _scoring_spot(match), height=520) | |
| return fig, score_chart.format_best(score_chart.best_window(hours), label) | |
| def _scoring_spot(break_: dict | None) -> dict | None: | |
| """Minimal scoring spot for wind directional colouring.""" | |
| if not break_: | |
| return None | |
| wind = (break_ or {}).get("idealWind", {}) or {} | |
| direction = wind.get("direction", "N") | |
| if isinstance(direction, list): | |
| direction = "/".join(str(d) for d in direction if d) | |
| return {"ideal_wind": {"direction": str(direction or "N")}} | |
| def _coerce_rank_rows(payload) -> list[dict] | None: | |
| if isinstance(payload, dict) and isinstance(payload.get("rank"), list): | |
| payload = payload["rank"] | |
| if isinstance(payload, dict) and isinstance(payload.get("spots"), list): | |
| payload = payload["spots"] | |
| if not isinstance(payload, list) or not payload: | |
| return None | |
| if not all(isinstance(r, dict) and "name" in r and "best_score" in r for r in payload): | |
| return None | |
| return payload | |
| def _viz_spot(args: dict, obs) -> tuple[str, str]: | |
| """(name, region) for a tool observation, falling back to call args.""" | |
| info = (obs.get("spot") or {}) if isinstance(obs, dict) else {} | |
| name = args.get("spot_name") or info.get("name") or "" | |
| region = args.get("region") or info.get("region") or "" | |
| return str(name), str(region) | |
| def _specialty_tool(query: str) -> str | None: | |
| """The tool whose chart the question explicitly asks for, if any.""" | |
| for tool_name, rx in _SPECIALTY_RE: | |
| if rx.search(query or ""): | |
| return tool_name | |
| return None | |
| def _rose_chart(entry: tuple[dict, object], records: list[dict]): | |
| _a, obs = entry | |
| if not isinstance(obs, dict): | |
| return None, "" | |
| rose = (obs.get("climate") or {}).get("direction_rose_pct") or {} | |
| try: | |
| if not any(float(v or 0) > 0 for v in rose.values()): | |
| return None, "" | |
| except (TypeError, ValueError): | |
| return None, "" | |
| name, _region = _viz_spot(_a, obs) | |
| rec = C.find_break(records, name) | |
| ideal = (((rec or {}).get("idealSwell") or {}).get("direction") | |
| if rec else None) | |
| fig = climate_chart.build_rose_fig({"rose": rose}, name=name, | |
| ideal_dirs=ideal) | |
| return fig, f"swell climate — {name} (5-yr ERA5 rose)" | |
| def _depth_chart(entry: tuple[dict, object], records: list[dict]): | |
| _a, obs = entry | |
| if not isinstance(obs, dict): | |
| return None, "" | |
| name, _region = _viz_spot(_a, obs) | |
| rec = C.find_break(records, name) | |
| if not rec: | |
| return None, "" | |
| try: | |
| grid = (C.get_seafloor(rec) or {}).get("grid") or {} | |
| return seafloor_chart.build_depth_fig(grid, name), \ | |
| f"seafloor depth map — {name}" | |
| except Exception: # noqa: BLE001 — fall through to the next viz | |
| return None, "" | |
| def _similarity_chart(entry: tuple[dict, object], records: list[dict]): | |
| _a, obs = entry | |
| if (isinstance(obs, list) and obs and isinstance(obs[0], dict) | |
| and "similarity" in obs[0]): | |
| ref = str(_a.get("spot_name") or "") | |
| return (score_chart.build_similarity_fig(obs, ref), | |
| f"{len(obs)} spots like {ref} — similarity") | |
| return None, "" | |
| def _components_chart(entry: tuple[dict, object], records: list[dict]): | |
| _a, obs = entry | |
| if (isinstance(obs, dict) and isinstance(obs.get("components"), dict) | |
| and obs["components"]): | |
| name, _region = _viz_spot(_a, obs) | |
| when = str(obs.get("time") or "") | |
| fig = score_chart.build_component_fig(obs["components"], spot=name, | |
| when=when, score=obs.get("score")) | |
| return fig, f"component split — {name} @ {when}" | |
| return None, "" | |
| def _specialty_figure(by_name: dict[str, tuple[dict, object]], | |
| records: list[dict], | |
| prefer: str | None = None): | |
| """First buildable question-specific chart from the tool payloads. | |
| Scans climate rose → seafloor depth map → similarity bars → component | |
| split; a question-matched tool (``prefer``) is scanned first so e.g. a | |
| seafloor question wins its depth map even when a rose payload exists. | |
| Returns (figure, markdown note) or (None, ""). | |
| """ | |
| checks = ( | |
| ("get_climate_profile", _rose_chart), | |
| ("get_seafloor_profile", _depth_chart), | |
| ("find_similar_spots", _similarity_chart), | |
| ("explain_score", _components_chart), | |
| ) | |
| if prefer: | |
| checks = tuple(sorted(checks, key=lambda c: c[0] != prefer)) | |
| for _tool_name, build in checks: | |
| fig, note = build(by_name.get(_tool_name, ({}, None)), records) | |
| if fig is not None: | |
| return fig, note | |
| return None, "" | |
| def _scored_compare_fig(scored: list[dict]): | |
| """Side-by-side best-score bars for a multi-spot scored turn.""" | |
| rows = [] | |
| for s in scored or []: | |
| best = score_chart.best_window(s.get("hours") or []) | |
| if not best: | |
| continue | |
| rows.append({"name": str(s.get("label") or "?"), | |
| "region": str(s.get("region") or ""), | |
| "best_score": best.get("score"), | |
| "best_time": best.get("time")}) | |
| if len(rows) < 2: | |
| return None, "" | |
| names = " vs ".join(r["name"].split(" (")[0] for r in rows[:2]) | |
| fig = score_chart.build_compare_fig( | |
| rows, "name", "best_score", "recommended breaks — best score this week", | |
| sub_keys=("region", "best_time")) | |
| return fig, f"{names} — best-score compare ({len(rows)} spots)" | |
| def _query_region(query: str, records: list[dict]) -> str | None: | |
| """A canonical state/region named in the query (codes expanded), or None.""" | |
| text = f" {query or ''} ".lower() | |
| vocab = sorted({str(r.get("state") or "") for r in records} | |
| | {str(r.get("region") or "") for r in records}, | |
| key=len, reverse=True) | |
| for name in vocab: | |
| if name and re.search(rf"(?<![a-z]){re.escape(name.lower())}(?![a-z])", | |
| text): | |
| return name | |
| for code, name in _STATE_CODES.items(): | |
| if re.search(rf"(?<![a-z]){code.lower()}(?![a-z])", text): | |
| return name | |
| return None | |
| def _turn_figure(viz: list[tuple[str, dict, object]], selected: dict | None, | |
| skill: str, records: list[dict], query: str = "", | |
| focus: str | None = None, scored: list[dict] | None = None, | |
| charted: bool = False): | |
| """Pick + build the end-of-turn chart, matched to the question. | |
| The house chart is the recommended-surf-break-scores view: a | |
| region-sweep leaderboard, or a side-by-side compare when several spots | |
| were scored this turn. Question-specific charts (climate rose, seafloor | |
| depth map, similarity bars, component split) jump the queue only when | |
| the question asks for them. A recommendation question the agent answered | |
| without any sweep still closes on one: a deterministic engine sweep of | |
| the region named in the question (or the page's State/Region focus). | |
| Numbers come from tool/engine output only, never from the answer text. | |
| Returns (figure, markdown note) or (None, "") when nothing chartable. | |
| """ | |
| by_name: dict[str, tuple[dict, object]] = {} | |
| for name, args, obs in viz: | |
| by_name.setdefault(str(name), (args if isinstance(args, dict) else {}, obs)) | |
| q = str(query or "") | |
| recommend = bool(_REC_RE.search(q)) | |
| prefer = _specialty_tool(q) | |
| special = _specialty_figure(by_name, records, prefer) | |
| if charted: | |
| # Multi-spot scored turn: week strips already ran mid-turn — close | |
| # on the side-by-side scores, never an unrelated refetch. | |
| return _scored_compare_fig(scored or []) | |
| if not recommend and prefer and special[0] is not None: | |
| return special | |
| # scores first: the sweep leaderboard, then this turn's scored spots | |
| _a, obs = by_name.get("rank_region_week", ({}, None)) | |
| rows = _coerce_rank_rows(obs) | |
| if rows: | |
| region = str((obs or {}).get("region") if isinstance(obs, dict) else "") \ | |
| or str(_a.get("region") or "") | |
| top = rows[0] | |
| region_bit = f" — {region}" if region else "" | |
| note = (f"region sweep{region_bit} — top pick " | |
| f"**{top.get('name')}** ({top.get('best_score')}/10)") | |
| return score_chart.build_rank_fig(rows, region), note | |
| compare = _scored_compare_fig(scored or []) | |
| if compare[0] is not None: | |
| return compare | |
| if recommend: | |
| region = _query_region(q, records) or (str(focus) if focus else None) | |
| if region: | |
| try: | |
| rows = _coerce_rank_rows( | |
| C.api_rank_region_week(region, skill=skill)) | |
| except Exception: # noqa: BLE001 — chart fallbacks never raise | |
| rows = None | |
| if rows: | |
| top = rows[0] | |
| return (score_chart.build_rank_fig(rows, region), | |
| f"recommended breaks — {region} — top pick " | |
| f"**{top.get('name')}** ({top.get('best_score')}/10)") | |
| if special[0] is not None: | |
| return special | |
| sel = selected or {} | |
| if sel.get("name"): | |
| payload = C.get_scored_week(sel, skill=skill, days=7) | |
| hours = payload.get("scored") or [] | |
| if hours: | |
| label = (f"{sel.get('name')} ({sel.get('region')})" | |
| if sel.get("region") else str(sel.get("name"))) | |
| return _build_strip(hours, label, records) | |
| return None, "" | |
| def chat_fn(message: str, history: list[dict] | None, skill: str, | |
| hf_token: str, selected: dict | None, store: dict | None, | |
| steps: int | None, state: str | None, region: str | None, | |
| records: list[dict]): | |
| """Stream an agent turn: trace cards + meter + verdict + charts.""" | |
| history = list(history or []) | |
| store = dict(store or fresh_store()) | |
| cards: list[dict] = [] | |
| usage = None | |
| verdict = "" | |
| token_source = "session token" if (hf_token or "").strip() else "space secret / env" | |
| try: | |
| steps_n = max(1, int(steps)) if steps is not None else _DEFAULT_STEPS | |
| except (TypeError, ValueError): | |
| steps_n = _DEFAULT_STEPS | |
| caps = C.agent_budget_for_steps(steps_n) | |
| live = {"steps": 0, "calls": 0, "score_week": 0, "chars": 0} | |
| meter = _live_meter(live, caps, token_source) | |
| spots = list(store.get("spots") or []) | |
| rank = store.get("rank") | |
| # Chat decorations injected by tool results (chart/seafloor/brief lines). | |
| # The final event replaces the streamed answer, so they are kept apart | |
| # and re-appended after it — otherwise they'd be wiped. | |
| decorations: list[str] = [] | |
| text = (message or "").strip() | |
| # Tool observations kept for the end-of-turn visualisation (every | |
| # answered turn ends with a chart), plus whether this turn already | |
| # charted scored hours. | |
| viz: list[tuple[str, dict, object]] = [] | |
| turn_charted = False | |
| def emit(status, strip_fig=None, spot_update=None): | |
| return fill(AGENT_KEYS, chatbot=history, msg="", | |
| trace_html=_trace_html(cards, ask=text), token_md=meter, | |
| agent_status=status, verdict_html=verdict, | |
| agent_strip=strip_fig if strip_fig is not None else gr.skip(), | |
| spot_dd=spot_update if spot_update is not None else gr.skip(), | |
| rank_html=_format_rank_cards(rank), | |
| agent_store=dict(store, spots=spots, rank=rank, usage=usage)) | |
| if not text: | |
| yield emit("⚠️ Type a question first.") | |
| return | |
| history = [*history, {"role": "user", "content": text}, {"role": "assistant", "content": ""}] | |
| yield emit("⏳ Agent thinking…") | |
| skill = C.scoring_skill(skill) | |
| try: | |
| stream = C.agent_run_stream(text, skill=skill, hf_token=hf_token or "", | |
| selected_break=selected, | |
| region_hint=_region_hint(state, region), | |
| max_steps=steps_n) | |
| for kind, payload in stream: | |
| if kind == "token": | |
| chunk = str(payload) | |
| history[-1]["content"] += chunk | |
| live["chars"] += len(chunk) | |
| meter = _live_meter(live, caps, token_source) | |
| yield emit("💬 Streaming answer…") | |
| elif kind == "step": | |
| try: | |
| live["steps"] = max(live["steps"], int(payload.get("n", 0))) | |
| except (TypeError, ValueError): | |
| pass | |
| meter = _live_meter(live, caps, token_source) | |
| yield emit(f"⚙️ Step {live['steps']}/{caps.get('max_steps', '?')} — thinking…") | |
| elif kind == "tool_call": | |
| d = payload if isinstance(payload, dict) else {"name": str(payload)} | |
| name = str(d.get("name", "?")) | |
| cards.append({"name": name, "args": _short_args(d.get("arguments", {})), | |
| "state": "pending", "ms": None, "summary": "", "preview": ""}) | |
| live["calls"] += 1 | |
| if name == "score_week": | |
| live["score_week"] += 1 | |
| meter = _live_meter(live, caps, token_source) | |
| yield emit(f"🔧 {name} — ⚙ engines working…") | |
| elif kind == "tool_result": | |
| d = payload if isinstance(payload, dict) else {} | |
| name = str(d.get("name", "?")) | |
| for c in reversed(cards): | |
| if c["state"] == "pending": | |
| c["state"] = "done" | |
| c["ms"] = d.get("ms") | |
| c["summary"] = d.get("summary") or "done" | |
| c["preview"] = (d.get("preview") or "")[:4000] | |
| break | |
| obs = d.get("observation") | |
| hours = score_chart.coerce_scored_hours(obs) | |
| if hours: | |
| args = d.get("arguments") or {} | |
| spot_name = args.get("spot_name") | |
| region_arg = args.get("region") | |
| if isinstance(obs, dict): | |
| info = obs.get("spot") or {} | |
| spot_name = spot_name or info.get("name") | |
| region_arg = region_arg or info.get("region") | |
| label = f"{spot_name} ({region_arg})" if spot_name and region_arg else (spot_name or f"spot {len(spots) + 1}") | |
| entry_skill = skill | |
| if isinstance(obs, dict) and obs.get("skill"): | |
| entry_skill = obs["skill"] | |
| spots.append({"label": label, "hours": hours, | |
| "skill": entry_skill, | |
| "region": str(region_arg or "")}) | |
| # Dedupe repeated chart labels at append time ("#2", "#3", …). | |
| counts: dict[str, int] = {} | |
| for s in spots: | |
| counts[s["label"]] = counts.get(s["label"], 0) + 1 | |
| if counts[s["label"]] > 1: | |
| s["label"] = f"{label} #{counts[s['label']]}" | |
| fig, best_md = _build_strip(hours, spots[-1]["label"], records) | |
| charted = f"📊 _Charted: {spots[-1]['label']} — {best_md}_" | |
| decorations.append(charted) | |
| history[-1]["content"] += f"\n\n{charted}" | |
| labels = [s["label"] for s in spots] | |
| turn_charted = True | |
| yield emit(f"📊 Charted '{spots[-1]['label']}' — agent still thinking…", | |
| strip_fig=fig, | |
| spot_update=gr.update(choices=labels, value=spots[-1]["label"], | |
| visible=len(labels) > 1)) | |
| continue | |
| if isinstance(obs, (dict, list)) and not ( | |
| isinstance(obs, dict) and "error" in obs): | |
| viz.append((name, d.get("arguments") or {}, obs)) | |
| rows = _coerce_rank_rows(obs) | |
| if rows: | |
| rank = rows | |
| yield emit(f"🏆 Ranked {len(rows)} spot(s) — agent still thinking…") | |
| continue | |
| if name == "get_seafloor_profile" and isinstance(obs, dict) and "error" not in obs: | |
| shelf = obs.get("shelf_class") or "shape read" | |
| channel = (" — deeper gutter(s) nearby" if obs.get("channel_hint") | |
| else "") | |
| note = f"🪨 _Seafloor: {shelf}{channel}._" | |
| decorations.append(note) | |
| history[-1]["content"] += f"\n\n{note}" | |
| elif name == "get_session_brief" and isinstance(obs, dict) and "error" not in obs: | |
| wetsuit = obs.get("wetsuit") or "check the water temp" | |
| sst = obs.get("sst_c") | |
| sun = f" · sun {obs.get('sunrise', '')}–{obs.get('sunset', '')}" | |
| note = (f"🤿 _{wetsuit}" | |
| + (f" (water {sst} °C)" if sst is not None else "") | |
| + sun + "_") | |
| decorations.append(note) | |
| history[-1]["content"] += f"\n\n{note}" | |
| yield emit(f"📦 {name} done — agent still thinking…") | |
| elif kind == "usage": | |
| usage = payload if isinstance(payload, dict) else None | |
| meter = _format_meter(usage, token_source, caps=caps) | |
| yield emit("🪙 Usage recorded — agent still thinking…") | |
| elif kind == "final": | |
| final_text = str(payload) if payload else history[-1]["content"] | |
| tail = ("\n\n" + "\n\n".join(decorations)) if decorations else "" | |
| history[-1]["content"] = final_text + tail | |
| verdict = _verdict_html(final_text) | |
| yield emit("✅ Answer complete.") | |
| except ValueError as e: | |
| if "HF_TOKEN" in str(e): | |
| history[-1]["content"] = ("_No Hugging Face token found._ Paste one in the " | |
| "**HF token** box (session-only, never logged) or set " | |
| "`HF_TOKEN`, then ask again.") | |
| yield emit("⚠️ No HF token — paste one above or set HF_TOKEN.") | |
| return | |
| history[-1]["content"] += f"\n\n_❌ Agent run failed: {e}_" | |
| yield emit(f"❌ Agent run failed: {e}") | |
| return | |
| except Exception as e: | |
| history[-1]["content"] += f"\n\n_❌ Agent run failed: {e}_" | |
| yield emit(f"❌ Agent run failed: {e}") | |
| return | |
| # Every answered turn ends with a visualisation matched to the question, | |
| # scores first. Multi-spot scored turns close on the side-by-side | |
| # compare; otherwise the chain runs only when nothing was charted | |
| # mid-turn. The status is yielded first so a slow fetch (e.g. a make-up | |
| # region sweep) reads as a staged spin-up, never a hang. | |
| fallback_fig = None | |
| viz_note = "" | |
| if (not turn_charted) or len(spots) > 1: | |
| yield emit("📊 assembling this turn's chart…") | |
| try: | |
| fallback_fig, viz_note = _turn_figure(viz, selected, skill, records, | |
| query=text, | |
| focus=_region_hint(state, region), | |
| scored=spots, | |
| charted=turn_charted) | |
| except Exception: # noqa: BLE001 — a chart must never break the answer | |
| fallback_fig, viz_note = None, "" | |
| if fallback_fig is not None: | |
| history[-1]["content"] += f"\n\n📊 _Charted: {viz_note}_" | |
| labels = [s["label"] for s in spots] | |
| status = ("✅ Answer complete — chart updated." if fallback_fig is not None | |
| else "✅ Answer complete." if (spots or rank) | |
| else "💬 Nothing chartable this turn — pick a spot and ask again.") | |
| out = dict(chatbot=history, msg="", | |
| trace_html=_trace_html(cards, ask=text), token_md=meter, | |
| agent_status=status, verdict_html=verdict, | |
| spot_dd=gr.update(choices=labels, value=(labels[0] if labels else None), | |
| visible=len(labels) > 1), | |
| rank_html=_format_rank_cards(rank), | |
| agent_store=dict(store, spots=spots, rank=rank, usage=usage)) | |
| if fallback_fig is not None: | |
| out["agent_strip"] = fallback_fig | |
| yield fill(AGENT_KEYS, **out) | |
| def show_spot(label: str | None, store: dict | None, records: list[dict]): | |
| """Rebuild the week strip for the spot picked in the dropdown.""" | |
| spots = (store or {}).get("spots") or [] | |
| entry = next((s for s in spots if s.get("label") == label), None) | |
| if entry is None: | |
| return gr.skip() | |
| try: | |
| fig, _ = _build_strip(entry["hours"], entry["label"], records) | |
| return fig | |
| except Exception: | |
| return gr.skip() | |
| _DEFAULT_STEPS = 6 | |
| def _region_hint(state: str | None, region: str | None) -> str | None: | |
| """Agent focus from the chained filters: region > state > auto (None).""" | |
| for value in (region, state): | |
| if value and value != C.ALL: | |
| return str(value) | |
| return None | |
| def ctx_line(skill: str, selected: dict | None, steps: int | None, | |
| state: str | None, region: str | None) -> str: | |
| """One live line showing what the agent inherits from the page.""" | |
| caps = C.agent_budget_for_steps(int(steps) if steps else _DEFAULT_STEPS) | |
| name = (selected or {}).get("name") or "no spot picked" | |
| reg = (selected or {}).get("region") or "" | |
| hint = _region_hint(state, region) | |
| focus = hint or "auto (map pick)" | |
| view = f"{name}" + (f" — {reg}" if reg else "") | |
| return (f"scoring for **{C.scoring_skill(skill)}** · viewing **{view}** · " | |
| f"focus **{focus}** · budget **{caps['max_steps']} steps / " | |
| f"{caps['score_week_calls']} score_week / {caps['max_tokens']} tokens**") | |
| def clear_chat(): | |
| """Reset the agent panel (session token box is a component, untouched).""" | |
| return fill(AGENT_KEYS, chatbot=[], msg="", | |
| trace_html=_trace_html([]), token_md="_Token meter — per-turn usage lands here._", | |
| agent_status="Ask anything — every answer lands with a chart…", | |
| verdict_html="", | |
| agent_strip=None, | |
| spot_dd=gr.update(choices=[], value=None, visible=False), | |
| rank_html=_EMPTY_RANK_HTML, agent_store=fresh_store()) | |
| CHIP_PROMPTS = [ | |
| "Where should I surf in NSW this weekend as a beginner?", | |
| "When are the best morning windows at Bells Beach this week?", | |
| "Compare Bells Beach and Snapper Rocks this weekend.", | |
| "What's the seafloor like at Bells Beach — and what wetsuit do I need?", | |
| "What breaks are like Snapper Rocks but quieter?", | |
| ] | |
| def build_agent(selected, store, records: list[dict], vocab: dict | None, | |
| visible: bool = False) -> dict: | |
| """Build the agent bar (full width, hidden until agentic mode slides on).""" | |
| states = list((vocab or {}).get("states") or []) | |
| regions_by_state = dict((vocab or {}).get("regions_by_state") or {}) | |
| all_regions = list((vocab or {}).get("all_regions") or []) | |
| with gr.Column(elem_classes=["agent-col"], visible=visible) as agent_col: | |
| gr.Markdown("### 💬 ask the agent — engines compute, the llm narrates") | |
| gr.Markdown("the agent calls ⚙ scoring, 🪨 the gebco world model, 🌡 era5 climate " | |
| "and 📡 open-meteo directly; nemotron 3 ultra only narrates their " | |
| "numbers. every answer lands with a question-matched chart — " | |
| "recommended-scores leaderboard, week strip, rose, depth map, " | |
| "similarity bars or component split.") | |
| ctx_md = gr.Markdown("", elem_classes=["ctx-line"]) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| with gr.Row(elem_classes=["agent-controls"]): | |
| state_dd = gr.Dropdown([C.ALL, *states], value=C.ALL, | |
| label="State", min_width=120) | |
| region_dd = gr.Dropdown([C.ALL, *all_regions], value=C.ALL, | |
| label="Region", min_width=120) | |
| steps_slider = gr.Slider(1, 12, step=1, | |
| value=_DEFAULT_STEPS, | |
| label="max calls", scale=2, | |
| min_width=180, | |
| elem_classes=["steps-slider"]) | |
| token_box = gr.Textbox(label="HF token (optional, session-only)", type="password", | |
| placeholder="Defaults to the Space secret — never logged or saved.") | |
| chatbot = gr.Chatbot(label="Surf agent", height=460) | |
| with gr.Row(elem_classes=["chat-input-row"]): | |
| msg = gr.Textbox(show_label=False, | |
| placeholder="e.g. When should I surf Bells Beach this week? (Enter to send)", | |
| container=False, scale=8) | |
| send_btn = gr.Button("Send", variant="primary", scale=1) | |
| clear_btn = gr.Button("Clear", variant="stop", scale=1) | |
| trace_html = gr.HTML(_trace_html([])) | |
| with gr.Column(scale=1): | |
| verdict_html = gr.HTML("", elem_classes=["verdict-slot"]) | |
| chips = [gr.Button(p, variant="secondary", elem_classes=["chip-btn"]) | |
| for p in CHIP_PROMPTS] | |
| token_md = gr.Markdown("_Token meter — per-turn usage lands here._") | |
| status_box = gr.Textbox(label="Status", interactive=False, | |
| placeholder="Ask anything — every answer lands with a chart…") | |
| spot_dd = gr.Dropdown(choices=[], value=None, visible=False, label="Chart spot (multiple scored)") | |
| agent_strip = gr.Plot(label="week strip — agent-scored spot") | |
| rank_html = gr.HTML(_EMPTY_RANK_HTML) | |
| def _chat(message, history, skill, hf_token, sel, st, steps, state, region): | |
| yield from chat_fn(message, history, skill, hf_token, sel, st, | |
| steps, state, region, records) | |
| def agent_state_regions(state: str): | |
| """Page-one pattern: the State pick rewrites the Region choices.""" | |
| regions = regions_by_state.get(state, all_regions) if state != C.ALL else all_regions | |
| return gr.update(choices=[C.ALL, *regions], value=C.ALL) | |
| def _show(label, st): | |
| return show_spot(label, st, records) | |
| def _chip(text): | |
| return lambda: text | |
| return { | |
| "agent_col": agent_col, | |
| "token_box": token_box, "chatbot": chatbot, "msg": msg, | |
| "send_btn": send_btn, "clear_btn": clear_btn, "trace_html": trace_html, | |
| "verdict_html": verdict_html, "rank_html": rank_html, | |
| "token_md": token_md, "agent_status": status_box, "spot_dd": spot_dd, | |
| "agent_strip": agent_strip, "chips": tuple(chips), | |
| "steps_slider": steps_slider, "state_dd": state_dd, | |
| "region_dd": region_dd, "ctx_md": ctx_md, | |
| "chat": _chat, "show_spot": _show, "clear": clear_chat, "chip_text": _chip, | |
| "ctx": ctx_line, "state_regions": agent_state_regions, | |
| } | |