niceeval 0.1.0

package/src/view/app/lib/format.ts

@@ -0,0 +1,73 @@
+import type { ViewUsage } from "../types.ts";
+
+export function prettyJson(value: unknown): string {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+export function previewText(value: string): string {
+  return String(value).split("\n").find((line) => line.trim()) || "";
+}
+
+export function truncate(value: unknown, n: number): string {
+  const str = String(value);
+  return str.length > n ? str.slice(0, n) + " ... [+" + (str.length - n) + " chars]" : str;
+}
+
+export function formatConfigValue(value: unknown): string {
+  if (value === null) return "null";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+
+export function totalTokens(usage?: ViewUsage): number {
+  return (usage?.inputTokens || 0) + (usage?.outputTokens || 0) + (usage?.cacheReadTokens || 0) + (usage?.cacheWriteTokens || 0);
+}
+
+export function formatPercent(value?: number): string {
+  if (typeof value !== "number" || !Number.isFinite(value)) return "0%";
+  return Math.round(value * 100) + "%";
+}
+
+/** 断言 / judge 分数本就是 0–1,直接展示原值(去掉末尾零),不转百分比。pass-rate 之类的「比率」仍用 formatPercent。 */
+export function formatScore(value?: number): string {
+  if (typeof value !== "number" || !Number.isFinite(value)) return "0";
+  return String(Number(value.toFixed(2)));
+}
+
+export function formatDuration(ms?: number): string {
+  if (typeof ms !== "number" || !Number.isFinite(ms) || ms <= 0) return "0ms";
+  if (ms >= 60000) return (ms / 60000).toFixed(1) + "m";
+  if (ms >= 1000) return (ms / 1000).toFixed(2) + "s";
+  return Math.round(ms) + "ms";
+}
+
+export function formatTokens(value: number): string {
+  if (!Number.isFinite(value) || value <= 0) return "0";
+  if (value >= 1000000) return (value / 1000000).toFixed(2) + "M";
+  if (value >= 1000) return (value / 1000).toFixed(1) + "k";
+  return String(Math.round(value));
+}
+
+export function formatCost(value?: number): string {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return "$0";
+  return "$" + value.toFixed(value < 1 ? 3 : 2);
+}
+
+export function formatDateTime(iso?: string): string {
+  if (!iso) return "-";
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return "-";
+  return date.toLocaleString([], { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+}
+
+export function formatClock(iso?: string): string {
+  if (!iso) return "";
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return "";
+  return date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}

package/src/view/app/lib/guards.ts

@@ -0,0 +1,61 @@
+import type { CodeSource, ObjectRecord, Span, TranscriptEvent } from "../types.ts";
+
+export function asSources(value: unknown): CodeSource[] | null {
+  if (!Array.isArray(value)) return null;
+  return value.every(isCodeSource) ? value : null;
+}
+
+export function isCodeSource(value: unknown): value is CodeSource {
+  return isObjectRecord(value) && typeof value.path === "string" && typeof value.content === "string";
+}
+
+export function asEvents(value: unknown): TranscriptEvent[] | null {
+  if (!Array.isArray(value)) return null;
+  return value.every(isTranscriptEvent) ? value : null;
+}
+
+export function asSpans(value: unknown): Span[] | null {
+  if (!Array.isArray(value)) return null;
+  return value.every(isSpan) ? value : null;
+}
+
+export function isTranscriptEvent(value: unknown): value is TranscriptEvent {
+  if (!isObjectRecord(value) || typeof value.type !== "string") return false;
+  switch (value.type) {
+    case "message":
+      return (value.role === "assistant" || value.role === "user") && typeof value.text === "string";
+    case "action.called":
+      return typeof value.callId === "string" && typeof value.name === "string";
+    case "action.result":
+      return typeof value.callId === "string";
+    case "subagent.called":
+      return typeof value.callId === "string" && typeof value.name === "string";
+    case "subagent.completed":
+      return typeof value.callId === "string";
+    case "input.requested":
+      return isObjectRecord(value.request);
+    case "thinking":
+      return typeof value.text === "string";
+    case "compaction":
+      return true;
+    case "error":
+      return typeof value.message === "string";
+    default:
+      return false;
+  }
+}
+
+export function isSpan(value: unknown): value is Span {
+  return (
+    isObjectRecord(value) &&
+    typeof value.traceId === "string" &&
+    typeof value.spanId === "string" &&
+    typeof value.name === "string" &&
+    typeof value.startMs === "number" &&
+    typeof value.endMs === "number"
+  );
+}
+
+export function isObjectRecord(value: unknown): value is ObjectRecord {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}

package/src/view/app/lib/outcome.ts

@@ -0,0 +1,96 @@
+import type { Assertion, Outcome, ViewResult, ViewRow } from "../types.ts";
+import type { T } from "../shared.ts";
+import { formatScore } from "./format.ts";
+
+export function outcomeOf(result: ViewResult): Outcome {
+  return result.outcome;
+}
+
+/**
+ * 同一个 eval 的多轮 attempt 折叠成单一判决:任一轮通过 → 通过(对齐 earlyExit「先过一次即停」),
+ * 否则按 failed > errored > skipped 取最严重的。后端 view/index.ts:foldEvalOutcome 用同样口径,
+ * 两边必须一致,否则折叠行的状态会和 KPI / 成功率对不上。
+ */
+export function foldEvalOutcome(attempts: ViewResult[]): Outcome {
+  const outs = attempts.map(outcomeOf);
+  if (outs.some((o) => o === "passed")) return "passed";
+  if (outs.some((o) => o === "failed")) return "failed";
+  if (outs.some((o) => o === "errored")) return "errored";
+  return "skipped";
+}
+
+export interface EvalGroup {
+  id: string;
+  experimentId?: string;
+  outcome: Outcome;
+  attempts: ViewResult[];
+  passedAttempts: number;
+}
+
+/** 把一批 attempt 按 (experimentId, eval id) 折叠成「每个 eval 一行」,内部 attempt 按轮次排序。 */
+export function groupByEval(results: ViewResult[]): EvalGroup[] {
+  const byEval = new Map<string, ViewResult[]>();
+  for (const r of results) {
+    const key = `${r.experimentId ?? ""}|||${r.id}`;
+    byEval.set(key, [...(byEval.get(key) ?? []), r]);
+  }
+  return [...byEval.values()].map((attempts) => {
+    const sorted = [...attempts].sort((a, b) => a.attempt - b.attempt);
+    return {
+      id: sorted[0]!.id,
+      experimentId: sorted[0]!.experimentId,
+      outcome: foldEvalOutcome(sorted),
+      attempts: sorted,
+      passedAttempts: sorted.filter((a) => outcomeOf(a) === "passed").length,
+    };
+  });
+}
+
+/** 成功率按 eval 计票:折叠后通过的 eval 占已跑(非 skipped)eval 的比例。 */
+export function evalPassRate(results: ViewResult[]): number {
+  const ran = groupByEval(results).filter((g) => g.outcome !== "skipped");
+  return ran.length ? ran.filter((g) => g.outcome === "passed").length / ran.length : 0;
+}
+
+export function outcomeClass(outcome: Outcome): string {
+  return outcome === "passed" ? "good" : outcome === "errored" ? "infra-err" : outcome === "failed" ? "bad" : "warn";
+}
+
+export function outcomeLabel(outcome: Outcome, t: T): string {
+  if (outcome === "passed") return t("status.pass");
+  if (outcome === "failed") return t("status.fail");
+  if (outcome === "errored") return t("status.error");
+  if (outcome === "skipped") return t("status.skipped");
+  return outcome || "—";
+}
+
+// Only gate-severity failures are eval "failure reasons"; soft failures show as scores
+export function failingAssertions(result: ViewResult): Assertion[] {
+  return (result.assertions || []).filter((a: Assertion) => !a.passed && a.severity === "gate");
+}
+
+export function reasonFor(result: ViewResult, failedGates: Assertion[]): string {
+  if (result.error) return result.error;
+  if (result.skipReason) return result.skipReason;
+  return failedGates.map((a: Assertion) => (a.detail ? `${a.name}: ${a.detail}` : a.name)).join(", ");
+}
+
+export function scoresSummary(assertions: Assertion[]): string {
+  const scored = (assertions || []).filter((a: Assertion) => a.score !== undefined && a.score !== null);
+  if (!scored.length) return "";
+  return scored
+    .map((a: Assertion) => {
+      const s = formatScore(a.score);
+      return a.threshold !== undefined ? `${a.name} ${s}/${formatScore(a.threshold)}` : `${a.name} ${s}`;
+    })
+    .join(" · ");
+}
+
+export function outcomeSummary(row: ViewRow, t: T): string {
+  // fold "scored" (soft-only) into passed count
+  const passed = (row.passed || 0) + (row.scored || 0);
+  const parts = [`${passed} ${t("outcome.passed")}`, `${row.failed} ${t("outcome.failed")}`];
+  if (row.errored) parts.push(`${row.errored} ${t("outcome.errored")}`);
+  if (row.skipped) parts.push(`${row.skipped} ${t("outcome.skipped")}`);
+  return parts.join(" / ");
+}

package/src/view/app/lib/rows.ts

@@ -0,0 +1,63 @@
+import type { ReactNode } from "react";
+import type { SortKey, ViewResult, ViewRow } from "../types.ts";
+import type { T } from "../shared.ts";
+import { formatConfigValue, totalTokens } from "./format.ts";
+
+export function resultFromUrl(rows: ViewRow[]): ViewResult | null {
+  const p = new URLSearchParams(location.search);
+  const id = p.get("modal");
+  if (!id) return null;
+  const exp = p.get("exp");
+  const attempt = parseInt(p.get("a") ?? "0", 10);
+  for (const row of rows) {
+    for (const result of row.results ?? []) {
+      if (result.id === id && (!exp || result.experimentId === exp) && result.attempt === attempt) {
+        return result;
+      }
+    }
+  }
+  return null;
+}
+
+export function buildGroupMap(rows: ViewRow[]): Map<string, ViewRow[]> {
+  const map = new Map<string, ViewRow[]>();
+  for (const row of rows) {
+    if (!row.group) continue;
+    if (!map.has(row.group)) map.set(row.group, []);
+    map.get(row.group)?.push(row);
+  }
+  return map;
+}
+
+export function compareRows(a: ViewRow, b: ViewRow, key: SortKey): number {
+  const av = valueFor(a, key);
+  const bv = valueFor(b, key);
+  if (typeof av === "string" || typeof bv === "string") return String(av).localeCompare(String(bv));
+  return Number(av) - Number(bv);
+}
+
+export function valueFor(row: ViewRow, key: SortKey): string | number {
+  if (key === "experiment") return row.label;
+  if (key === "model") return row.model || "";
+  if (key === "agent") return row.agent;
+  if (key === "cost") return row.estimatedCostUSD || 0;
+  if (key === "tokens") return totalTokens(row.usage);
+  return row[key] || 0;
+}
+
+export function configChips(row: ViewRow, t: T): [string, ReactNode][] {
+  const exp = row.experiment || {};
+  const flags = exp.flags && Object.keys(exp.flags).length
+    ? Object.entries(exp.flags).map(([k, v]) => k + "=" + formatConfigValue(v)).join(", ")
+    : t("config.flagsNone");
+  return [
+    [t("config.experiment"), row.experimentId || row.label],
+    [t("table.model"), row.model || t("config.default")],
+    ["agent", row.agent],
+    ["runs", exp.runs ?? row.runs],
+    ["earlyExit", exp.earlyExit === undefined ? t("config.notApplicable") : String(exp.earlyExit)],
+    ["sandbox", exp.sandbox || t("config.default")],
+    ["budget", exp.budget === undefined ? t("config.none") : "$" + exp.budget],
+    ["flags", flags],
+  ];
+}

package/src/view/app/lib/transcript-data.tsx

@@ -0,0 +1,121 @@
+import type { ReactNode } from "react";
+import type { Assertion, Indexed, IndexedTurns, SourceTurn, TranscriptEvent, ViewJson } from "../types.ts";
+import type { ToolBlockCall } from "../shared.ts";
+import { isObjectRecord } from "./guards.ts";
+import { prettyJson } from "./format.ts";
+
+// ───────────────────────── 源码对齐的代码视图(github-diff 式)─────────────────────────
+// 拿 sources.json(eval 源码)+ events.json(带 loc 的 send),把每条 send / 断言的运行结果
+// 叠回真实源码行:send 行折叠→展开看回复;断言行绿(过)/红(不过),judge 行带分数,展开看 CoT。
+
+export function locKey(file: string, line: number): string {
+  return `${file}:${line}`;
+}
+
+/** events → 按 send 的 loc 聚成「轮」:每轮含 sent 文本 + 后续 thinking/assistant/tool 回复。 */
+export function indexTurns(events: TranscriptEvent[]): IndexedTurns {
+  const byKey = new Map<string, SourceTurn>();
+  const noloc: SourceTurn[] = [];
+  let cur: SourceTurn | null = null;
+  for (const ev of events || []) {
+    if (ev.type === "message" && ev.role === "user") {
+      cur = { loc: ev.loc, sent: ev.text || "", replies: [] };
+      if (ev.loc) byKey.set(locKey(ev.loc.file, ev.loc.line), cur);
+      else noloc.push(cur);
+    } else if (!cur) {
+      continue;
+    } else if (ev.type === "message" && ev.role === "assistant") {
+      cur.replies.push({ kind: "text", text: ev.text || "" });
+    } else if (ev.type === "thinking") {
+      cur.replies.push({ kind: "thinking", text: ev.text || "" });
+    } else if (ev.type === "action.called") {
+      cur.replies.push({ kind: "tool", ev });
+    } else if (ev.type === "action.result") {
+      const tool = [...cur.replies].reverse().find(
+        (r): r is Extract<SourceTurn["replies"][number], { kind: "tool" }> => r.kind === "tool" && r.ev.callId === ev.callId,
+      );
+      if (tool) tool.result = ev;
+    } else if (ev.type === "error") {
+      cur.replies.push({ kind: "error", text: ev.message || "error" });
+    }
+  }
+  return { byKey, noloc };
+}
+
+/** assertions → 按 loc 聚到行。有 loc 的进 byKey,没 loc 的进 noloc(底部兜底列)。 */
+export function indexAsserts(assertions: Assertion[]): Indexed<Assertion> {
+  const byKey = new Map<string, Assertion[]>();
+  const noloc: Assertion[] = [];
+  for (const a of assertions || []) {
+    if (a.loc) {
+      const k = locKey(a.loc.file, a.loc.line);
+      if (!byKey.has(k)) byKey.set(k, []);
+      byKey.get(k)?.push(a);
+    } else {
+      noloc.push(a);
+    }
+  }
+  return { byKey, noloc };
+}
+
+export const TS_HL_RE =
+  /(\/\/[^\n]*)|(\/\*[^]*?\*\/)|(`(?:\\.|[^`\\])*`|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')|\b(import|from|export|default|const|let|var|async|await|function|return|if|else|for|of|in|new|class|extends|typeof|void|true|false|null|undefined)\b|\b(\d[\d_.]*)\b|([A-Za-z_$][\w$]*)(?=\s*\()/g;
+
+/** 轻量 TS 着色(逐行,零依赖):注释 / 字符串 / 关键字 / 数字 / 函数名。 */
+export function highlightTs(line: string): ReactNode[] {
+  const out: ReactNode[] = [];
+  let last = 0;
+  let i = 0;
+  let m: RegExpExecArray | null;
+  TS_HL_RE.lastIndex = 0;
+  while ((m = TS_HL_RE.exec(line))) {
+    if (m.index > last) out.push(line.slice(last, m.index));
+    const cls = m[1] || m[2] ? "tok-comment" : m[3] ? "tok-str" : m[4] ? "tok-kw" : m[5] ? "tok-num" : m[6] ? "tok-fn" : null;
+    out.push(cls ? <span key={i++} className={cls}>{m[0]}</span> : m[0]);
+    last = m.index + m[0].length;
+    if (m[0].length === 0) TS_HL_RE.lastIndex++;
+  }
+  if (last < line.length) out.push(line.slice(last));
+  return out;
+}
+
+export const TOOL_VERB: Record<string, string> = {
+  file_read: "Read",
+  file_write: "Write",
+  file_edit: "Edit",
+  shell: "Bash",
+  web_fetch: "Fetch",
+  web_search: "Search",
+  glob: "Glob",
+  grep: "Grep",
+  list_dir: "List",
+  agent_task: "Task",
+};
+
+export function toolPrimaryArg(call: ToolBlockCall): string {
+  const input = call.input;
+  if (typeof input === "string") return input;
+  if (!isObjectRecord(input)) return "";
+  if (call.tool === "shell") {
+    const command = input.command ?? input.cmd;
+    if (typeof command === "string") return command;
+    if (Array.isArray(command)) return command.filter((x: ViewJson) => typeof x === "string").join(" ");
+  }
+  for (const key of ["path", "file", "file_path", "filename", "pattern", "query", "url", "uri", "prompt", "description", "command", "remoteUrl"]) {
+    const value = input[key];
+    if (typeof value === "string" && value) return value;
+  }
+  return "";
+}
+
+export function resultBody(output: ViewJson | undefined): string {
+  if (output == null) return "";
+  if (typeof output === "string") return output;
+  if (isObjectRecord(output)) {
+    for (const key of ["output", "stdout", "content", "text", "result", "body"]) {
+      const value = output[key];
+      if (typeof value === "string") return value;
+    }
+  }
+  return prettyJson(output);
+}

package/src/view/app/main.tsx

@@ -0,0 +1,17 @@
+import { createRoot } from "react-dom/client";
+import type { ViewData } from "./types.ts";
+import { App } from "./App.tsx";
+import "../styles.css";
+
+const initialData: ViewData = window.__NICEEVAL_VIEW_DATA__ ?? {
+  rows: [],
+  lastRun: "No runs yet",
+  passRate: "0%",
+  resultCount: "0",
+  duration: "0ms",
+  cost: "$0",
+};
+
+const rootEl = document.getElementById("root");
+if (!rootEl) throw new Error("Missing #root element");
+createRoot(rootEl).render(<App data={initialData} />);

package/src/view/app/pages/RunsPage.tsx

@@ -0,0 +1,83 @@
+import { useMemo, useState } from "react";
+import type { RowRun, T } from "../shared.ts";
+import type { ViewResult, ViewRow } from "../types.ts";
+import { outcomeClass, outcomeLabel, outcomeOf } from "../lib/outcome.ts";
+import { formatCost, formatDateTime, formatDuration, formatTokens, totalTokens } from "../lib/format.ts";
+
+export function RunsView({ rows, t }: { rows: ViewRow[]; t: T }) {
+  const [query, setQuery] = useState("");
+  const allRuns = useMemo(
+    () => rows.flatMap((row: ViewRow) => (row.results ?? []).map((r: ViewResult): RowRun => ({ ...r, rowLabel: row.label, rowAgent: row.agent, rowModel: row.model }))),
+    [rows],
+  );
+  const filtered = allRuns.filter((r: RowRun) => {
+    const q = query.trim().toLowerCase();
+    return !q || `${r.id} ${r.rowLabel} ${r.rowAgent} ${r.rowModel || ""}`.toLowerCase().includes(q);
+  });
+  return (
+    <section id="tab-runs">
+      <div className="section-head">
+        <h2>{t("section.individualRuns")}</h2>
+        <div className="controls">
+          <input
+            className="search"
+            type="search"
+            placeholder={t("search.runs")}
+            autoComplete="off"
+            value={query}
+            onChange={(e) => setQuery(e.target.value)}
+          />
+        </div>
+      </div>
+      {!allRuns.length ? (
+        <div className="empty">{t("empty.individualRuns")}</div>
+      ) : (
+        <div className="table-wrap">
+          <table>
+            <thead>
+              <tr>
+                <th>{t("table.evalId")}</th>
+                <th>{t("table.experiment")}</th>
+                <th>{t("table.outcome")}</th>
+                <th>{t("table.agent")}</th>
+                <th>{t("table.model")}</th>
+                <th>{t("metric.duration")}</th>
+                <th>{t("table.tokens")}</th>
+                <th>{t("table.estCost")}</th>
+                <th>{t("table.ranAt")}</th>
+              </tr>
+            </thead>
+            <tbody>
+              {filtered.length ? (
+                filtered.map((r: RowRun) => {
+                  const outcome = outcomeOf(r);
+                  return (
+                    <tr key={`${r.id}-${r.rowLabel}-${r.attempt}`}>
+                      <td>
+                        <span className="name">{r.id}</span>
+                      </td>
+                      <td>{r.rowLabel}</td>
+                      <td className={outcomeClass(outcome)}>{outcomeLabel(outcome, t)}</td>
+                      <td>{r.rowAgent}</td>
+                      <td>{r.rowModel || t("config.default")}</td>
+                      <td className="num">{formatDuration(r.durationMs)}</td>
+                      <td className="num">{formatTokens(totalTokens(r.usage))}</td>
+                      <td className="num">{formatCost(r.estimatedCostUSD)}</td>
+                      <td className="num">{r.startedAt ? formatDateTime(r.startedAt) : "-"}</td>
+                    </tr>
+                  );
+                })
+              ) : (
+                <tr>
+                  <td colSpan={9} style={{ textAlign: "center", color: "var(--muted)" }}>
+                    {t("empty.runsFilter")}
+                  </td>
+                </tr>
+              )}
+            </tbody>
+          </table>
+        </div>
+      )}
+    </section>
+  );
+}

package/src/view/app/pages/TracesPage.tsx

@@ -0,0 +1,40 @@
+import { useMemo } from "react";
+import type { RowRun, T } from "../shared.ts";
+import type { ViewResult, ViewRow } from "../types.ts";
+import { outcomeClass, outcomeLabel, outcomeOf } from "../lib/outcome.ts";
+import { formatDuration } from "../lib/format.ts";
+import { LazyArtifact } from "../components/LazyArtifact.tsx";
+
+export function TracesView({ rows, t }: { rows: ViewRow[]; t: T }) {
+  const allRuns = useMemo(
+    () => rows.flatMap((row: ViewRow) => (row.results ?? []).map((r: ViewResult): RowRun => ({ ...r, rowLabel: row.label, rowAgent: row.agent, rowModel: row.model }))),
+    [rows],
+  );
+  const traceable = allRuns.filter((r: RowRun) => r.hasEvents || r.hasTrace);
+  return (
+    <section id="tab-traces">
+      <div className="section-head">
+        <h2>{t("section.traces")}</h2>
+      </div>
+      {!traceable.length ? (
+        <div className="empty">{t("empty.traces")}</div>
+      ) : (
+        traceable.map((r: RowRun) => {
+          const outcome = outcomeOf(r);
+          return (
+            <div className="traces-entry" key={`${r.id}-${r.rowLabel}-${r.attempt}`}>
+              <div className="traces-entry-head">
+                <span className={`${outcomeClass(outcome)} traces-verdict`}>{outcomeLabel(outcome, t)}</span>
+                <span className="eval-id">{r.id}</span>
+                <span className="traces-exp">{r.rowLabel}</span>
+                <span className="num traces-dur">{formatDuration(r.durationMs)}</span>
+              </div>
+              {r.hasEvents && r.artifactBase ? <LazyArtifact type="transcript" src={`${r.artifactBase}/events.json`} t={t} /> : null}
+              {r.hasTrace && r.artifactBase ? <LazyArtifact type="trace" src={`${r.artifactBase}/trace.json`} t={t} /> : null}
+            </div>
+          );
+        })
+      )}
+    </section>
+  );
+}

package/src/view/app/shared.ts

@@ -0,0 +1,10 @@
+import type { MessageKey } from "./i18n.ts";
+import type { CodeSource, TranscriptEvent, ViewJson, ViewResult } from "./types.ts";
+
+export type T = (key: MessageKey) => string;
+export type OpenModal = (result: ViewResult) => void;
+export type ArtifactLoadState =
+  | { sources: CodeSource[] | null; events: TranscriptEvent[] | null; status: "loading" | "ready" | "none" };
+export type RowRun = ViewResult & { rowLabel: string; rowAgent: string; rowModel?: string };
+export type LazyArtifactType = "trace" | "transcript";
+export type ToolBlockCall = { tool?: string; name: string; input: ViewJson };