@atlanai/sdk 0.2.2 → 0.2.3

package/dist/evals.js

@@ -62,6 +62,9 @@ function manifestItem(item) {
     if (item.version.toLowerCase() === "latest") {
         throw new Error("context item version must be pinned; 'latest' is not a version");
     }
+    if (item.artifactKind !== undefined && !CONTEXT_KIND.test(item.artifactKind)) {
+        throw new Error("context item artifactKind must be a lowercase identifier");
+    }
     if (item.artifactId !== undefined) {
         validText(item.artifactId, "context item artifactId", 200);
     }
@@ -69,11 +72,18 @@ function manifestItem(item) {
         (!Number.isInteger(item.versionOrdinal) || item.versionOrdinal < 1)) {
         throw new Error("context item versionOrdinal must be an integer of at least 1");
     }
+    if ((item.artifactId === undefined) !== (item.versionOrdinal === undefined)) {
+        throw new Error("context item Registry pins require artifactId and versionOrdinal");
+    }
+    if (item.artifactKind !== undefined && item.artifactId === undefined) {
+        throw new Error("context item artifactKind requires a Registry artifact pin");
+    }
     return {
         kind: item.kind,
         name: item.name,
         digest: item.digest,
         version: item.version,
+        ...(item.artifactKind === undefined ? {} : { artifact_kind: item.artifactKind }),
         ...(item.artifactId === undefined ? {} : { artifact_id: item.artifactId }),
         ...(item.versionOrdinal === undefined ? {} : { version_ordinal: item.versionOrdinal }),
     };
@@ -237,7 +247,7 @@ async function startExperiment(client, dataset, body, options = {}) {
 }
 // ---------------------------------------------------------------------------
 // Declarative evaluator
-const DEFAULT_GATEWAY_ORIGIN = "https://agentgateway.atlan.engineering";
+const DEFAULT_GATEWAY_ORIGIN = "https://api.atlan.com";
 function tracingModule() {
     // The root client is CommonJS while tracing has its own NodeNext build. A
     // runtime require keeps the two compiler targets independent and resolves to
@@ -311,6 +321,20 @@ async function collectData(data) {
     }
     return cases;
 }
+async function casesDigest(cases) {
+    const normalized = cases.map((item, index) => ({
+        id: item.id ?? `case-${index + 1}`,
+        input: item.input,
+        expected: item.expected ?? null,
+        metadata: item.metadata ?? {},
+        tags: item.tags ?? [],
+    }));
+    if (new Set(normalized.map((item) => item.id)).size !== cases.length) {
+        throw new Error("Eval case IDs must be unique");
+    }
+    const hash = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonicalJson(normalized)));
+    return "sha256:" + [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
 async function datasetCases(resources, datasetId) {
     const records = [];
     let offset = 0;
@@ -394,11 +418,6 @@ async function experimentResults(resources, experimentId) {
     }
     return results;
 }
-async function existingCaseIds(resources, experimentId) {
-    return new Set((await experimentResults(resources, experimentId))
-        .map((item) => field(item, "caseId"))
-        .filter((caseId) => typeof caseId === "string" && caseId.length > 0));
-}
 async function findScorer(resources, name, workspaceId) {
     const matches = [];
     let offset = 0;
@@ -434,6 +453,39 @@ function scorerIdentity(value, workspaceId) {
     }
     return { id, version };
 }
+async function scorerDefinition(definition) {
+    const outputs = definition.outputs ?? { [definition.name]: { type: "number", minimum: 0, maximum: 1 } };
+    if (definition.spec !== undefined)
+        return { spec: definition.spec, outputs };
+    if (!globalThis.crypto?.subtle)
+        throw new Error("Web Crypto is required to identify a scorer");
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(String(definition.scorer)));
+    const codeDigest = "sha256:" +
+        [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    return {
+        outputs,
+        spec: {
+            executor: "external",
+            sdk: "@atlanai/sdk",
+            entrypoint: definition.scorer.name || "anonymous",
+            code_digest: codeDigest,
+        },
+    };
+}
+async function reconcileScorer(resources, existing, workspaceId, definition) {
+    const identity = scorerIdentity(existing, workspaceId);
+    const scorerKind = definition.scorerKind ?? "code";
+    const scope = definition.scope ?? "result";
+    if (field(existing, "scorerKind") !== scorerKind || field(existing, "scope") !== scope) {
+        throw new Error(`scorer '${definition.name}' reuses a Registry name with a different identity`);
+    }
+    const desired = await scorerDefinition(definition);
+    if (canonicalJson(field(existing, "spec")) === canonicalJson(desired.spec) &&
+        canonicalJson(field(existing, "outputs")) === canonicalJson(desired.outputs)) {
+        return identity;
+    }
+    return scorerIdentity(await resources.scorers.update(identity.id, desired), workspaceId);
+}
 async function resolveScorer(resources, workspaceId, evalName, definition) {
     if (!definition.name || /[\r\n]/.test(definition.name)) {
         throw new Error("each scorer needs a non-empty single-line name");
@@ -448,7 +500,7 @@ async function resolveScorer(resources, workspaceId, evalName, definition) {
             if (!Number.isInteger(definition.scorerVersion) || definition.scorerVersion < 1) {
                 throw new Error(`scorer '${definition.name}' has an invalid scorerVersion`);
             }
-            return { id: identity.id, version: definition.scorerVersion };
+            return scorerIdentity(await resources.scorers.versions.get(identity.id, definition.scorerVersion), workspaceId);
         }
         return identity;
     }
@@ -457,8 +509,10 @@ async function resolveScorer(resources, workspaceId, evalName, definition) {
     }
     const artifactName = definition.registryName ?? `${slug(evalName, "eval")}-${slug(definition.name, "score")}`;
     const existing = await findScorer(resources, artifactName, workspaceId);
-    if (existing !== undefined)
-        return scorerIdentity(existing, workspaceId);
+    if (existing !== undefined) {
+        return reconcileScorer(resources, existing, workspaceId, definition);
+    }
+    const desired = await scorerDefinition(definition);
     try {
         return scorerIdentity(await resources.scorers.create({
             workspaceId,
@@ -468,12 +522,8 @@ async function resolveScorer(resources, workspaceId, evalName, definition) {
             sourceId: `atlan-eval:${slug(evalName, "eval")}:${slug(definition.name, "score")}`,
             scorerKind: definition.scorerKind ?? "code",
             scope: definition.scope ?? "result",
-            outputs: definition.outputs ?? { [definition.name]: { type: "number", minimum: 0, maximum: 1 } },
-            spec: definition.spec ?? {
-                executor: "external",
-                sdk: "@atlanai/sdk",
-                entrypoint: definition.scorer.name || "anonymous",
-            },
+            outputs: desired.outputs,
+            spec: desired.spec,
         }), workspaceId);
     }
     catch (error) {
@@ -482,7 +532,7 @@ async function resolveScorer(resources, workspaceId, evalName, definition) {
         const raced = await findScorer(resources, artifactName, workspaceId);
         if (raced === undefined)
             throw error;
-        return scorerIdentity(raced, workspaceId);
+        return reconcileScorer(resources, raced, workspaceId, definition);
     }
 }
 function normalizedScores(value, defaultName) {
@@ -546,12 +596,41 @@ function localSummary(results, durationMs) {
         },
     };
 }
+async function traceSpans(resources, experimentId, traceId) {
+    const spans = [];
+    const seenCursors = new Set();
+    let cursor;
+    while (true) {
+        const page = await resources.experiments.traces.listSpans({
+            experimentId,
+            traceId,
+            limit: 500,
+            fields: "io",
+            ...(cursor === undefined ? {} : { cursor }),
+        });
+        const items = field(page, "items");
+        if (Array.isArray(items))
+            spans.push(...items);
+        const nextCursor = field(field(page, "page"), "nextCursor");
+        if (typeof nextCursor !== "string" || nextCursor.length === 0)
+            return spans;
+        if (seenCursors.has(nextCursor)) {
+            throw new Error("experiment trace span pagination repeated a cursor");
+        }
+        seenCursors.add(nextCursor);
+        cursor = nextCursor;
+    }
+}
 async function listedTraceIds(resources, experimentId) {
     const traceIds = new Set();
     const seenCursors = new Set();
     let cursor;
+    const windowEnd = Math.floor(Date.now() / 1_000);
     while (true) {
-        const page = await resources.experiments.traces.list(experimentId, {
+        const page = await resources.experiments.traces.list({
+            experimentId,
+            startTimeUnixSeconds: windowEnd - 30 * 24 * 60 * 60,
+            endTimeUnixSeconds: windowEnd,
             limit: 500,
             ...(cursor === undefined ? {} : { cursor }),
         });
@@ -573,14 +652,73 @@ async function listedTraceIds(resources, experimentId) {
         cursor = nextCursor;
     }
 }
-async function verifyTraceJoins(resources, experimentId, expected, timeoutMs) {
+function spanAttributes(span) {
+    const attributes = field(span, "attributes");
+    return isRecord(attributes) ? attributes : {};
+}
+function missingTraceEvidence(spans, expected) {
+    const missing = [];
+    const byId = new Map();
+    for (const span of spans) {
+        const spanId = field(span, "spanId");
+        if (typeof spanId === "string")
+            byId.set(spanId, span);
+    }
+    const root = expected.rootSpanId === undefined
+        ? spans.find((span) => spanAttributes(span)["atlan.eval.case_id"] === expected.caseId &&
+            spanAttributes(span)["atlan.eval.evidence_complete"] === true)
+        : byId.get(expected.rootSpanId);
+    if (root === undefined) {
+        missing.push("case root");
+    }
+    else {
+        const attributes = spanAttributes(root);
+        if (attributes["atlan.eval.evidence_complete"] !== true) {
+            missing.push("producer completion marker");
+        }
+        if (attributes["atlan.eval.case_id"] !== expected.caseId)
+            missing.push("case identity");
+        if (expected.datasetRecordId !== undefined &&
+            attributes["atlan.eval.dataset_record_id"] !== expected.datasetRecordId) {
+            missing.push("dataset record identity");
+        }
+    }
+    const absentIds = [...expected.requiredSpanIds].filter((spanId) => !byId.has(spanId));
+    if (absentIds.length > 0)
+        missing.push(`${absentIds.length} SDK-owned spans`);
+    if (spans.some((span) => spanAttributes(span)["atlan.eval.evidence_truncated"] === true)) {
+        missing.push("untruncated payloads");
+    }
+    for (const [scoreName, scorer] of expected.scores) {
+        const present = spans.some((span) => field(span, "scoreName") === scoreName &&
+            field(span, "scorerId") === scorer.id &&
+            field(span, "scorerVersion") === scorer.version);
+        if (!present)
+            missing.push(`score '${scoreName}'`);
+    }
+    return missing;
+}
+async function verifyTraceEvidence(resources, experimentId, expected, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
-    let missing = expected;
+    let missing = new Map();
     let lastError;
     while (true) {
         try {
-            const observed = await listedTraceIds(resources, experimentId);
-            missing = new Set([...expected].filter((traceId) => !observed.has(traceId)));
+            missing = new Map();
+            if (typeof resources.experiments.traces.listSpans === "function") {
+                for (const [traceId, expectation] of expected) {
+                    const gaps = missingTraceEvidence(await traceSpans(resources, experimentId, traceId), expectation);
+                    if (gaps.length > 0)
+                        missing.set(traceId, gaps);
+                }
+            }
+            else {
+                const observed = await listedTraceIds(resources, experimentId);
+                for (const traceId of expected.keys()) {
+                    if (!observed.has(traceId))
+                        missing.set(traceId, ["trace read"]);
+                }
+            }
             lastError = undefined;
         }
         catch (error) {
@@ -588,15 +726,16 @@ async function verifyTraceJoins(resources, experimentId, expected, timeoutMs) {
                 ![404, 429, 500, 502, 503, 504].includes(error.status)) {
                 throw error;
             }
-            missing = expected;
+            missing = new Map([...expected.keys()].map((traceId) => [traceId, ["trace read"]]));
             lastError = error;
         }
         if (missing.size === 0)
             return;
         const remaining = deadline - Date.now();
         if (remaining <= 0) {
-            const failure = new Error(`Registry did not expose ${missing.size} of ${expected.size} case traces ` +
-                "before the verification deadline");
+            const failure = new Error(`Registry did not expose complete trace evidence for ${missing.size} of ` +
+                `${expected.size} case traces before the verification deadline: ` +
+                [...missing].map(([traceId, gaps]) => `${traceId} (${gaps.join(", ")})`).join("; "));
             if (lastError !== undefined)
                 failure.cause = lastError;
             throw failure;
@@ -632,6 +771,11 @@ function defaultConnections(name, options) {
     if (sampleRate !== undefined && sampleRate !== 1) {
         throw new Error("Eval tracing requires sampleRate=1 so no case trace is sampled out");
     }
+    const traceContent = traceLogger.client.config
+        ?.traceContent;
+    if (traceContent === false) {
+        throw new Error("Eval tracing requires traceContent=true so case evidence is readable");
+    }
     return { client, logger: traceLogger, workspaceId, tracing };
 }
 /**
@@ -689,11 +833,14 @@ async function Eval(name, evaluator, options = {}) {
         if (field(experiment, "experimentStatus") !== "running") {
             throw new Error("resumeExperimentId must name a running experiment");
         }
-        if (options.contextManifest !== undefined &&
-            field(field(experiment, "config"), "context_manifest_digest") !==
-                options.contextManifest.digest) {
+        const storedConfig = field(experiment, "config") ?? {};
+        if (field(storedConfig, "context_manifest_digest") !== options.contextManifest?.digest) {
             throw new Error("resume experiment uses a different context manifest");
         }
+        const storedUserConfig = Object.fromEntries(Object.entries(storedConfig).filter(([key]) => !["runner", "registry_dataset", "context_manifest", "context_manifest_digest", "eval_cases_digest"].includes(key)));
+        if (canonicalJson(storedUserConfig) !== canonicalJson(options.config ?? {})) {
+            throw new Error("resume experiment uses a different config");
+        }
         let resolvedDataset;
         if (evaluator.dataset !== undefined) {
             resolvedDataset = await resolveDataset(client, evaluator.dataset, workspaceId);
@@ -706,6 +853,9 @@ async function Eval(name, evaluator, options = {}) {
         }
         else {
             cases = await collectData(evaluator.data);
+            if (field(storedConfig, "eval_cases_digest") !== await casesDigest(cases)) {
+                throw new Error("resume inline data differs or has no saved digest; start a new experiment");
+            }
         }
         run = new EvalRun(experiment, resolvedDataset, options.contextManifest);
     }
@@ -717,6 +867,7 @@ async function Eval(name, evaluator, options = {}) {
     else {
         cases = await collectData(evaluator.data);
         const config = { ...experimentBody.config };
+        config.eval_cases_digest = await casesDigest(cases);
         if (options.contextManifest !== undefined) {
             config.context_manifest = options.contextManifest;
             config.context_manifest_digest = options.contextManifest.digest;
@@ -729,23 +880,34 @@ async function Eval(name, evaluator, options = {}) {
         }
     }
     const scorerCache = new Map();
+    const traceEvidence = new Map();
     const started = Date.now();
     const results = [];
     try {
         options.onStart?.({ experimentId: run.id, experiment: run.experiment });
         if (evaluator.dataset !== undefined) {
+            const snapshot = snapshotCases(run.experiment);
+            if (options.resumeExperimentId !== undefined && snapshot === undefined) {
+                throw new Error("resume requires the experiment's immutable dataset snapshot");
+            }
             cases =
-                snapshotCases(run.experiment) ??
+                snapshot ??
                     (await datasetCases(resources, String(field(run.dataset, "id"))));
         }
-        const completedCaseIds = options.resumeExperimentId === undefined
-            ? new Set()
-            : await existingCaseIds(resources, run.id);
+        const caseIds = new Set(cases.map((item, index) => item.id ?? `case-${index + 1}`));
+        if (caseIds.size !== cases.length)
+            throw new Error("Eval case IDs must be unique");
+        const persisted = options.resumeExperimentId === undefined ? [] : await experimentResults(resources, run.id);
+        const completedCaseIds = new Set(persisted.map((item) => field(item, "caseId")));
+        if (completedCaseIds.size !== persisted.length || [...completedCaseIds].some((id) => typeof id !== "string" || !caseIds.has(id))) {
+            throw new Error("resume experiment contains unexpected or duplicate case IDs");
+        }
         for (const definition of evaluator.scores) {
             scorerCache.set(definition.name, await resolveScorer(resources, workspaceId, name, definition));
         }
         for (const [index, item] of cases.entries()) {
             const caseId = item.id ?? `case-${index + 1}`;
+            const datasetRecordId = evaluator.dataset === undefined ? undefined : item.id;
             if (completedCaseIds.has(caseId))
                 continue;
             const caseStarted = Date.now();
@@ -753,8 +915,15 @@ async function Eval(name, evaluator, options = {}) {
             const failures = [];
             let output;
             let traceId = "";
+            let rootSpanId;
+            const requiredSpanIds = new Set();
+            const scoreEvidence = new Map();
             const metadata = (item.metadata ?? {});
-            await tracing.propagateAttributes(run.traceOptions, () => traceLogger.client.startAsCurrentSpan(`eval.case.${index + 1}`, {
+            await tracing.propagateAttributes({
+                ...run.traceOptions,
+                caseId,
+                ...(datasetRecordId === undefined ? {} : { datasetRecordId }),
+            }, () => traceLogger.client.startAsCurrentSpan(`eval.case.${index + 1}`, {
                 asType: "task",
                 fields: {
                     input: item.input,
@@ -763,8 +932,13 @@ async function Eval(name, evaluator, options = {}) {
                 },
             }, async (rootSpan) => {
                 traceId = rootSpan.traceId;
+                rootSpanId = rootSpan.spanId;
+                if (rootSpan.spanId !== undefined)
+                    requiredSpanIds.add(rootSpan.spanId);
                 try {
                     output = await traceLogger.client.startAsCurrentSpan("eval.task", { asType: "task", fields: { input: item.input } }, async (taskSpan) => {
+                        if (taskSpan.spanId !== undefined)
+                            requiredSpanIds.add(taskSpan.spanId);
                         const value = await evaluator.task(item.input, {
                             expected: item.expected,
                             metadata,
@@ -779,6 +953,7 @@ async function Eval(name, evaluator, options = {}) {
                 catch (error) {
                     failures.push(safeError(error));
                     rootSpan.recordFailure(error);
+                    rootSpan.markEvidenceComplete?.();
                     return;
                 }
                 for (const definition of evaluator.scores) {
@@ -793,6 +968,8 @@ async function Eval(name, evaluator, options = {}) {
                                 },
                             },
                         }, async (scoreSpan) => {
+                            if (scoreSpan.spanId !== undefined)
+                                requiredSpanIds.add(scoreSpan.spanId);
                             const value = await definition.scorer({ ...item, output: output });
                             scoreSpan.update({ output: value });
                             return value;
@@ -813,6 +990,7 @@ async function Eval(name, evaluator, options = {}) {
                             }
                             const numeric = numericScore(scored.score);
                             scores[scoreName] = numeric;
+                            scoreEvidence.set(scoreName, registered);
                             rootSpan.score(scoreName, numeric, {
                                 scorerId: registered.id,
                                 scorerVersion: registered.version,
@@ -828,6 +1006,7 @@ async function Eval(name, evaluator, options = {}) {
                     }
                 }
                 rootSpan.update({ output, metadata });
+                rootSpan.markEvidenceComplete?.();
             }));
             if (!TRACE_ID.test(traceId) || /^0+$/.test(traceId)) {
                 throw new Error(`case ${index + 1} did not produce a trace ID`);
@@ -841,41 +1020,84 @@ async function Eval(name, evaluator, options = {}) {
                 traceId,
                 durationMs: Date.now() - caseStarted,
             });
-        }
-        // Score aggregation reads spans, so make the async exporter observable first.
-        await traceLogger.flush();
-        if (options.verifyTraces !== false && results.length > 0) {
-            await verifyTraceJoins(resources, run.id, new Set(results.map((result) => result.traceId)), traceVerificationTimeoutMs);
-        }
-        const resultBodies = results.map((result, index) => ({
-            workspaceId,
-            name: `${slug(run.id, "experiment")}-case-${index + 1}`,
-            caseId: result.caseId,
-            datasetRecordId: result.id || undefined,
-            input: registryObject(result.input),
-            expected: registryObject(result.expected),
-            output: registryObject(result.output),
-            error: result.error,
-            scores: result.scores,
-            traceId: result.traceId,
-            durationMs: result.durationMs,
-            sourceType: "local",
-        }));
-        for (let offset = 0; offset < resultBodies.length; offset += 100) {
+            traceEvidence.set(traceId, {
+                caseId,
+                ...(datasetRecordId === undefined ? {} : { datasetRecordId }),
+                ...(rootSpanId === undefined ? {} : { rootSpanId }),
+                requiredSpanIds,
+                scores: scoreEvidence,
+            });
+            // Persist each completed case before starting another costly task.
+            // Keep the source index so a resumed subset cannot reuse earlier names.
+            const result = results[results.length - 1];
+            await traceLogger.flush();
+            if (options.verifyTraces !== false) {
+                await verifyTraceEvidence(resources, run.id, new Map([[result.traceId, traceEvidence.get(result.traceId)]]), traceVerificationTimeoutMs);
+            }
+            const resultBody = {
+                workspaceId,
+                name: `${slug(run.id, "experiment")}-case-${index + 1}`,
+                caseId: result.caseId,
+                datasetRecordId,
+                input: registryObject(result.input),
+                expected: registryObject(result.expected),
+                output: registryObject(result.output),
+                error: result.error,
+                scores: result.scores,
+                traceId: result.traceId,
+                durationMs: result.durationMs,
+                sourceType: "local",
+            };
             const response = await resources.experiments.results.createBulk(run.id, {
-                items: resultBodies.slice(offset, offset + 100),
+                items: [resultBody],
             });
             const slots = field(response, "items");
-            if (Array.isArray(slots)) {
-                const failed = slots.filter((slot) => {
-                    const status = field(slot, "statusCode");
-                    return typeof status === "number" && status >= 400;
-                });
-                if (failed.length > 0)
-                    throw new Error(`${failed.length} Eval results were rejected`);
+            const status = Array.isArray(slots) && slots.length === 1 ? field(slots[0], "statusCode") : undefined;
+            if (typeof status !== "number" || status < 200 || status >= 300) {
+                throw new Error("1 Eval results were rejected or not acknowledged");
             }
         }
         const persistedResults = await experimentResults(resources, run.id);
+        const persistedCaseIds = new Set(persistedResults.map((item) => field(item, "caseId")));
+        if (persistedResults.length !== caseIds.size || persistedCaseIds.size !== caseIds.size || [...caseIds].some((id) => !persistedCaseIds.has(id))) {
+            throw new Error("Registry result coverage does not match the evaluation cases");
+        }
+        if (options.verifyTraces !== false && persistedResults.length > 0) {
+            const traceIds = new Set();
+            for (const item of persistedResults) {
+                const traceId = field(item, "traceId");
+                if (typeof traceId !== "string" || !TRACE_ID.test(traceId) || /^0+$/.test(traceId)) {
+                    throw new Error("Registry result is missing a valid trace ID");
+                }
+                traceIds.add(traceId);
+            }
+            const expectations = new Map();
+            for (const item of persistedResults) {
+                const traceId = field(item, "traceId");
+                const current = traceEvidence.get(traceId);
+                if (current !== undefined) {
+                    expectations.set(traceId, current);
+                    continue;
+                }
+                const persistedScores = field(item, "scores");
+                const scorePins = new Map();
+                if (isRecord(persistedScores)) {
+                    for (const [scoreName, value] of Object.entries(persistedScores)) {
+                        const scorer = scorerCache.get(scoreName);
+                        if (value !== null && scorer !== undefined)
+                            scorePins.set(scoreName, scorer);
+                    }
+                }
+                const datasetRecordId = field(item, "datasetRecordId");
+                expectations.set(traceId, {
+                    caseId: String(field(item, "caseId")),
+                    ...(typeof datasetRecordId === "string" ? { datasetRecordId } : {}),
+                    requiredSpanIds: new Set(),
+                    scores: scorePins,
+                });
+            }
+            await verifyTraceEvidence(resources, run.id, expectations, traceVerificationTimeoutMs);
+        }
         const local = localSummary(persistedResults, Date.now() - started);
         const experiment = await resources.experiments.update(run.id, {
             experimentStatus: "completed",
@@ -902,15 +1124,8 @@ async function Eval(name, evaluator, options = {}) {
         catch {
             // Preserve the original runner/upload failure.
         }
-        try {
-            await resources.experiments.update(run.id, {
-                experimentStatus: "failed",
-                summary: localSummary(results, Date.now() - started),
-            });
-        }
-        catch {
-            // Preserve the original runner/upload failure.
-        }
+        // Leave interrupted infrastructure work running: terminal experiments
+        // cannot accept more results. Resume reconciles Registry case IDs.
         throw error;
     }
 }

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { AtlanClient, ServiceNamespace, createService } from "./client";
 export type { AtlanClientOptions, ForwardedOperation, Service } from "./client";
 export { buildResources, resourceMap } from "./resources";
 export type { Resource, ResourceOperation } from "./resources";
+export type { ResourceMap, ResourceRoots } from "./resource-types";
 export { AtlanAPIError } from "./errors";
 export { operationManifest, operations } from "./operations";
 export type { Operation, OperationManifest, ServiceContract } from "./operations";