@atlanai/sdk 0.2.1 → 0.2.3

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,13 +71,21 @@ 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;
     /**
      * Create or refresh a Visitor and return its canonical artifact identity.
      * This never changes process-global identity; carry visitor.id through
@@ -96,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,10 +264,21 @@ 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);
     }
+    /** Return the active OTel span through the Atlan ergonomic span surface. */
+    currentSpan() {
+        const active = api_1.trace.getSpan(api_1.context.active());
+        if (active === undefined)
+            return (0, spans_js_1.noopSpan)(this.config);
+        return new spans_js_1.AtlanSpan(active, this.config, this.mask, this.getTracer());
+    }
     /**
      * Create or refresh a Visitor and return its canonical artifact identity.
      * This never changes process-global identity; carry visitor.id through
@@ -331,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)
@@ -355,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.
@@ -372,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) {
@@ -391,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/compat.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Low-friction tracing compatibility helpers.
+ *
+ * The implementation deliberately reuses the SDK's OTel pipeline: ended spans
+ * enter its bounded background batcher, `flush()` drains that same queue, and
+ * third-party OTel instrumentation shares the same provider. There is no
+ * second transport or vendor-specific event format to keep in sync.
+ */
+import { type AtlanAI, type InitOptions, type StartSpanOptions } from "./client.js";
+import { type ObserveOptions } from "./observe.js";
+import type { AtlanSpan, UpdateFields } from "./spans.js";
+type AnyFunction = (...args: any[]) => any;
+export interface InitLoggerOptions extends Omit<InitOptions, "exportMode" | "serviceName"> {
+    /** Braintrust migration alias. In Atlan this becomes the trace service name. */
+    projectName?: string;
+    /** Used as the service name when `projectName` is absent. */
+    projectId?: string;
+    /** Native Atlan spelling; takes precedence over the migration aliases. */
+    serviceName?: string;
+    /** Background batching is on by default. `false` switches to immediate export. */
+    asyncFlush?: boolean;
+    /** Export every OTel span. Defaults to true for logger-style observability. */
+    captureAll?: boolean;
+    /** Set this logger as the process current logger. Defaults to true. */
+    setCurrent?: boolean;
+}
+export interface StartSpanArgs extends StartSpanOptions {
+    name?: string;
+    type?: string;
+    event?: UpdateFields;
+}
+export interface LogEvent extends UpdateFields {
+    name?: string;
+    type?: string;
+}
+export interface LoggedSpan {
+    traceId: string;
+    spanId: string;
+}
+export interface WrapTracedOptions extends Omit<ObserveOptions, "asType"> {
+    type?: string;
+    asType?: string;
+    /** Suppress automatic argument and return-value capture. */
+    noTraceIO?: boolean;
+}
+/** A small logger facade over one Atlan OTel client. */
+export declare class Logger {
+    readonly client: AtlanAI;
+    readonly projectName: string;
+    readonly asyncFlush: boolean;
+    constructor(client: AtlanAI, projectName: string, asyncFlush: boolean);
+    startSpan(name: string, options?: StartSpanOptions): AtlanSpan;
+    startSpan(args?: StartSpanArgs): AtlanSpan;
+    /** Run a callback with an automatically ended, ambient current span. */
+    traced<T>(callback: (span: AtlanSpan) => T, args?: StartSpanArgs): T;
+    /** Log one complete root event. Delivery is asynchronous by default. */
+    log(event: LogEvent): LoggedSpan;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/**
+ * Initialize production tracing with Braintrust-style logger ergonomics.
+ *
+ * All OTel spans are accepted by default and handed to the existing background
+ * batch processor. Initialize this before provider/framework clients so their
+ * instrumentation acquires the same global OTel provider.
+ */
+export declare function initLogger(options?: InitLoggerOptions): Logger;
+/** The logger most recently initialized with `setCurrent !== false`. */
+export declare function currentLogger(): Logger | undefined;
+/** Active span, or a safe no-op span when no traced scope is active. */
+export declare function currentSpan(): AtlanSpan;
+/** Start a manual span from the current tracing client. */
+export declare function startSpan(name: string, options?: StartSpanOptions): AtlanSpan;
+export declare function startSpan(args?: StartSpanArgs): AtlanSpan;
+/** Run a callback in an automatically ended current span. */
+export declare function traced<T>(callback: (span: AtlanSpan) => T, args?: StartSpanArgs): T;
+/** Braintrust-compatible function wrapper, backed by `observe`. */
+export declare function wrapTraced<F extends AnyFunction>(fn: F, options?: WrapTracedOptions): F;
+/** Common alias used by other tracing SDKs. */
+export declare const traceable: typeof wrapTraced;
+export {};

package/dist/tracing/compat.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Low-friction tracing compatibility helpers.
+ *
+ * The implementation deliberately reuses the SDK's OTel pipeline: ended spans
+ * enter its bounded background batcher, `flush()` drains that same queue, and
+ * third-party OTel instrumentation shares the same provider. There is no
+ * second transport or vendor-specific event format to keep in sync.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceable = exports.Logger = void 0;
+exports.initLogger = initLogger;
+exports.currentLogger = currentLogger;
+exports.currentSpan = currentSpan;
+exports.startSpan = startSpan;
+exports.traced = traced;
+exports.wrapTraced = wrapTraced;
+const client_js_1 = require("./client.js");
+const observe_js_1 = require("./observe.js");
+const LOGGER_SLOT = Symbol.for("atlanai.current-logger.v1");
+function loggerHost() {
+    return globalThis;
+}
+function allSpans(_) {
+    return true;
+}
+function spanArgs(nameOrArgs, options) {
+    if (typeof nameOrArgs === "string")
+        return { name: nameOrArgs, options };
+    const args = nameOrArgs ?? {};
+    const { name = "span", type, event, asType, fields, ...rest } = args;
+    return {
+        name,
+        options: {
+            ...rest,
+            ...(type === undefined && asType === undefined ? {} : { asType: type ?? asType }),
+            ...(event === undefined && fields === undefined ? {} : { fields: event ?? fields }),
+        },
+    };
+}
+/** A small logger facade over one Atlan OTel client. */
+class Logger {
+    client;
+    projectName;
+    asyncFlush;
+    constructor(client, projectName, asyncFlush) {
+        this.client = client;
+        this.projectName = projectName;
+        this.asyncFlush = asyncFlush;
+    }
+    startSpan(nameOrArgs, options = {}) {
+        const resolved = spanArgs(nameOrArgs, options);
+        return this.client.startSpan(resolved.name, resolved.options);
+    }
+    /** Run a callback with an automatically ended, ambient current span. */
+    traced(callback, args = {}) {
+        const resolved = spanArgs(args, {});
+        return this.client.startAsCurrentSpan(resolved.name, resolved.options, callback);
+    }
+    /** Log one complete root event. Delivery is asynchronous by default. */
+    log(event) {
+        const { name = "event", type = "task", ...fields } = event;
+        const span = this.client.startSpan(name, { asType: type, fields });
+        const identity = { traceId: span.traceId, spanId: span.spanId };
+        span.end();
+        if (!this.asyncFlush)
+            void this.client.flush();
+        return identity;
+    }
+    flush() {
+        return this.client.flush();
+    }
+    shutdown() {
+        return this.client.shutdown();
+    }
+}
+exports.Logger = Logger;
+/**
+ * Initialize production tracing with Braintrust-style logger ergonomics.
+ *
+ * All OTel spans are accepted by default and handed to the existing background
+ * batch processor. Initialize this before provider/framework clients so their
+ * instrumentation acquires the same global OTel provider.
+ */
+function initLogger(options = {}) {
+    const { projectName, projectId, serviceName, asyncFlush = true, captureAll = true, setCurrent = true, shouldExportSpan, ...initOptions } = options;
+    const resolvedName = serviceName ?? projectName ?? projectId ?? "global";
+    const exportPredicate = shouldExportSpan ?? (captureAll ? allSpans : undefined);
+    const client = (0, client_js_1.init)({
+        ...initOptions,
+        serviceName: resolvedName,
+        exportMode: asyncFlush ? "batch" : "immediate",
+        ...(exportPredicate === undefined ? {} : { shouldExportSpan: exportPredicate }),
+    });
+    const logger = new Logger(client, resolvedName, asyncFlush);
+    if (setCurrent)
+        loggerHost()[LOGGER_SLOT] = logger;
+    return logger;
+}
+/** The logger most recently initialized with `setCurrent !== false`. */
+function currentLogger() {
+    return loggerHost()[LOGGER_SLOT];
+}
+/** Active span, or a safe no-op span when no traced scope is active. */
+function currentSpan() {
+    return (0, client_js_1.getClient)().currentSpan();
+}
+function startSpan(nameOrArgs, options = {}) {
+    const resolved = spanArgs(nameOrArgs, options);
+    return (0, client_js_1.getClient)().startSpan(resolved.name, resolved.options);
+}
+/** Run a callback in an automatically ended current span. */
+function traced(callback, args = {}) {
+    const resolved = spanArgs(args, {});
+    return (0, client_js_1.getClient)().startAsCurrentSpan(resolved.name, resolved.options, callback);
+}
+/** Braintrust-compatible function wrapper, backed by `observe`. */
+function wrapTraced(fn, options = {}) {
+    const { type, asType, noTraceIO, captureInput, captureOutput, ...rest } = options;
+    return (0, observe_js_1.observe)(fn, {
+        ...rest,
+        ...(type === undefined && asType === undefined ? {} : { asType: type ?? asType }),
+        captureInput: noTraceIO ? false : (captureInput ?? true),
+        captureOutput: noTraceIO ? false : (captureOutput ?? true),
+    });
+}
+/** Common alias used by other tracing SDKs. */
+exports.traceable = wrapTraced;

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/index.d.ts

@@ -9,6 +9,8 @@
 export { init, getClient, AtlanAI, _resetForTests, type InitOptions, type StartAsCurrentSpanOptions, type StartSpanOptions, type TraceContext, } from "./client.js";
 export { AtlanSpan, noopSpan, resolveSpanType, ROOT_SPAN_CONTEXT_KEY, type ScoreOptions, type UpdateFields, } from "./spans.js";
 export { observe, type ObserveOptions } from "./observe.js";
+export { aiTelemetry, wrapAISDK, type AITelemetryOptions, type AITelemetrySettings, } from "./integrations.js";
+export { Logger, currentLogger, currentSpan, initLogger, startSpan, traceable, traced, wrapTraced, type InitLoggerOptions, type LogEvent, type LoggedSpan, type StartSpanArgs, type WrapTracedOptions, } from "./compat.js";
 export { createSpanId, createSpanIdAsync, createTraceId, createTraceIdAsync } from "./ids.js";
 export { isMessageShaped, serializePayload, toJsonable, truncateUtf8, MAX_DEPTH, TRUNCATION_SUFFIX, } from "./serialize.js";
 export { AtlanConfigError, DEFAULT_BASE_URL, resolveConfig, type ConfigOptions, type Mode, type ResolvedConfig, } from "./config.js";

package/dist/tracing/index.js

@@ -41,7 +41,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.semconv = exports.SDK_VERSION = exports.SDK_LANGUAGE = exports.MaskingSpanExporter = exports.MASK_FAILURE_PLACEHOLDER = exports.applyMask = exports.AtlanSpanProcessor = exports.KNOWN_INSTRUMENTATION_SCOPE_PREFIXES = exports.isKnownInstrumentorSpan = exports.isGenAiSpan = exports.isAtlanSdkSpan = exports.defaultShouldExport = exports.ATLAN_SDK_SCOPE = exports.VisitorIdentifyError = exports.propagateAttributes = exports.resolveConfig = exports.DEFAULT_BASE_URL = exports.AtlanConfigError = exports.TRUNCATION_SUFFIX = exports.MAX_DEPTH = exports.truncateUtf8 = exports.toJsonable = exports.serializePayload = exports.isMessageShaped = exports.createTraceIdAsync = exports.createTraceId = exports.createSpanIdAsync = exports.createSpanId = exports.observe = exports.ROOT_SPAN_CONTEXT_KEY = exports.resolveSpanType = exports.noopSpan = exports.AtlanSpan = exports._resetForTests = exports.AtlanAI = exports.getClient = exports.init = void 0;
+exports.semconv = exports.SDK_VERSION = exports.SDK_LANGUAGE = exports.MaskingSpanExporter = exports.MASK_FAILURE_PLACEHOLDER = exports.applyMask = exports.AtlanSpanProcessor = exports.KNOWN_INSTRUMENTATION_SCOPE_PREFIXES = exports.isKnownInstrumentorSpan = exports.isGenAiSpan = exports.isAtlanSdkSpan = exports.defaultShouldExport = exports.ATLAN_SDK_SCOPE = exports.VisitorIdentifyError = exports.propagateAttributes = exports.resolveConfig = exports.DEFAULT_BASE_URL = exports.AtlanConfigError = exports.TRUNCATION_SUFFIX = exports.MAX_DEPTH = exports.truncateUtf8 = exports.toJsonable = exports.serializePayload = exports.isMessageShaped = exports.createTraceIdAsync = exports.createTraceId = exports.createSpanIdAsync = exports.createSpanId = exports.wrapTraced = exports.traced = exports.traceable = exports.startSpan = exports.initLogger = exports.currentSpan = exports.currentLogger = exports.Logger = exports.wrapAISDK = exports.aiTelemetry = exports.observe = exports.ROOT_SPAN_CONTEXT_KEY = exports.resolveSpanType = exports.noopSpan = exports.AtlanSpan = exports._resetForTests = exports.AtlanAI = exports.getClient = exports.init = void 0;
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "init", { enumerable: true, get: function () { return client_js_1.init; } });
 Object.defineProperty(exports, "getClient", { enumerable: true, get: function () { return client_js_1.getClient; } });
@@ -54,6 +54,18 @@ Object.defineProperty(exports, "resolveSpanType", { enumerable: true, get: funct
 Object.defineProperty(exports, "ROOT_SPAN_CONTEXT_KEY", { enumerable: true, get: function () { return spans_js_1.ROOT_SPAN_CONTEXT_KEY; } });
 var observe_js_1 = require("./observe.js");
 Object.defineProperty(exports, "observe", { enumerable: true, get: function () { return observe_js_1.observe; } });
+var integrations_js_1 = require("./integrations.js");
+Object.defineProperty(exports, "aiTelemetry", { enumerable: true, get: function () { return integrations_js_1.aiTelemetry; } });
+Object.defineProperty(exports, "wrapAISDK", { enumerable: true, get: function () { return integrations_js_1.wrapAISDK; } });
+var compat_js_1 = require("./compat.js");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return compat_js_1.Logger; } });
+Object.defineProperty(exports, "currentLogger", { enumerable: true, get: function () { return compat_js_1.currentLogger; } });
+Object.defineProperty(exports, "currentSpan", { enumerable: true, get: function () { return compat_js_1.currentSpan; } });
+Object.defineProperty(exports, "initLogger", { enumerable: true, get: function () { return compat_js_1.initLogger; } });
+Object.defineProperty(exports, "startSpan", { enumerable: true, get: function () { return compat_js_1.startSpan; } });
+Object.defineProperty(exports, "traceable", { enumerable: true, get: function () { return compat_js_1.traceable; } });
+Object.defineProperty(exports, "traced", { enumerable: true, get: function () { return compat_js_1.traced; } });
+Object.defineProperty(exports, "wrapTraced", { enumerable: true, get: function () { return compat_js_1.wrapTraced; } });
 var ids_js_1 = require("./ids.js");
 Object.defineProperty(exports, "createSpanId", { enumerable: true, get: function () { return ids_js_1.createSpanId; } });
 Object.defineProperty(exports, "createSpanIdAsync", { enumerable: true, get: function () { return ids_js_1.createSpanIdAsync; } });

package/dist/tracing/integrations.d.ts

@@ -0,0 +1,35 @@
+/** Framework integration helpers that reuse the Atlan OpenTelemetry pipeline. */
+import type { Tracer } from "@opentelemetry/api";
+import { type Logger } from "./compat.js";
+export interface AITelemetryOptions {
+    /** Logger whose provider should create framework spans. Defaults to the current logger. */
+    logger?: Pick<Logger, "client">;
+    /** Vercel AI SDK function identifier. */
+    functionId?: string;
+    metadata?: Record<string, unknown>;
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+    /** Replace a tracer already present on the call. Defaults to false. */
+    replaceTracer?: boolean;
+}
+export interface AITelemetrySettings {
+    isEnabled: true;
+    tracer: Tracer;
+    functionId?: string;
+    metadata?: Record<string, unknown>;
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+}
+/**
+ * Build the native `experimental_telemetry` value used by Vercel AI SDK v3-v6.
+ * No Vercel dependency or vendor wrapper is required.
+ */
+export declare function aiTelemetry(options?: AITelemetryOptions): AITelemetrySettings;
+/**
+ * Braintrust-shaped Vercel AI SDK wrapper.
+ *
+ * Known generation/embedding functions and agent constructors receive native
+ * `experimental_telemetry`; all other exports pass through untouched. The
+ * returned proxy preserves the original namespace's types and lazy getters.
+ */
+export declare function wrapAISDK<T extends object>(sdk: T, options?: AITelemetryOptions): T;