agentinputlab 0.1.0a1__py3-none-any.whl

agentinputlab/studio/static/app.js

@@ -0,0 +1,397 @@
+"use strict";
+
+const state = {
+  catalog: null,
+  validation: null,
+  validationSequence: 0,
+  validationTimer: null,
+  toastTimer: null,
+  activeRuns: 0,
+};
+
+const el = (id) => document.getElementById(id);
+
+async function requestJSON(url, options = {}) {
+  const response = await fetch(url, {
+    ...options,
+    headers: options.body ? { "Content-Type": "application/json" } : undefined,
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const error = new Error(payload?.error?.message || `Request failed (${response.status})`);
+    error.status = response.status;
+    error.payload = payload;
+    throw error;
+  }
+  return payload;
+}
+
+function addOption(select, value, label) {
+  const option = document.createElement("option");
+  option.value = value;
+  option.textContent = label;
+  select.append(option);
+}
+
+function currentAlgorithm() {
+  return state.catalog?.algorithms.find((item) => item.id === el("algorithm").value) || null;
+}
+
+function currentRelease() {
+  return currentAlgorithm()?.versions.find((item) => item.id === el("release").value) || null;
+}
+
+function currentDataset() {
+  return state.catalog?.datasets.find((item) => item.id === el("dataset").value) || null;
+}
+
+function currentBackend() {
+  return state.catalog?.backends.find((item) => item.id === el("backend").value) || null;
+}
+
+function setSelectValue(select, desired, fallback = "") {
+  const exists = Array.from(select.options).some((option) => option.value === desired);
+  select.value = exists ? desired : fallback || select.options[0]?.value || "";
+}
+
+function populateCatalog() {
+  const defaults = state.catalog.default_config;
+  const algorithmSelect = el("algorithm");
+  const backendSelect = el("backend");
+  const datasetSelect = el("dataset");
+  algorithmSelect.replaceChildren();
+  backendSelect.replaceChildren();
+  datasetSelect.replaceChildren();
+
+  for (const algorithm of state.catalog.algorithms) {
+    const readyCount = algorithm.versions.filter((version) => version.studio_ready).length;
+    const suffix = readyCount ? `${readyCount} local` : "inspect only";
+    addOption(algorithmSelect, algorithm.id, `${algorithm.name} · ${suffix}`);
+  }
+  for (const backend of state.catalog.backends) {
+    addOption(backendSelect, backend.id, `${backend.name} · ${backend.ready ? "ready" : "locked"}`);
+  }
+  for (const dataset of state.catalog.datasets) {
+    const readiness = dataset.execution_ready
+      ? "executable"
+      : dataset.data_ready
+        ? "data ready"
+        : "registered";
+    addOption(datasetSelect, dataset.id, `${dataset.suite} / ${dataset.task} · ${readiness}`);
+  }
+
+  setSelectValue(algorithmSelect, defaults.algorithm_id);
+  populateReleases(defaults.release_id);
+  setSelectValue(backendSelect, defaults.backend_id);
+  setSelectValue(datasetSelect, defaults.dataset_id);
+  el("seed").value = defaults.parameters.seed;
+  el("sample-limit").value = defaults.parameters.sample_limit;
+  el("top-k").value = defaults.parameters.top_k;
+  el("temperature").value = defaults.parameters.temperature;
+  el("soft-word-budget").value = defaults.parameters.soft_word_budget;
+  el("clarification-threshold").value = defaults.parameters.clarification_threshold;
+  el("paired-baseline").checked = defaults.fairness.paired_baseline;
+  el("fixed-seed").checked = defaults.fairness.fixed_seed;
+  el("shared-retriever").checked = defaults.fairness.shared_retriever;
+  el("freeze-dependencies").checked = defaults.fairness.freeze_dependencies;
+  el("fail-on-drift").checked = defaults.fairness.fail_on_fingerprint_drift;
+  el("catalog-count").textContent = `${state.catalog.algorithms.length - 1} methods · ${state.catalog.selectors.length} selectors · ${state.catalog.datasets.length - 1} benchmark cells`;
+  updateContextCopy();
+}
+
+function populateReleases(preferred = "") {
+  const select = el("release");
+  select.replaceChildren();
+  const algorithm = currentAlgorithm();
+  for (const version of algorithm?.versions || []) {
+    const availability = version.studio_ready ? "LOCAL" : "LOCKED";
+    addOption(select, version.id, `${version.id} · ${availability}`);
+  }
+  setSelectValue(select, preferred);
+  updateContextCopy();
+}
+
+function updateContextCopy() {
+  const algorithm = currentAlgorithm();
+  const release = currentRelease();
+  const dataset = currentDataset();
+  const backend = currentBackend();
+  if (algorithm) {
+    el("algorithm-family").textContent = `${algorithm.family} · ${algorithm.tier} · ${algorithm.status}`;
+  }
+  if (release) {
+    el("release-status").textContent = `${release.status} · ${release.delivery_tier}`;
+    el("method-note").querySelector("p").textContent = release.studio_reason;
+  }
+  if (backend) {
+    el("backend-note").textContent = backend.description;
+  }
+  if (dataset) {
+    const readiness = dataset.execution_ready
+      ? "Data verified · executable"
+      : dataset.data_ready
+        ? "Data verified · execution locked"
+        : "Data not prepared · execution locked";
+    el("dataset-readiness").textContent = `${readiness} · ${dataset.reason}`;
+    el("dataset-task").textContent = dataset.task;
+    el("dataset-size").textContent = dataset.size;
+    el("dataset-metrics").textContent = dataset.metrics.join(", ");
+    el("dataset-families").textContent = dataset.families.join(", ");
+    el("dataset-sample").textContent = dataset.sample
+      ? `${dataset.sample.id}: “${dataset.sample.query}” → ${dataset.sample.target_document}`
+      : "No local sample is exposed until the prepared-data adapter passes validation.";
+  }
+  el("manifest-release").textContent = el("release").value || "—";
+  el("manifest-backend").textContent = el("backend").value || "—";
+  el("manifest-dataset").textContent = el("dataset").value || "—";
+}
+
+function numericValue(id) {
+  const value = el(id).valueAsNumber;
+  return Number.isFinite(value) ? value : null;
+}
+
+function collectConfig() {
+  return {
+    algorithm_id: el("algorithm").value,
+    release_id: el("release").value,
+    backend_id: el("backend").value,
+    dataset_id: el("dataset").value,
+    parameters: {
+      seed: numericValue("seed"),
+      sample_limit: numericValue("sample-limit"),
+      top_k: numericValue("top-k"),
+      temperature: numericValue("temperature"),
+      soft_word_budget: numericValue("soft-word-budget"),
+      clarification_threshold: numericValue("clarification-threshold"),
+    },
+    fairness: {
+      paired_baseline: el("paired-baseline").checked,
+      fixed_seed: el("fixed-seed").checked,
+      shared_retriever: el("shared-retriever").checked,
+      freeze_dependencies: el("freeze-dependencies").checked,
+      fail_on_fingerprint_drift: el("fail-on-drift").checked,
+    },
+  };
+}
+
+function scheduleValidation() {
+  updateContextCopy();
+  clearTimeout(state.validationTimer);
+  el("validation-state").className = "validation-state checking";
+  el("validation-state").textContent = "CHECKING";
+  el("run-button").disabled = true;
+  const sequence = ++state.validationSequence;
+  state.validationTimer = setTimeout(() => validateCurrent(sequence), 120);
+}
+
+async function validateCurrent(sequence) {
+  try {
+    const report = await requestJSON("/api/validate", {
+      method: "POST",
+      body: JSON.stringify(collectConfig()),
+    });
+    if (sequence !== state.validationSequence) return;
+    state.validation = report;
+    renderValidation(report);
+  } catch (error) {
+    if (sequence !== state.validationSequence) return;
+    renderValidation({
+      valid: false,
+      errors: [{ path: "api", message: error.message }],
+      warnings: [],
+      compatibility: { confirmatory: false },
+    });
+  }
+}
+
+function renderValidation(report) {
+  const badge = el("validation-state");
+  const list = el("issue-list");
+  list.replaceChildren();
+  badge.className = `validation-state ${report.valid ? "valid" : "invalid"}`;
+  badge.textContent = report.valid ? "READY" : "BLOCKED";
+  el("run-button").disabled = !report.valid;
+  const allIssues = [...(report.errors || []), ...(report.warnings || [])];
+  if (report.valid && !allIssues.length) {
+    el("compatibility-title").textContent = "Ready for a controlled run";
+    el("compatibility-copy").textContent = "Profile, replay backend, fixture data, and all fairness controls are compatible.";
+    const item = document.createElement("li");
+    item.className = "ok";
+    item.textContent = "No compatibility exceptions";
+    list.append(item);
+  } else if (report.valid) {
+    el("compatibility-title").textContent = "Ready, with exploratory flags";
+    el("compatibility-copy").textContent = "The run can execute, but disabled controls will be recorded in its manifest.";
+  } else {
+    el("compatibility-title").textContent = "Configuration is blocked";
+    el("compatibility-copy").textContent = "Resolve the constraints below before this experiment can enter the queue.";
+  }
+  for (const issue of report.errors || []) {
+    const item = document.createElement("li");
+    item.textContent = `${issue.path}: ${issue.message}`;
+    list.append(item);
+  }
+  for (const issue of report.warnings || []) {
+    const item = document.createElement("li");
+    item.className = "warning";
+    item.textContent = `${issue.path}: ${issue.message}`;
+    list.append(item);
+  }
+  el("manifest-mode").textContent = report.compatibility?.confirmatory ? "confirmatory" : "exploratory";
+}
+
+function setupSteps() {
+  for (const button of document.querySelectorAll(".step")) {
+    button.addEventListener("click", () => {
+      const selected = button.dataset.step;
+      for (const step of document.querySelectorAll(".step")) {
+        const active = step === button;
+        step.classList.toggle("active", active);
+        step.setAttribute("aria-selected", String(active));
+      }
+      for (const panel of document.querySelectorAll(".config-section")) {
+        const active = panel.dataset.panel === selected;
+        panel.hidden = !active;
+        panel.classList.toggle("active", active);
+      }
+    });
+  }
+}
+
+function bindInputs() {
+  el("algorithm").addEventListener("change", () => {
+    populateReleases();
+    scheduleValidation();
+  });
+  for (const input of document.querySelectorAll("#run-form select:not(#algorithm), #run-form input")) {
+    input.addEventListener("input", scheduleValidation);
+    input.addEventListener("change", scheduleValidation);
+  }
+  el("run-form").addEventListener("submit", queueRun);
+  el("refresh-runs").addEventListener("click", refreshRuns);
+}
+
+async function queueRun(event) {
+  event.preventDefault();
+  if (!state.validation?.valid) return;
+  const button = el("run-button");
+  button.classList.add("running");
+  button.querySelector("span").textContent = "Queueing";
+  button.disabled = true;
+  try {
+    const run = await requestJSON("/api/runs", {
+      method: "POST",
+      body: JSON.stringify(collectConfig()),
+    });
+    showToast(`Run ${run.id.slice(0, 8)} entered the local queue.`);
+    await refreshRuns();
+    document.getElementById("runs").scrollIntoView({ behavior: "smooth", block: "start" });
+  } catch (error) {
+    const details = error.payload?.errors?.[0]?.message;
+    showToast(details || error.message);
+  } finally {
+    button.classList.remove("running");
+    button.querySelector("span").textContent = "Queue experiment";
+    button.disabled = !state.validation?.valid;
+  }
+}
+
+function short(value, size = 30) {
+  const text = String(value ?? "—");
+  return text.length > size ? `${text.slice(0, size - 1)}…` : text;
+}
+
+function formatPercent(value) {
+  return Number.isFinite(value) ? `${(value * 100).toFixed(1)}%` : "—";
+}
+
+function tableCell(row, text, className = "") {
+  const cell = document.createElement("td");
+  cell.textContent = text;
+  if (className) cell.className = className;
+  row.append(cell);
+  return cell;
+}
+
+function renderRuns(runs) {
+  const body = el("runs-body");
+  body.replaceChildren();
+  if (!runs.length) {
+    const row = document.createElement("tr");
+    const cell = tableCell(row, "No experiments queued in this session.", "empty-row");
+    cell.colSpan = 7;
+    body.append(row);
+    el("queue-summary").textContent = "No active runs";
+    return;
+  }
+  let active = 0;
+  for (const run of runs) {
+    if (["queued", "running"].includes(run.status)) active += 1;
+    const row = document.createElement("tr");
+    tableCell(row, run.id.slice(0, 8));
+    tableCell(row, short(run.config.release_id, 28));
+    tableCell(row, short(run.config.dataset_id, 24));
+    const statusCell = document.createElement("td");
+    const status = document.createElement("span");
+    status.className = `run-table-status ${run.status}`;
+    status.textContent = run.status.replaceAll("_", " ");
+    statusCell.append(status);
+    row.append(statusCell);
+    const quality = run.result?.summary?.quality?.treatment;
+    tableCell(row, formatPercent(quality));
+    const cost = run.result?.summary?.usage?.cost_usd;
+    tableCell(row, Number.isFinite(cost) ? `$${cost.toFixed(4)}` : "—");
+    const linkCell = document.createElement("td");
+    const link = document.createElement("a");
+    link.className = "result-link";
+    link.href = `/result?run=${encodeURIComponent(run.id)}`;
+    link.textContent = "Open →";
+    linkCell.append(link);
+    row.append(linkCell);
+    body.append(row);
+  }
+  state.activeRuns = active;
+  el("queue-summary").textContent = active ? `${active} active · ${runs.length} recorded` : `${runs.length} recorded · queue idle`;
+}
+
+async function refreshRuns() {
+  try {
+    const payload = await requestJSON("/api/runs");
+    renderRuns(payload.runs);
+  } catch (error) {
+    showToast(`Run queue unavailable: ${error.message}`);
+  }
+}
+
+function showToast(message) {
+  const toast = el("toast");
+  toast.textContent = message;
+  toast.classList.add("visible");
+  clearTimeout(state.toastTimer);
+  state.toastTimer = setTimeout(() => toast.classList.remove("visible"), 3600);
+}
+
+async function init() {
+  setupSteps();
+  try {
+    const [catalog] = await Promise.all([
+      requestJSON("/api/catalog"),
+      requestJSON("/api/health"),
+    ]);
+    state.catalog = catalog;
+    populateCatalog();
+    bindInputs();
+    scheduleValidation();
+    await refreshRuns();
+  } catch (error) {
+    el("api-dot").classList.add("offline");
+    el("catalog-count").textContent = "Studio API unavailable";
+    showToast(error.message);
+  }
+  setInterval(() => {
+    if (!document.hidden && state.activeRuns > 0) refreshRuns();
+  }, 1500);
+}
+
+document.addEventListener("DOMContentLoaded", init);

agentinputlab/studio/static/campaigns.html

@@ -0,0 +1,175 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="color-scheme" content="dark">
+    <title>Research campaigns · AgentInputLab Studio</title>
+    <link rel="stylesheet" href="/styles.css">
+    <script src="/campaigns.js" defer></script>
+  </head>
+  <body>
+    <div class="app-shell">
+      <aside class="sidebar">
+        <a class="brand" href="/" aria-label="AgentInputLab Studio home">
+          <span class="brand-mark" aria-hidden="true">AI</span>
+          <span><strong>AgentInputLab</strong><small>Experiment Studio</small></span>
+        </a>
+        <nav class="primary-nav" aria-label="Studio navigation">
+          <a class="nav-link" href="/#configure"><span>01</span>Configure</a>
+          <a class="nav-link active" href="/campaigns"><span>02</span>Campaigns</a>
+          <a class="nav-link" href="/#runs"><span>03</span>Run queue</a>
+          <a class="nav-link" href="/result"><span>04</span>Results</a>
+        </nav>
+        <div class="sidebar-spacer"></div>
+        <div class="local-policy">
+          <div class="policy-heading">
+            <span class="status-dot" id="campaign-api-dot"></span>Server allowlist
+          </div>
+          <p>Profiles, paths, drivers, and environment bindings are fixed at startup—not entered here.</p>
+        </div>
+        <div class="build-label">STUDIO / CAMPAIGNS 01</div>
+      </aside>
+
+      <main class="main-canvas campaign-canvas">
+        <header class="topbar entrance">
+          <div>
+            <p class="eyebrow">RESEARCH CAMPAIGN CONTROL</p>
+            <h1>Frozen plans, explicit starts</h1>
+            <p class="campaign-subtitle">
+              Inspect allowlisted experiment blueprints and resolve every blocker before a separate execution confirmation.
+            </p>
+          </div>
+          <div class="topbar-meta">
+            <span id="campaign-profile-count">Loading profiles…</span>
+            <span class="local-chip" id="campaign-mode-state">PREFLIGHT ONLY</span>
+          </div>
+        </header>
+
+        <section class="campaign-workspace entrance entrance-delay-1" aria-label="Campaign preparation workspace">
+          <aside class="campaign-profile-rail">
+            <div class="campaign-section-heading">
+              <p class="section-index">01 / ALLOWLIST</p>
+              <h2>Profiles</h2>
+              <p>Only server-configured identities appear.</p>
+            </div>
+            <div id="campaign-profile-list" class="campaign-profile-list" role="listbox" aria-label="Campaign profiles"></div>
+          </aside>
+
+          <section class="campaign-plan-pane">
+            <div id="campaign-unconfigured" class="campaign-empty-state" hidden>
+              <span aria-hidden="true">↳</span>
+              <h2>Campaign mode is not configured</h2>
+              <p>Restart Studio with a server-side profile catalog. The ordinary tiny offline Studio remains available.</p>
+            </div>
+
+            <div id="campaign-profile-content">
+              <div class="campaign-profile-header">
+                <div>
+                  <p class="section-index">02 / PREFLIGHT + PLAN</p>
+                  <h2 id="campaign-profile-name">Select a profile</h2>
+                  <p id="campaign-profile-description">Choose one server allowlisted campaign to inspect its frozen blueprint.</p>
+                </div>
+                <button id="campaign-preflight-button" class="primary-action" type="button" disabled>
+                  <span>Preflight and plan</span><b aria-hidden="true">↗</b>
+                </button>
+              </div>
+
+              <dl class="campaign-identity-line">
+                <div><dt>Profile identity</dt><dd id="campaign-profile-identity">—</dd></div>
+                <div><dt>Blueprint</dt><dd id="campaign-blueprint-identity">—</dd></div>
+                <div><dt>Arm catalog</dt><dd id="campaign-arm-catalog-identity">—</dd></div>
+              </dl>
+
+              <div class="campaign-plan-status">
+                <div>
+                  <span class="validation-state waiting" id="campaign-preflight-state">NOT RUN</span>
+                  <h3 id="campaign-preflight-title">No materialized plan</h3>
+                  <p id="campaign-preflight-copy">Preflight checks assets and drivers without executing a benchmark cell.</p>
+                </div>
+                <dl class="campaign-stat-strip">
+                  <div><dt>Cells</dt><dd id="campaign-stat-cells">—</dd></div>
+                  <div><dt>Targets</dt><dd id="campaign-stat-targets">—</dd></div>
+                  <div><dt>Arms</dt><dd id="campaign-stat-arms">—</dd></div>
+                  <div><dt>Models × seeds</dt><dd id="campaign-stat-grid">—</dd></div>
+                </dl>
+              </div>
+
+              <div class="campaign-detail-grid">
+                <section>
+                  <div class="campaign-subheading"><p class="section-index">READINESS</p><span id="campaign-blocker-count">0 blockers</span></div>
+                  <ul id="campaign-blockers" class="issue-list campaign-issue-list">
+                    <li class="ok">Select a profile, then materialize its exact plan.</li>
+                  </ul>
+                </section>
+                <section>
+                  <div class="campaign-subheading"><p class="section-index">ARMS</p><span id="campaign-study-stage">—</span></div>
+                  <div id="campaign-arms" class="campaign-arm-list">
+                    <p class="campaign-placeholder">Arm identities appear after preflight.</p>
+                  </div>
+                </section>
+              </div>
+
+              <section class="campaign-cells-section">
+                <div class="campaign-subheading">
+                  <div><p class="section-index">CELL PREVIEW</p><h3>Frozen execution units</h3></div>
+                  <span id="campaign-plan-identity">No plan hash</span>
+                </div>
+                <div class="campaign-table-wrap">
+                  <table class="runs-table campaign-cells-table">
+                    <thead>
+                      <tr><th>Cell</th><th>Benchmark</th><th>Unit</th><th>Model</th><th>Seed</th><th>Arms</th></tr>
+                    </thead>
+                    <tbody id="campaign-cells-body">
+                      <tr><td colspan="6" class="empty-row">Preflight has not materialized cells.</td></tr>
+                    </tbody>
+                  </table>
+                </div>
+              </section>
+
+              <section class="campaign-confirmation">
+                <div>
+                  <p class="section-index">03 / SEPARATE CONFIRMATION</p>
+                  <h2>Queue the frozen plan</h2>
+                  <p id="campaign-execution-note">
+                    Execution stays locked until the profile, assets, output root, and plan are ready.
+                  </p>
+                </div>
+                <div class="campaign-confirm-controls">
+                  <label class="campaign-confirm-check">
+                    <input id="campaign-confirm-checkbox" type="checkbox" disabled>
+                    <span>I reviewed the exact plan hash and intend to execute it.</span>
+                  </label>
+                  <button id="campaign-execute-button" class="primary-action" type="button" disabled>
+                    <span>Queue confirmed plan</span><b aria-hidden="true">↗</b>
+                  </button>
+                </div>
+              </section>
+            </div>
+          </section>
+        </section>
+
+        <section class="runs-section entrance entrance-delay-2" aria-labelledby="campaign-executions-title">
+          <div class="runs-heading">
+            <div>
+              <p class="eyebrow">CAMPAIGN QUEUE</p>
+              <h2 id="campaign-executions-title">Execution progress</h2>
+            </div>
+            <button class="text-button" id="campaign-refresh-executions" type="button">Refresh</button>
+          </div>
+          <div class="runs-table-wrap">
+            <table class="runs-table">
+              <thead>
+                <tr><th>Execution</th><th>Profile</th><th>Status</th><th>Progress</th><th>Plan</th><th>Result identity</th></tr>
+              </thead>
+              <tbody id="campaign-executions-body">
+                <tr><td colspan="6" class="empty-row">No campaign execution has been queued.</td></tr>
+              </tbody>
+            </table>
+          </div>
+        </section>
+      </main>
+    </div>
+    <div class="toast" id="campaign-toast" role="status" aria-live="polite"></div>
+  </body>
+</html>