@sanity/ailf-studio 1.3.1 → 1.4.0

package/dist/index.d.ts

@@ -318,6 +318,8 @@ interface ProvenanceData {
         id: string;
         label: string;
     }[];
+    /** Identity of the pipeline run that produced this report (D0032) */
+    runId: string;
     /** @deprecated Use `promptfooUrls` when available */
     promptfooUrl?: string;
     /** Per-mode Promptfoo share URLs (one per sub-eval) */
@@ -441,6 +443,16 @@ interface ArtifactRef {
     path: string;
     bytes?: number;
     entryCount?: number;
+    /**
+     * Added in W0047 / D0032. Missing on pre-W0047 legacy refs, in which case
+     * dispatchers must treat it as `"bulk"` (the only layout that existed then).
+     */
+    layout?: "bulk" | "per-entry";
+    /** Per-entry index (populated for `layout: "per-entry"` refs only). */
+    entries?: {
+        key: string;
+        bytes: number;
+    }[];
 }
 /** A single gap/recommendation from gap analysis */
 interface RecommendationGap {
@@ -539,11 +551,14 @@ interface PerModelData {
 interface SummaryData {
     /** Per-feature agent behavior data (only present when agentic mode ran) */
     agentBehavior?: FeatureAgentBehaviorData[] | null;
-    /** External artifact references — present when pipeline uploads to GCS (D0030) */
-    artifacts?: {
+    /** External artifact references — present when pipeline uploads to GCS (D0032) */
+    artifactManifest?: {
         testOutputs?: ArtifactRef;
         renderedPrompts?: ArtifactRef;
         rawResults?: ArtifactRef;
+        graderPrompts?: ArtifactRef;
+        taskDefinitions?: ArtifactRef;
+        evalResults?: ArtifactRef;
         traces?: ArtifactRef;
     };
     belowCritical: string[];

package/dist/index.js

@@ -734,6 +734,30 @@ function artifactRefSchema() {
         name: "entryCount",
         title: "Entry Count",
         type: "number"
+      }),
+      defineField4({
+        name: "layout",
+        title: "Layout",
+        type: "string",
+        options: { list: ["bulk", "per-entry"] }
+      }),
+      defineField4({
+        name: "entries",
+        title: "Per-Entry Index",
+        type: "array",
+        of: [
+          {
+            fields: [
+              defineField4({ name: "key", title: "Key", type: "string" }),
+              defineField4({
+                name: "bytes",
+                title: "Size (bytes)",
+                type: "number"
+              })
+            ],
+            type: "object"
+          }
+        ]
       })
     ],
     type: "object"
@@ -1650,7 +1674,7 @@ var reportSchema = defineType4({
           type: "array"
         }),
         defineField4({
-          description: "External artifact references \u2014 points to large data in GCS that was too big for inline storage (D0030).",
+          description: "External artifact references \u2014 points to large data in GCS that was too big for inline storage (D0032).",
           fields: [
             defineField4({
               ...artifactRefSchema(),
@@ -1667,14 +1691,29 @@ var reportSchema = defineType4({
               name: "rawResults",
               title: "Raw Results"
             }),
+            defineField4({
+              ...artifactRefSchema(),
+              name: "graderPrompts",
+              title: "Grader Prompts"
+            }),
+            defineField4({
+              ...artifactRefSchema(),
+              name: "taskDefinitions",
+              title: "Task Definitions"
+            }),
+            defineField4({
+              ...artifactRefSchema(),
+              name: "evalResults",
+              title: "Eval Results"
+            }),
             defineField4({
               ...artifactRefSchema(),
               name: "traces",
               title: "Traces"
             })
           ],
-          name: "artifacts",
-          title: "Artifacts",
+          name: "artifactManifest",
+          title: "Artifact Manifest",
           type: "object"
         })
       ],
@@ -5890,67 +5929,128 @@ import { useClient as useClient10 } from "sanity";
 
 // src/lib/useArtifactCache.ts
 import { useCallback as useCallback14, useRef as useRef5, useState as useState10 } from "react";
-function useArtifactCache(reportId, artifactRef) {
+function useArtifactCache(opts) {
+  const { runId, artifactRef, type } = opts;
   const cacheRef = useRef5(/* @__PURE__ */ new Map());
   const [status, setStatus] = useState10("idle");
   const [error, setError] = useState10(null);
-  const fetchingRef = useRef5(false);
-  const fetchArtifacts = useCallback14(async () => {
-    if (fetchingRef.current || cacheRef.current.size > 0) return;
-    if (!artifactRef) return;
-    fetchingRef.current = true;
-    setStatus("loading");
-    setError(null);
-    try {
-      const signingRes = await fetch(
-        `${ARTIFACT_API_BASE_URL}/artifacts/${encodeURIComponent(reportId)}?type=testOutputs`,
-        {
-          credentials: "omit",
-          headers: { Accept: "application/json" }
-        }
-      );
-      if (!signingRes.ok) {
-        const body = await signingRes.text().catch(() => "");
-        throw new Error(
-          `Artifact signing failed: ${signingRes.status} ${signingRes.statusText}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`
-        );
-      }
-      const envelope = await signingRes.json();
-      if (envelope.object === "error" || !envelope.url) {
-        throw new Error(
-          envelope.error?.message ?? "Invalid signing response \u2014 missing signed URL"
-        );
-      }
-      const artifactRes = await fetch(envelope.url, {
-        credentials: "omit"
-      });
-      if (!artifactRes.ok) {
-        throw new Error(
-          `GCS artifact fetch failed: ${artifactRes.status} ${artifactRes.statusText}`
-        );
+  const inFlight = useRef5(/* @__PURE__ */ new Set());
+  const BULK_KEY = "__bulk__";
+  const availableEntries = artifactRef?.entries?.map((e) => e.key) ?? [];
+  const fetchEntry = useCallback14(
+    async (key) => {
+      if (!artifactRef || !runId) return;
+      if (!artifactRef.layout || artifactRef.layout === "bulk") return;
+      if (cacheRef.current.has(key) || inFlight.current.has(key)) return;
+      inFlight.current.add(key);
+      setStatus("loading");
+      setError(null);
+      try {
+        const url = `${ARTIFACT_API_BASE_URL}/runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(type)}/${encodeURIComponent(key)}`;
+        const entry = await signAndFetch(url);
+        cacheRef.current.set(key, entry);
+        setStatus("ready");
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setStatus("error");
+      } finally {
+        inFlight.current.delete(key);
       }
-      const artifact = await artifactRes.json();
-      const map = /* @__PURE__ */ new Map();
-      for (const [key, entry] of Object.entries(artifact.entries)) {
-        map.set(key, entry);
+    },
+    [runId, artifactRef, type]
+  );
+  const fetchAll = useCallback14(async () => {
+    if (!artifactRef || !runId) return;
+    if (inFlight.current.has(BULK_KEY)) return;
+    if (!artifactRef.layout || artifactRef.layout === "bulk") {
+      if (cacheRef.current.size > 0) return;
+      inFlight.current.add(BULK_KEY);
+      setStatus("loading");
+      setError(null);
+      try {
+        const url = `${ARTIFACT_API_BASE_URL}/runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(type)}`;
+        const body = await signAndFetch(url);
+        const next = /* @__PURE__ */ new Map();
+        for (const [key, entry] of Object.entries(body.entries)) {
+          next.set(key, entry);
+        }
+        cacheRef.current = next;
+        setStatus("ready");
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setStatus("error");
+      } finally {
+        inFlight.current.delete(BULK_KEY);
       }
-      cacheRef.current = map;
-      setStatus("ready");
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(message);
-      setStatus("error");
-    } finally {
-      fetchingRef.current = false;
+      return;
     }
-  }, [reportId, artifactRef]);
-  const getOutput = useCallback14(
-    (taskId, modelId) => {
-      return cacheRef.current.get(`${taskId}::${modelId}`) ?? null;
-    },
+    const keys = artifactRef.entries?.map((e) => e.key) ?? [];
+    await Promise.all(keys.map((k) => fetchEntry(k)));
+  }, [runId, artifactRef, type, fetchEntry]);
+  const getEntry = useCallback14(
+    (key) => cacheRef.current.get(key) ?? null,
     []
   );
-  return { status, error, getOutput, fetchArtifacts };
+  return {
+    status,
+    error,
+    availableEntries,
+    getEntry,
+    fetchEntry,
+    fetchAll
+  };
+}
+async function signAndFetch(signingUrl) {
+  const signingRes = await fetch(signingUrl, {
+    credentials: "omit",
+    headers: { Accept: "application/json" }
+  });
+  if (!signingRes.ok) {
+    const body = await signingRes.text().catch(() => "");
+    throw new Error(
+      `Artifact signing failed: ${signingRes.status} ${signingRes.statusText}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`
+    );
+  }
+  const envelope = await signingRes.json();
+  if (envelope.object === "error" || !envelope.url) {
+    throw new Error(
+      envelope.error?.message ?? "Invalid signing response \u2014 missing signed URL"
+    );
+  }
+  const artifactRes = await fetch(envelope.url, { credentials: "omit" });
+  if (!artifactRes.ok) {
+    throw new Error(
+      `GCS artifact fetch failed: ${artifactRes.status} ${artifactRes.statusText}`
+    );
+  }
+  return await artifactRes.json();
+}
+
+// src/lib/use-test-outputs-artifact.ts
+function useTestOutputsArtifact(runId, artifactRef) {
+  const cache = useArtifactCache({
+    runId,
+    artifactRef,
+    type: "testOutputs"
+  });
+  return {
+    status: cache.status,
+    error: cache.error,
+    getOutput: (taskId, modelId) => cache.getEntry(`${taskId}::${modelId}`),
+    fetchOutput: async (taskId, modelId) => {
+      if (!artifactRef) return;
+      if (!artifactRef.layout || artifactRef.layout === "bulk") {
+        await cache.fetchAll();
+        return;
+      }
+      await cache.fetchEntry(`${taskId}::${modelId}`);
+    },
+    hasOutput: (taskId, modelId) => {
+      if (!artifactRef) return false;
+      if (!artifactRef.layout || artifactRef.layout === "bulk") return true;
+      return cache.availableEntries.includes(`${taskId}::${modelId}`);
+    }
+  };
 }
 
 // src/lib/thresholds.ts
@@ -7160,8 +7260,10 @@ function JudgmentCard({
   );
   const resolvedOutput = inlineOutput ?? artifactEntry?.responseOutput ?? null;
   const resolvedTruncated = testResult?.responseOutputTruncated ?? artifactEntry?.responseOutputTruncated ?? false;
-  const canFetchArtifact = !inlineOutput && !artifactEntry && artifactCache != null && artifactCache.status !== "ready";
-  const hasOutputOrCanFetch = resolvedOutput != null || canFetchArtifact;
+  const entryKnownToManifest = artifactCache?.hasOutput(judgment.taskId, judgment.modelId) ?? false;
+  const canFetchArtifact = !inlineOutput && !artifactEntry && artifactCache != null && entryKnownToManifest;
+  const entryUnavailable = !inlineOutput && !artifactEntry && artifactCache != null && !entryKnownToManifest;
+  const hasOutputOrCanFetch = resolvedOutput != null || canFetchArtifact || entryUnavailable;
   useEffect8(() => {
     if (focused) {
       setExpanded(true);
@@ -7224,12 +7326,19 @@ function JudgmentCard({
   const handleToggleOutput = useCallback16(
     (e) => {
       e.stopPropagation();
-      if (!outputExpanded && !resolvedOutput && artifactCache) {
-        artifactCache.fetchArtifacts();
+      if (!outputExpanded && !resolvedOutput && artifactCache && entryKnownToManifest) {
+        artifactCache.fetchOutput(judgment.taskId, judgment.modelId);
       }
       setOutputExpanded((prev) => !prev);
     },
-    [outputExpanded, resolvedOutput, artifactCache]
+    [
+      outputExpanded,
+      resolvedOutput,
+      artifactCache,
+      entryKnownToManifest,
+      judgment.taskId,
+      judgment.modelId
+    ]
   );
   return /* @__PURE__ */ jsx28(
     Box16,
@@ -7368,8 +7477,9 @@ function JudgmentCard({
                   padding: 12
                 },
                 children: [
-                  !resolvedOutput && artifactCache?.status === "loading" && /* @__PURE__ */ jsx28(Text25, { muted: true, size: 1, children: "Fetching model output\u2026" }),
-                  !resolvedOutput && artifactCache?.status === "error" && /* @__PURE__ */ jsxs23(Text25, { muted: true, size: 1, style: { color: "#f87171" }, children: [
+                  !resolvedOutput && entryUnavailable && /* @__PURE__ */ jsx28(Text25, { muted: true, size: 1, children: "Model output not available for this entry." }),
+                  !resolvedOutput && !entryUnavailable && artifactCache?.status === "loading" && /* @__PURE__ */ jsx28(Text25, { muted: true, size: 1, children: "Fetching model output\u2026" }),
+                  !resolvedOutput && !entryUnavailable && artifactCache?.status === "error" && /* @__PURE__ */ jsxs23(Text25, { muted: true, size: 1, style: { color: "#f87171" }, children: [
                     "Failed to load model output",
                     artifactCache.error ? `: ${artifactCache.error}` : ""
                   ] }),
@@ -9323,9 +9433,9 @@ function ReportDetail({
       cancelled = true;
     };
   }, [client, reportId]);
-  const artifactCache = useArtifactCache(
-    reportId,
-    report?.summary?.artifacts?.testOutputs
+  const artifactCache = useTestOutputsArtifact(
+    report?.provenance?.runId,
+    report?.summary?.artifactManifest?.testOutputs
   );
   const { summary } = report ?? {};
   const hasWeaknesses = Boolean(

package/package.json

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