@sanity/ailf-studio 1.6.0 → 1.7.1

package/dist/index.d.ts

@@ -521,6 +521,15 @@ interface JudgmentData {
     /** Docs the task expected the model to use */
     canonicalDocs?: DocumentRef[];
     dimension: string;
+    /**
+     * `graderJudgments` manifest entry key = `formatEntryKey({mode, task,
+     * model, grader})` from the slim-report publisher. Present on reports
+     * published under W0051+. Consumed by `useArtifactDetail` in
+     * `JudgmentDetailDrawer` to hydrate the full reasoning from GCS, and by
+     * `JudgmentList` to drive hover-prefetch and the list row's data hook.
+     * Optional so legacy reports (pre-W0051) still type-check.
+     */
+    id?: string;
     modelId: string;
     /** True when the model failed to produce output (empty response, API error, refusal) */
     outputFailure?: boolean;
@@ -588,7 +597,6 @@ interface SummaryData {
         rawResults?: ArtifactRef;
         graderPrompts?: ArtifactRef;
         taskDefinitions?: ArtifactRef;
-        evalResults?: ArtifactRef;
         traces?: ArtifactRef;
     };
     belowCritical: string[];

package/dist/index.js

@@ -1701,11 +1701,6 @@ var reportSchema = defineType4({
               name: "taskDefinitions",
               title: "Task Definitions"
             }),
-            defineField4({
-              ...artifactRefSchema(),
-              name: "evalResults",
-              title: "Eval Results"
-            }),
             defineField4({
               ...artifactRefSchema(),
               name: "traces",
@@ -3285,7 +3280,7 @@ import {
   TabPanel as TabPanel3,
   Text as Text46
 } from "@sanity/ui";
-import { useCallback as useCallback36 } from "react";
+import { useCallback as useCallback36, useEffect as useEffect15 } from "react";
 import { useRouter as useRouter3 } from "sanity/router";
 
 // src/lib/help-context.ts
@@ -7162,6 +7157,7 @@ function cacheKey({ runId, type, key }) {
 }
 var hydratedEntries = /* @__PURE__ */ new Map();
 var inFlight = /* @__PURE__ */ new Map();
+var knownNotFound = /* @__PURE__ */ new Set();
 var subscribers = /* @__PURE__ */ new Map();
 function getCached(k) {
   const hit = hydratedEntries.get(cacheKey(k));
@@ -7195,6 +7191,12 @@ function recordInFlight(k, start) {
   inFlight.set(composite, p);
   return p;
 }
+function markNotFound(k) {
+  knownNotFound.add(cacheKey(k));
+}
+function isKnownNotFound(k) {
+  return knownNotFound.has(cacheKey(k));
+}
 function notify(composite) {
   const set2 = subscribers.get(composite);
   if (!set2) return;
@@ -7202,6 +7204,14 @@ function notify(composite) {
 }
 
 // src/lib/artifact-fetch.ts
+var ArtifactHttpError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "ArtifactHttpError";
+    this.status = status;
+  }
+};
 function buildSigningUrl(runId, type, entryKey) {
   const base = `${ARTIFACT_API_BASE_URL}/runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(type)}`;
   return entryKey === void 0 ? base : `${base}/${encodeURIComponent(entryKey)}`;
@@ -7210,8 +7220,9 @@ async function signAndFetchJson(signingUrl) {
   const signed = await exchangeSigningUrl(signingUrl);
   const res = await fetch(signed, { credentials: "omit" });
   if (!res.ok) {
-    throw new Error(
-      `GCS artifact fetch failed: ${res.status} ${res.statusText}`
+    throw new ArtifactHttpError(
+      `GCS artifact fetch failed: ${res.status} ${res.statusText}`,
+      res.status
     );
   }
   return await res.json();
@@ -7220,8 +7231,9 @@ async function signAndFetchNdjson(signingUrl) {
   const signed = await exchangeSigningUrl(signingUrl);
   const res = await fetch(signed, { credentials: "omit" });
   if (!res.ok) {
-    throw new Error(
-      `GCS artifact fetch failed: ${res.status} ${res.statusText}`
+    throw new ArtifactHttpError(
+      `GCS artifact fetch failed: ${res.status} ${res.statusText}`,
+      res.status
     );
   }
   const body = await res.text();
@@ -7239,6 +7251,36 @@ async function signAndFetchNdjson(signingUrl) {
   }
   return rows;
 }
+async function fetchBatchReadUrls(runId, type, keys) {
+  const res = await fetch(
+    `${ARTIFACT_API_BASE_URL}/runs/${encodeURIComponent(runId)}/artifacts/batch/read-urls`,
+    {
+      method: "POST",
+      credentials: "omit",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ types: [type], keys: { [type]: keys } })
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      `Batch signing failed: ${res.status} ${res.statusText}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`
+    );
+  }
+  const envelope = await res.json();
+  if (envelope.object === "error" || !envelope.urls) {
+    throw new Error(
+      envelope.error?.message ?? "Invalid batch signing response \u2014 missing urls"
+    );
+  }
+  const entries = envelope.urls[type];
+  if (!entries) return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(entries)) {
+    out[key] = entry.url;
+  }
+  return out;
+}
 async function exchangeSigningUrl(signingUrl) {
   const res = await fetch(signingUrl, {
     credentials: "omit",
@@ -7246,8 +7288,9 @@ async function exchangeSigningUrl(signingUrl) {
   });
   if (!res.ok) {
     const body = await res.text().catch(() => "");
-    throw new Error(
-      `Artifact signing failed: ${res.status} ${res.statusText}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`
+    throw new ArtifactHttpError(
+      `Artifact signing failed: ${res.status} ${res.statusText}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`,
+      res.status
     );
   }
   const envelope = await res.json();
@@ -7279,21 +7322,29 @@ function useArtifactDetail(type, key) {
   }, [runId, type, key]);
   const request = useCallback16(async () => {
     if (!runId || !ref || !key) return;
-    const hit = getCached({ runId, type, key });
+    const cacheId = { runId, type, key };
+    if (isKnownNotFound(cacheId)) {
+      setStatus("error");
+      return;
+    }
+    const hit = getCached(cacheId);
     if (hit !== null) {
       setStatus("ready");
       return;
     }
     setStatus("loading");
     try {
-      await recordInFlight({ runId, type, key }, async () => {
+      await recordInFlight(cacheId, async () => {
         const url = buildSigningUrl(runId, type, key);
         const body = NDJSON_TYPES.has(type) ? await signAndFetchNdjson(url) : await signAndFetchJson(url);
-        setCached({ runId, type, key }, body);
+        setCached(cacheId, body);
         return body;
       });
       setStatus("ready");
-    } catch {
+    } catch (err) {
+      if (err instanceof ArtifactHttpError && err.status === 404) {
+        markNotFound(cacheId);
+      }
       setStatus("error");
     }
   }, [runId, ref, type, key]);
@@ -7328,33 +7379,73 @@ import { useCallback as useCallback17, useMemo as useMemo7 } from "react";
 var NDJSON_TYPES2 = /* @__PURE__ */ new Set([
   "traces"
 ]);
+var HOVER_DEBOUNCE_MS = 200;
+var MAX_CONCURRENT_PREFETCHES = 4;
+var pendingHoverTimers = /* @__PURE__ */ new Map();
+var activePrefetches = 0;
+var prefetchWaitQueue = [];
+async function withPrefetchSlot(run) {
+  if (activePrefetches >= MAX_CONCURRENT_PREFETCHES) {
+    await new Promise((resolve) => prefetchWaitQueue.push(resolve));
+  }
+  activePrefetches++;
+  try {
+    return await run();
+  } finally {
+    activePrefetches--;
+    const next = prefetchWaitQueue.shift();
+    if (next) next();
+  }
+}
+async function prefetchArtifactCore(args) {
+  const { runId, type, key } = args;
+  if (!runId || !key) return;
+  const cacheId = { runId, type, key };
+  if (isKnownNotFound(cacheId)) return;
+  if (getCached(cacheId) !== null) return;
+  try {
+    await recordInFlight(
+      cacheId,
+      () => withPrefetchSlot(async () => {
+        const url = buildSigningUrl(runId, type, key);
+        const body = NDJSON_TYPES2.has(type) ? await signAndFetchNdjson(url) : await signAndFetchJson(url);
+        setCached(cacheId, body);
+        return body;
+      })
+    );
+  } catch (err) {
+    if (err instanceof ArtifactHttpError && err.status === 404) {
+      markNotFound(cacheId);
+    }
+  }
+}
+function scheduleHoverPrefetch(type, run, debounceMs = HOVER_DEBOUNCE_MS) {
+  const existing = pendingHoverTimers.get(type);
+  if (existing) clearTimeout(existing);
+  const timer = setTimeout(() => {
+    pendingHoverTimers.delete(type);
+    run();
+  }, debounceMs);
+  pendingHoverTimers.set(type, timer);
+}
 function useArtifactPrefetch(type) {
   const { runId } = useReportArtifactContext();
   const ref = useArtifactRef(type);
   const prefetch = useCallback17(
     async (key) => {
       if (!runId || !ref || !key) return;
-      const cached = getCached({ runId, type, key });
-      if (cached !== null) return;
-      try {
-        await recordInFlight({ runId, type, key }, async () => {
-          const url = buildSigningUrl(runId, type, key);
-          const body = NDJSON_TYPES2.has(type) ? await signAndFetchNdjson(url) : await signAndFetchJson(url);
-          setCached({ runId, type, key }, body);
-          return body;
-        });
-      } catch {
-      }
+      await prefetchArtifactCore({ runId, type, key });
     },
     [runId, ref, type]
   );
   const onHover = useCallback17(
     (key) => {
       return () => {
-        void prefetch(key);
+        if (!runId || !ref || !key) return;
+        scheduleHoverPrefetch(type, () => void prefetch(key));
       };
     },
-    [prefetch]
+    [runId, ref, type, prefetch]
   );
   const prefetchWindow = useCallback17(
     async (keys, centerIndex, radius = 5) => {
@@ -7372,49 +7463,28 @@ function useArtifactPrefetch(type) {
         (k) => getCached({ runId, type, key: k }) === null
       );
       if (pending.length === 0) return;
-      const batchUrls = await tryBatchSign(runId, type, pending);
-      if (batchUrls) {
-        await Promise.all(
-          Object.entries(batchUrls).map(async ([k, signedUrl]) => {
-            await recordInFlight({ runId, type, key: k }, async () => {
-              const body = await fetchSigned(signedUrl, NDJSON_TYPES2.has(type));
-              setCached({ runId, type, key: k }, body);
-              return body;
-            });
-          })
-        );
-        return;
-      }
-      for (const k of pending) {
-        await prefetch(k);
-      }
+      const signedByKey = await fetchBatchReadUrls(runId, type, pending);
+      await Promise.all(
+        Object.entries(signedByKey).map(async ([k, signedUrl]) => {
+          await recordInFlight({ runId, type, key: k }, async () => {
+            const body = await fetchSignedBody(
+              signedUrl,
+              NDJSON_TYPES2.has(type)
+            );
+            setCached({ runId, type, key: k }, body);
+            return body;
+          });
+        })
+      );
     },
-    [runId, ref, type, prefetch]
+    [runId, ref, type]
   );
   return useMemo7(
     () => ({ prefetch, onHover, prefetchWindow, warmAll }),
     [prefetch, onHover, prefetchWindow, warmAll]
   );
 }
-async function tryBatchSign(runId, type, keys) {
-  try {
-    const res = await fetch(
-      `${ARTIFACT_API_BASE_URL}/runs/${encodeURIComponent(runId)}/artifacts/batch/read-urls`,
-      {
-        method: "POST",
-        credentials: "omit",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ types: [type], keys: { [type]: keys } })
-      }
-    );
-    if (!res.ok) return null;
-    const body = await res.json();
-    return body.urls?.[type] ?? null;
-  } catch {
-    return null;
-  }
-}
-async function fetchSigned(signedUrl, ndjson) {
+async function fetchSignedBody(signedUrl, ndjson) {
   const res = await fetch(signedUrl, { credentials: "omit" });
   if (!res.ok) {
     throw new Error(
@@ -8190,12 +8260,15 @@ function JudgmentList({
     }
   }, [flatSlugs, activeRowSlug]);
   const { close: closeDrawer, open: openDrawer } = useJudgmentDrawer();
+  const { runId: artifactRunId, manifest: artifactManifest } = useReportArtifactContext();
   useEffect9(() => {
     if (focus && focusedJudgment) {
       openDrawer({
         artifactCache,
         judgment: focusedJudgment,
-        testResult: focusedTestResult
+        testResult: focusedTestResult,
+        runId: artifactRunId,
+        manifest: artifactManifest
       });
     } else if (!focus) {
       closeDrawer();
@@ -8206,7 +8279,9 @@ function JudgmentList({
     focusedTestResult,
     artifactCache,
     openDrawer,
-    closeDrawer
+    closeDrawer,
+    artifactRunId,
+    artifactManifest
   ]);
   const prevFocusRef = useRef6(focus);
   useEffect9(() => {
@@ -8508,14 +8583,18 @@ function JudgmentCard({
     },
     [handleClick]
   );
+  const onHoverTestOutputs = useMemo9(
+    () => testOutputsKey ? testOutputsPrefetch.onHover(testOutputsKey) : null,
+    [testOutputsPrefetch, testOutputsKey]
+  );
   const handleMouseEnter = useCallback21(() => {
     row.handlers.onMouseEnter();
-    if (testOutputsKey) void testOutputsPrefetch.prefetch(testOutputsKey);
-  }, [row.handlers, testOutputsPrefetch, testOutputsKey]);
+    onHoverTestOutputs?.();
+  }, [row.handlers, onHoverTestOutputs]);
   const handleFocusPrefetch = useCallback21(() => {
     row.handlers.onFocus();
-    if (testOutputsKey) void testOutputsPrefetch.prefetch(testOutputsKey);
-  }, [row.handlers, testOutputsPrefetch, testOutputsKey]);
+    onHoverTestOutputs?.();
+  }, [row.handlers, onHoverTestOutputs]);
   return /* @__PURE__ */ jsx32(
     Box18,
     {
@@ -11218,6 +11297,16 @@ function JudgmentDetailDrawer({
   const rawTaskName = sep > 0 ? judgment.taskId.substring(sep + 3) : judgment.taskId;
   const { name: taskName, variant } = splitVariant(rawTaskName);
   const dimLabel = dimensionLabel2(judgment.dimension);
+  const judgmentId = judgment.id ?? "";
+  const [fullJudgment, fullStatus, requestFullJudgment] = useArtifactDetail("graderJudgments", judgmentId);
+  useEffect12(() => {
+    if (!judgmentId) return;
+    if (fullStatus !== "idle") return;
+    void requestFullJudgment();
+  }, [judgmentId, fullStatus, requestFullJudgment]);
+  const fullReason = typeof fullJudgment?.reason === "string" && fullJudgment.reason.length > 0 ? fullJudgment.reason : null;
+  const reasoningText = fullReason ?? judgment.reason;
+  const reasoningIsPreview = fullReason === null && judgmentId.length > 0 && fullStatus !== "error";
   useEffect12(() => {
     setTab("reasoning");
   }, [judgment.taskId, judgment.dimension, judgment.modelId]);
@@ -11449,10 +11538,11 @@ function JudgmentDetailDrawer({
                   {
                     copiedLabel: "Reasoning copied",
                     label: "Copy reasoning",
-                    text: judgment.reason
+                    text: reasoningText
                   }
                 ) }),
-                /* @__PURE__ */ jsx59(Markdown, { content: judgment.reason })
+                /* @__PURE__ */ jsx59(Markdown, { content: reasoningText }),
+                reasoningIsPreview && /* @__PURE__ */ jsx59(Text44, { muted: true, size: 1, style: { marginTop: 8 }, children: fullStatus === "loading" ? "Loading full reasoning\u2026" : "Showing preview (280 chars). Full reasoning not yet loaded." })
               ] })
             }
           ),
@@ -11625,7 +11715,7 @@ function JudgmentDetailDrawerOutlet({
               flexDirection: "column",
               overflow: "hidden"
             },
-            children: /* @__PURE__ */ jsx60(
+            children: /* @__PURE__ */ jsx60(ReportArtifactProvider, { runId: active.runId, manifest: active.manifest, children: /* @__PURE__ */ jsx60(
               JudgmentDetailDrawer,
               {
                 artifactCache: active.artifactCache,
@@ -11633,7 +11723,7 @@ function JudgmentDetailDrawerOutlet({
                 onClose,
                 testResult: active.testResult
               }
-            )
+            ) })
           }
         )
       ]
@@ -11869,17 +11959,29 @@ var VIEW_PARAM_MAP = {
   timeline: "timeline"
 };
 function Dashboard() {
+  return /* @__PURE__ */ jsx62(HelpProvider, { children: /* @__PURE__ */ jsx62(JudgmentDrawerProvider, { children: /* @__PURE__ */ jsx62(DashboardShell, {}) }) });
+}
+function DashboardShell() {
   const router = useRouter3();
+  const { close: closeDrawer } = useJudgmentDrawer();
+  const routerState = router.state;
+  const reportId = routerState.reportId ?? null;
+  useEffect15(() => {
+    if (!reportId) closeDrawer();
+  }, [reportId, closeDrawer]);
   const handleJudgmentDrawerClose = useCallback36(() => {
+    closeDrawer();
     const state = { ...router.state };
-    delete state.focus;
-    router.navigate(state);
-  }, [router]);
-  return /* @__PURE__ */ jsx62(HelpProvider, { children: /* @__PURE__ */ jsx62(JudgmentDrawerProvider, { children: /* @__PURE__ */ jsxs45(Flex34, { style: { height: "100%" }, children: [
+    if (state.focus) {
+      delete state.focus;
+      router.navigate(state);
+    }
+  }, [closeDrawer, router]);
+  return /* @__PURE__ */ jsxs45(Flex34, { style: { height: "100%" }, children: [
     /* @__PURE__ */ jsx62(Box29, { flex: 1, overflow: "auto", children: /* @__PURE__ */ jsx62(DashboardContent, {}) }),
     /* @__PURE__ */ jsx62(JudgmentDetailDrawerOutlet, { onClose: handleJudgmentDrawerClose }),
     /* @__PURE__ */ jsx62(HelpDrawer, {})
-  ] }) }) });
+  ] });
 }
 function DashboardContent() {
   const router = useRouter3();
@@ -12012,7 +12114,7 @@ function ailfTool(options = {}) {
 // src/actions/RunEvaluationAction.tsx
 import { BarChartIcon as BarChartIcon2 } from "@sanity/icons";
 import { useToast as useToast10 } from "@sanity/ui";
-import { useCallback as useCallback37, useEffect as useEffect15, useRef as useRef9, useState as useState27 } from "react";
+import { useCallback as useCallback37, useEffect as useEffect16, useRef as useRef9, useState as useState27 } from "react";
 import {
   getReleaseIdFromReleaseDocumentId as getReleaseIdFromReleaseDocumentId3,
   useClient as useClient12,
@@ -12046,7 +12148,7 @@ function createRunEvaluationAction(options = {}) {
     const [state, setState] = useState27({ status: "loading" });
     const requestedAtRef = useRef9(null);
     const perspectiveId = getReleaseIdFromReleaseDocumentId3(release._id);
-    useEffect15(() => {
+    useEffect16(() => {
       let cancelled = false;
       client.fetch(contentImpactQuery, buildReportQueryParams(perspectiveId)).then((results) => {
         if (cancelled) return;
@@ -12069,7 +12171,7 @@ function createRunEvaluationAction(options = {}) {
         cancelled = true;
       };
     }, [client, perspectiveId]);
-    useEffect15(() => {
+    useEffect16(() => {
       if (state.status !== "requested" && state.status !== "polling") return;
       const { requestId, startedAt } = state;
       if (state.status === "requested") {
@@ -12119,7 +12221,7 @@ function createRunEvaluationAction(options = {}) {
       }, POLL_INTERVAL_MS2);
       return () => clearInterval(interval);
     }, [client, perspectiveId, state]);
-    useEffect15(() => {
+    useEffect16(() => {
       if (state.status !== "error") return;
       const timer = setTimeout(() => {
         client.fetch(contentImpactQuery, buildReportQueryParams(perspectiveId)).then((results) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/ailf-studio",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "AI Literacy Framework — Sanity Studio dashboard plugin",
   "type": "module",
   "license": "MIT",