@atlanai/sdk 0.2.2 → 0.2.4

package/dist/resource-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resources.d.ts

@@ -60,6 +60,16 @@ export interface Resource {
     readonly operations: Readonly<Record<string, string>>;
     readonly [member: string]: ResourceOperation | Resource | string | Readonly<Record<string, string>>;
 }
+/**
+ * Refuse to return a bulk write that achieved nothing as a success.
+ *
+ * A bulk endpoint answers 207: each slot carries its own status, and partial
+ * success is the point, so one failed slot is the caller's business and is
+ * left alone. A batch where no slot succeeded is different. It changed
+ * nothing, it is never what the caller wanted, and returning it as an ordinary
+ * value is how a whole dataset ends up silently empty.
+ */
+export declare function raiseIfNothingSucceeded(result: unknown): void;
 /**
  * Build the top-level resources, nesting children under their parents.
  *

package/dist/resources.js

@@ -17,8 +17,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resourceMap = void 0;
+exports.raiseIfNothingSucceeded = raiseIfNothingSucceeded;
 exports.buildResources = buildResources;
 const resources_json_1 = __importDefault(require("./resources.json"));
+const errors_1 = require("./errors");
 const SCHEMA_VERSION = 1;
 exports.resourceMap = resources_json_1.default;
 if (exports.resourceMap.schema_version !== SCHEMA_VERSION) {
@@ -49,6 +51,53 @@ function isPlainObject(value) {
  * guessed: a lone object argument carrying any of the expected property names
  * is passed straight through.
  */
+/** The per-item status on a multi-status slot, if this is one. */
+function slotStatus(item) {
+    if (!isPlainObject(item))
+        return undefined;
+    const status = item.statusCode ?? item.status_code;
+    return typeof status === "number" ? status : undefined;
+}
+/**
+ * Refuse to return a bulk write that achieved nothing as a success.
+ *
+ * A bulk endpoint answers 207: each slot carries its own status, and partial
+ * success is the point, so one failed slot is the caller's business and is
+ * left alone. A batch where no slot succeeded is different. It changed
+ * nothing, it is never what the caller wanted, and returning it as an ordinary
+ * value is how a whole dataset ends up silently empty.
+ */
+function raiseIfNothingSucceeded(result) {
+    const items = isPlainObject(result) ? result.items : undefined;
+    if (!Array.isArray(items) || items.length === 0)
+        return;
+    const statuses = items.map(slotStatus);
+    // Only a multi-status envelope: every slot has to carry its own status.
+    if (statuses.some((status) => status === undefined))
+        return;
+    if (statuses.some((status) => status !== undefined && status >= 200 && status < 300))
+        return;
+    const codes = [...new Set(statuses.map(String))].sort();
+    const explanation = `none of the ${items.length} items in this batch was accepted ` +
+        `(per-item status: ${codes.join(", ")}); read items[].error for why`;
+    throw new errors_1.AtlanAPIError({
+        status: statuses[0] ?? 207,
+        code: "bulk_all_rejected",
+        title: "Every item in the batch was rejected",
+        detail: explanation,
+        // As a hint, not a detail: this text is client-authored, so the rule
+        // keeping server prose out of the message does not apply.
+        hint: explanation,
+    });
+}
+/** Wrap an operation so a batch that achieved nothing cannot return quietly. */
+function guarded(operation) {
+    return (async (...args) => {
+        const result = await operation(...args);
+        raiseIfNothingSucceeded(result);
+        return result;
+    });
+}
 function positionalCall(forwarded, detail, workspace) {
     const bodyKey = detail.typescript_body;
     const pathKeys = [...detail.route.matchAll(/\{(\w+)\}/g)].map((match) => camelCase(match[1]));
@@ -56,11 +105,12 @@ function positionalCall(forwarded, detail, workspace) {
     // alone let `get(agentId)` pass a bare string where the generated client
     // wanted an object: no error, and the wrong resource fetched.
     const workspaceKey = detail.workspace_parameter?.typescript;
-    if (bodyKey === undefined && pathKeys.length === 0 && workspaceKey === undefined)
-        return forwarded;
+    if (bodyKey === undefined && pathKeys.length === 0 && workspaceKey === undefined) {
+        return guarded(forwarded);
+    }
     const arity = pathKeys.length + (bodyKey === undefined ? 0 : 1);
     const expected = new Set(bodyKey === undefined ? pathKeys : [...pathKeys, bodyKey]);
-    return ((...args) => {
+    return guarded(((...args) => {
         const values = args;
         if (values.length === 1 && isPlainObject(values[0])) {
             const keys = Object.keys(values[0]);
@@ -81,7 +131,7 @@ function positionalCall(forwarded, detail, workspace) {
         if (workspaceKey !== undefined && workspace !== undefined)
             options[workspaceKey] = workspace;
         return forwarded(options);
-    });
+    }));
 }
 function buildResource(path, entry, service, children, workspace) {
     const operations = {};

package/dist/resources.json

@@ -253,6 +253,15 @@
         },
         "agents.sessions": {
             "methods": {
+                "create": {
+                    "method_camel": "create",
+                    "operation_id": "agent.createSession",
+                    "python": "agent_create_session",
+                    "route": "POST /agent/v1/agents/{agent_id}/sessions",
+                    "summary": "Trigger an agent run",
+                    "typescript": "agentCreateSession",
+                    "typescript_body": "triggerBody"
+                },
                 "list": {
                     "method_camel": "list",
                     "operation_id": "agent.listAgentSessions",
@@ -466,6 +475,42 @@
             "service": "registry",
             "typescript": "auth"
         },
+        "callback": {
+            "methods": {
+                "oauth": {
+                    "method_camel": "oauth",
+                    "operation_id": "secret.oauthCallback",
+                    "python": "secret_oauth_callback",
+                    "route": "GET /secret/v1/oauth/callback/{provider}",
+                    "summary": "`GET /<ext>/v1/oauth/callback/{provider}` \u2014 the provider's redirect target.",
+                    "typescript": "secretOauthCallback"
+                }
+            },
+            "service": "secret",
+            "typescript": "callback"
+        },
+        "connections": {
+            "methods": {
+                "disconnect_oauth": {
+                    "method_camel": "disconnectOauth",
+                    "operation_id": "secret.disconnectOauth",
+                    "python": "secret_disconnect_oauth",
+                    "route": "DELETE /secret/v1/oauth/connections/{secret_id}",
+                    "summary": "`DELETE /<ext>/v1/oauth/connections/{secret_id}`.",
+                    "typescript": "secretDisconnectOauth"
+                },
+                "list_oauth": {
+                    "method_camel": "listOauth",
+                    "operation_id": "secret.listOauthConnections",
+                    "python": "secret_list_oauth_connections",
+                    "route": "GET /secret/v1/oauth/connections",
+                    "summary": "`GET /<ext>/v1/oauth/connections`.",
+                    "typescript": "secretListOauthConnections"
+                }
+            },
+            "service": "secret",
+            "typescript": "connections"
+        },
         "datasets": {
             "methods": {
                 "archive": {
@@ -1163,6 +1208,38 @@
             "service": "model",
             "typescript": "modelProviders"
         },
+        "oauth": {
+            "methods": {
+                "complete": {
+                    "method_camel": "complete",
+                    "operation_id": "secret.completeOauth",
+                    "python": "secret_complete_oauth",
+                    "route": "POST /secret/v1/oauth/complete",
+                    "summary": "`POST /<ext>/v1/oauth/complete` \u2014 polled until it answers `connected`.",
+                    "typescript": "secretCompleteOauth",
+                    "typescript_body": "gatewayOauthCompleteRequest"
+                },
+                "list_providers": {
+                    "method_camel": "listProviders",
+                    "operation_id": "secret.listOauthProviders",
+                    "python": "secret_list_oauth_providers",
+                    "route": "GET /secret/v1/oauth/providers",
+                    "summary": "`GET /<ext>/v1/oauth/providers` \u2014 what can be connected, and the callback URL\nto register for each.",
+                    "typescript": "secretListOauthProviders"
+                },
+                "start": {
+                    "method_camel": "start",
+                    "operation_id": "secret.startOauth",
+                    "python": "secret_start_oauth",
+                    "route": "POST /secret/v1/oauth/start",
+                    "summary": "`POST /<ext>/v1/oauth/start`.",
+                    "typescript": "secretStartOauth",
+                    "typescript_body": "gatewayOauthStartRequest"
+                }
+            },
+            "service": "secret",
+            "typescript": "oauth"
+        },
         "openai": {
             "methods": {
                 "chat_completions": {
@@ -2136,6 +2213,15 @@
                     "summary": "Recommend workspaces to join",
                     "typescript": "registryListWorkspaceRecommendations"
                 },
+                "set_visibility": {
+                    "method_camel": "setVisibility",
+                    "operation_id": "registry.setWorkspaceVisibility",
+                    "python": "registry_set_workspace_visibility",
+                    "route": "PATCH /registry/v1/workspaces/{workspace_id}/visibility",
+                    "summary": "Change a workspace's visibility",
+                    "typescript": "registrySetWorkspaceVisibility",
+                    "typescript_body": "setVisibilityBody"
+                },
                 "update": {
                     "method_camel": "update",
                     "operation_id": "registry.updateWorkspace",

package/dist/tracing/client.d.ts

@@ -15,6 +15,7 @@
 import { type Tracer, type TimeInput } from "@opentelemetry/api";
 import { BasicTracerProvider, type SpanExporter } from "@opentelemetry/sdk-trace-base";
 import { type ConfigOptions, type ResolvedConfig } from "./config.js";
+import { type ExportHealth } from "./exporter.js";
 import { type MaskFunction, type MaskOtelSpansFunction } from "./masking.js";
 import { AtlanSpanProcessor } from "./processor.js";
 import { type ShouldExportSpan } from "./span-filter.js";
@@ -70,12 +71,18 @@ export declare class AtlanAI {
     private readonly mask;
     private readonly ownsGlobal;
     private readonly waitUntil;
+    private readonly trackedExporter;
     private shutdownDone;
     constructor(config: ResolvedConfig, options?: InitOptions);
     get isEnabled(): boolean;
     /** The SDK's TracerProvider (null when disabled). Third-party tracers
      * acquired from it flow through the Atlan pipeline (allowlist + enrichment). */
     get tracerProvider(): BasicTracerProvider | null;
+    /** Current delivery health without endpoint or credential details. */
+    get exportHealth(): ExportHealth | {
+        status: "disabled";
+        exportFailures: 0;
+    };
     getTracer(): Tracer;
     /** Return the active OTel span through the Atlan ergonomic span surface. */
     currentSpan(): AtlanSpan;
@@ -98,7 +105,7 @@ export declare class AtlanAI {
     shutdown(): Promise<void>;
 }
 /**
- * Initialize the SDK. Idempotent per API key (SPEC §10.2). Throws
+ * Initialize the SDK. Idempotent per pipeline identity (SPEC §10.2). Throws
  * AtlanConfigError only when an Atlan endpoint is configured without a
  * workspace (SPEC §2.4); all other misconfiguration logs a warning and returns
  * a disabled, no-op client.

package/dist/tracing/client.js

@@ -72,7 +72,7 @@ function registry() {
     const host = globalThis;
     let existing = host[REGISTRY_SLOT];
     if (!existing) {
-        existing = { clients: new Map(), defaultKey: undefined };
+        existing = { clients: new Map(), defaultKey: undefined, exitHookInstalled: false };
         try {
             Object.defineProperty(host, REGISTRY_SLOT, {
                 value: existing,
@@ -85,10 +85,25 @@ function registry() {
             host[REGISTRY_SLOT] = existing;
         }
     }
+    if (!existing.exitHookInstalled) {
+        existing.exitHookInstalled = true;
+        const clients = existing.clients;
+        isomorph_js_1.iso.onExit(() => {
+            for (const client of clients.values()) {
+                void client.flush().catch(() => undefined);
+            }
+        });
+    }
     return existing;
 }
-function clientKey(apiKey) {
-    return apiKey ?? "::anon::";
+function clientKey(config) {
+    return [
+        config.apiKey ?? "::anon::",
+        config.mode,
+        config.baseUrl,
+        config.workspaceId ?? "",
+        config.serviceName ?? "",
+    ].join("\u0000");
 }
 const TRACE_ID_RE = /^[0-9a-f]{32}$/;
 const SPAN_ID_RE = /^[0-9a-f]{16}$/;
@@ -196,6 +211,7 @@ class AtlanAI {
     mask;
     ownsGlobal = false;
     waitUntil;
+    trackedExporter = null;
     shutdownDone = false;
     constructor(config, options = {}) {
         this.config = config;
@@ -207,7 +223,8 @@ class AtlanAI {
         if (options.maskOtelSpans !== undefined) {
             exporter = new masking_js_1.MaskingSpanExporter(exporter, options.maskOtelSpans);
         }
-        this.spanProcessor = new processor_js_1.AtlanSpanProcessor(exporter, {
+        this.trackedExporter = new exporter_js_1.TrackingSpanExporter(exporter);
+        this.spanProcessor = new processor_js_1.AtlanSpanProcessor(this.trackedExporter, {
             flushAt: config.debug ? 1 : config.flushAt,
             flushIntervalS: config.debug ? 0.1 : config.flushIntervalS,
             timeoutS: config.timeoutS,
@@ -238,9 +255,6 @@ class AtlanAI {
                 this.ownsGlobal = true;
             }
         }
-        isomorph_js_1.iso.onExit(() => {
-            void this.flush().catch(() => undefined);
-        });
     }
     get isEnabled() {
         return this.spanProcessor !== null;
@@ -250,6 +264,10 @@ class AtlanAI {
     get tracerProvider() {
         return this.provider;
     }
+    /** Current delivery health without endpoint or credential details. */
+    get exportHealth() {
+        return this.trackedExporter?.health ?? { status: "disabled", exportFailures: 0 };
+    }
     getTracer() {
         const provider = this.provider ?? api_1.trace.getTracerProvider();
         return provider.getTracer(span_filter_js_1.ATLAN_SDK_SCOPE, version_js_1.SDK_VERSION);
@@ -338,14 +356,20 @@ class AtlanAI {
         return result;
     }
     /** Force the processor pipeline to export (SPEC §10.3). */
-    flush() {
+    async flush() {
         if (this.spanProcessor === null)
             return Promise.resolve();
-        const flushing = this.spanProcessor.forceFlush().catch(() => {
-            logger_js_1.logger.debug("flush failed");
-        });
+        const flushing = this.spanProcessor.forceFlush();
         this.waitUntil?.(flushing);
-        return flushing;
+        try {
+            await flushing;
+        }
+        catch {
+            throw new Error("Atlan trace export failed; inspect client.exportHealth and retry");
+        }
+        if (this.exportHealth.status === "failed") {
+            throw new Error("Atlan trace export failed; inspect client.exportHealth and retry");
+        }
     }
     async shutdown() {
         if (this.shutdownDone || this.provider === null)
@@ -362,7 +386,7 @@ class AtlanAI {
 }
 exports.AtlanAI = AtlanAI;
 /**
- * Initialize the SDK. Idempotent per API key (SPEC §10.2). Throws
+ * Initialize the SDK. Idempotent per pipeline identity (SPEC §10.2). Throws
  * AtlanConfigError only when an Atlan endpoint is configured without a
  * workspace (SPEC §2.4); all other misconfiguration logs a warning and returns
  * a disabled, no-op client.
@@ -379,7 +403,7 @@ function init(options = {}) {
         config = (0, config_js_1.resolveConfig)({ ...options, tracingEnabled: false });
     }
     (0, logger_js_1.setDebug)(config.debug);
-    const key = clientKey(config.apiKey);
+    const key = clientKey(config);
     const bucket = registry();
     const existing = bucket.clients.get(key);
     if (existing) {
@@ -398,8 +422,11 @@ function init(options = {}) {
  */
 function getClient(apiKey) {
     const bucket = registry();
-    const key = apiKey !== undefined ? clientKey(apiKey) : bucket.defaultKey;
-    const existing = key !== undefined ? bucket.clients.get(key) : undefined;
+    const existing = apiKey === undefined
+        ? bucket.defaultKey === undefined
+            ? undefined
+            : bucket.clients.get(bucket.defaultKey)
+        : [...bucket.clients.values()].find((client) => client.config.apiKey === apiKey);
     if (existing)
         return existing;
     return new AtlanAI((0, config_js_1.resolveConfig)({ tracingEnabled: false }));

package/dist/tracing/config.d.ts

@@ -7,7 +7,7 @@
  * (SPEC §2.4). On runtimes without ambient env (workerd), everything resolves
  * from the init options alone.
  */
-export declare const DEFAULT_BASE_URL = "https://agentgateway.atlan.engineering";
+export declare const DEFAULT_BASE_URL = "https://api.atlan.com";
 /**
  * Modes (SPEC §3.3): "atlan" exports to the gateway with Atlan headers; "otlp"
  * is generic-collector mode driven purely by OTEL_EXPORTER_OTLP_* env;
@@ -42,6 +42,8 @@ export interface ConfigOptions {
     tracingEnabled?: boolean;
     traceContent?: boolean;
     sampleRate?: number;
+    /** Export and flush timeout in seconds. Defaults to ATLAN_TIMEOUT or 30. */
+    timeoutS?: number;
 }
 export declare function validAtlanBaseUrl(baseUrl: string): boolean;
 /**

package/dist/tracing/config.js

@@ -14,7 +14,7 @@ exports.validAtlanBaseUrl = validAtlanBaseUrl;
 exports.resolveConfig = resolveConfig;
 const isomorph_js_1 = require("./isomorph.js");
 const logger_js_1 = require("./logger.js");
-exports.DEFAULT_BASE_URL = "https://agentgateway.atlan.engineering";
+exports.DEFAULT_BASE_URL = "https://api.atlan.com";
 const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
 /** Thrown only for the spec-mandated fail-fast cases (SPEC §2.4). */
 class AtlanConfigError extends Error {
@@ -69,6 +69,11 @@ function resolveConfig(options = {}) {
         logger_js_1.logger.warn(`sample_rate ${rate} outside [0, 1]; using 1.0`);
         rate = 1.0;
     }
+    let timeout = options.timeoutS ?? envNumber("ATLAN_TIMEOUT", 30.0);
+    if (!Number.isFinite(timeout) || timeout <= 0) {
+        logger_js_1.logger.warn(`timeoutS ${timeout} must be positive and finite; using 30`);
+        timeout = 30.0;
+    }
     let mode = "disabled";
     if (enabled) {
         if (apiKey) {
@@ -107,7 +112,7 @@ function resolveConfig(options = {}) {
         sampleRate: rate,
         flushAt: envNumber("ATLAN_FLUSH_AT", 64, true),
         flushIntervalS: envNumber("ATLAN_FLUSH_INTERVAL", 5.0),
-        timeoutS: envNumber("ATLAN_TIMEOUT", 30.0),
+        timeoutS: timeout,
         maxPayloadBytes: envNumber("ATLAN_MAX_PAYLOAD_BYTES", 1024 * 1024, true),
         debug: envBool("ATLAN_DEBUG", false),
     };

package/dist/tracing/exporter.d.ts

@@ -8,7 +8,8 @@
  * standard OTEL_EXPORTER_OTLP_(TRACES_)ENDPOINT / _HEADERS env chain — the SDK
  * adds no Atlan headers there.
  */
-import type { SpanExporter } from "@opentelemetry/sdk-trace-base";
+import { type ExportResult } from "@opentelemetry/core";
+import type { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-base";
 import type { ResolvedConfig } from "./config.js";
 /**
  * Lazy OTLP exporter: the heavyweight node-only OTLP/protobuf chain is
@@ -18,3 +19,20 @@ import type { ResolvedConfig } from "./config.js";
  * worker bundles.
  */
 export declare function buildExporter(config: ResolvedConfig): SpanExporter;
+export interface ExportHealth {
+    status: "ok" | "failed";
+    exportFailures: number;
+    lastError?: string;
+}
+/** Makes asynchronous exporter failures observable to `flush()` callers. */
+export declare class TrackingSpanExporter implements SpanExporter {
+    private readonly wrapped;
+    private failures;
+    private lastError;
+    constructor(wrapped: SpanExporter);
+    get health(): ExportHealth;
+    private failed;
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

package/dist/tracing/exporter.js

@@ -10,7 +10,9 @@
  * adds no Atlan headers there.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackingSpanExporter = void 0;
 exports.buildExporter = buildExporter;
+const core_1 = require("@opentelemetry/core");
 const logger_js_1 = require("./logger.js");
 const version_js_1 = require("./version.js");
 async function loadOtlpExporter(config) {
@@ -44,29 +46,69 @@ async function loadOtlpExporter(config) {
 function buildExporter(config) {
     let loading = null;
     const load = () => {
-        loading ??= loadOtlpExporter(config).catch(() => {
-            logger_js_1.logger.warn("OTLP exporter unavailable on this runtime; spans will be dropped");
-            return null;
-        });
+        loading ??= loadOtlpExporter(config);
         return loading;
     };
     return {
         export(spans, resultCallback) {
-            void load().then((exporter) => {
-                if (exporter === null) {
-                    resultCallback({ code: 0 });
-                    return;
-                }
-                exporter.export(spans, resultCallback);
+            void load().then((exporter) => exporter.export(spans, resultCallback), () => {
+                logger_js_1.logger.warn("OTLP exporter unavailable on this runtime; trace export failed");
+                resultCallback({ code: core_1.ExportResultCode.FAILED });
             });
         },
         async shutdown() {
-            const exporter = loading === null ? null : await loading;
-            await exporter?.shutdown();
+            if (loading !== null)
+                await (await loading).shutdown();
         },
         async forceFlush() {
-            const exporter = loading === null ? null : await loading;
-            await exporter?.forceFlush?.();
+            if (loading !== null)
+                await (await loading).forceFlush?.();
         },
     };
 }
+/** Makes asynchronous exporter failures observable to `flush()` callers. */
+class TrackingSpanExporter {
+    wrapped;
+    failures = 0;
+    lastError;
+    constructor(wrapped) {
+        this.wrapped = wrapped;
+    }
+    get health() {
+        return {
+            status: this.failures === 0 ? "ok" : "failed",
+            exportFailures: this.failures,
+            ...(this.lastError === undefined ? {} : { lastError: this.lastError }),
+        };
+    }
+    failed(detail) {
+        this.failures += 1;
+        this.lastError = detail;
+    }
+    export(spans, resultCallback) {
+        try {
+            this.wrapped.export(spans, (result) => {
+                if (result.code !== core_1.ExportResultCode.SUCCESS)
+                    this.failed("exporter returned failure");
+                resultCallback(result);
+            });
+        }
+        catch (error) {
+            this.failed(error instanceof Error ? error.name : "exporter threw");
+            resultCallback({ code: core_1.ExportResultCode.FAILED });
+        }
+    }
+    shutdown() {
+        return this.wrapped.shutdown();
+    }
+    async forceFlush() {
+        try {
+            await this.wrapped.forceFlush?.();
+        }
+        catch (error) {
+            this.failed(error instanceof Error ? error.name : "forceFlush failed");
+            throw error;
+        }
+    }
+}
+exports.TrackingSpanExporter = TrackingSpanExporter;

package/dist/tracing/propagation.d.ts

@@ -18,6 +18,8 @@ export interface PropagateAttributesOptions {
     userId?: string;
     visitorId?: string;
     experimentId?: string;
+    caseId?: string;
+    datasetRecordId?: string;
     tags?: readonly string[];
     metadata?: Record<string, unknown>;
     traceName?: string;

package/dist/tracing/propagation.js

@@ -57,6 +57,8 @@ const SESSION_ID_KEY = (0, api_1.createContextKey)("atlan.propagated.session_id"
 const USER_ID_KEY = (0, api_1.createContextKey)("atlan.propagated.user_id");
 const VISITOR_ID_KEY = (0, api_1.createContextKey)("atlan.propagated.visitor_id");
 const EXPERIMENT_ID_KEY = (0, api_1.createContextKey)("atlan.propagated.experiment_id");
+const EVAL_CASE_ID_KEY = (0, api_1.createContextKey)("atlan.propagated.eval_case_id");
+const DATASET_RECORD_ID_KEY = (0, api_1.createContextKey)("atlan.propagated.dataset_record_id");
 const TAGS_KEY = (0, api_1.createContextKey)("atlan.propagated.tags");
 const METADATA_KEY = (0, api_1.createContextKey)("atlan.propagated.metadata");
 const TRACE_NAME_KEY = (0, api_1.createContextKey)("atlan.propagated.trace_name");
@@ -127,6 +129,13 @@ function propagatedAttributesFromContext(context, includeContent = true) {
     const experimentId = context.getValue(EXPERIMENT_ID_KEY);
     if (typeof experimentId === "string")
         attributes[sc.ATLAN_EVAL_EXPERIMENT_ID] = experimentId;
+    const caseId = context.getValue(EVAL_CASE_ID_KEY);
+    if (typeof caseId === "string")
+        attributes[sc.ATLAN_EVAL_CASE_ID] = caseId;
+    const datasetRecordId = context.getValue(DATASET_RECORD_ID_KEY);
+    if (typeof datasetRecordId === "string") {
+        attributes[sc.ATLAN_EVAL_DATASET_RECORD_ID] = datasetRecordId;
+    }
     const tags = context.getValue(TAGS_KEY);
     if (Array.isArray(tags) && tags.length > 0)
         attributes[sc.ATLAN_TAGS] = [...tags];
@@ -156,6 +165,13 @@ function propagateAttributes(options, fn) {
     const experimentId = validShortString("experimentId", options.experimentId);
     if (experimentId !== undefined)
         context = context.setValue(EXPERIMENT_ID_KEY, experimentId);
+    const caseId = validShortString("caseId", options.caseId);
+    if (caseId !== undefined)
+        context = context.setValue(EVAL_CASE_ID_KEY, caseId);
+    const datasetRecordId = validShortString("datasetRecordId", options.datasetRecordId);
+    if (datasetRecordId !== undefined) {
+        context = context.setValue(DATASET_RECORD_ID_KEY, datasetRecordId);
+    }
     const newTags = validTags(options.tags);
     if (newTags.length > 0) {
         const existing = context.getValue(TAGS_KEY);

package/dist/tracing/semconv.d.ts

@@ -9,6 +9,10 @@ export type ScoreDataType = (typeof SCORE_DATA_TYPES)[number];
 export declare const ATLAN_COMPLETION_START_TIME = "atlan.completion_start_time";
 export declare const ATLAN_CONSENT_STORE_CONTENT = "atlan.consent.store_content";
 export declare const ATLAN_ENVIRONMENT = "atlan.environment";
+export declare const ATLAN_EVAL_CASE_ID = "atlan.eval.case_id";
+export declare const ATLAN_EVAL_DATASET_RECORD_ID = "atlan.eval.dataset_record_id";
+export declare const ATLAN_EVAL_EVIDENCE_COMPLETE = "atlan.eval.evidence_complete";
+export declare const ATLAN_EVAL_EVIDENCE_TRUNCATED = "atlan.eval.evidence_truncated";
 export declare const ATLAN_EVAL_EXPERIMENT_ID = "atlan.eval.experiment_id";
 export declare const ATLAN_INPUT = "atlan.input";
 export declare const ATLAN_INTERNAL_AS_ROOT = "atlan.internal.as_root";