@atlanai/sdk 0.1.0

package/dist/tracing/spans.js

@@ -0,0 +1,306 @@
+"use strict";
+/**
+ * AtlanSpan — the ergonomic wrapper over an OTel span (SPEC §9).
+ *
+ * Has-a, not is-a: the wrapper holds the OTel span and writes agent-sdk.v1
+ * attributes. The observation type is set once at creation and immutable.
+ * Every method is safe on a non-recording span (no-op posture, SPEC §10.1).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtlanSpan = exports.ROOT_SPAN_CONTEXT_KEY = void 0;
+exports.resolveSpanType = resolveSpanType;
+exports.noopSpan = noopSpan;
+const api_1 = require("@opentelemetry/api");
+const logger_js_1 = require("./logger.js");
+const masking_js_1 = require("./masking.js");
+const propagation_js_1 = require("./propagation.js");
+const sc = __importStar(require("./semconv.js"));
+const serialize_js_1 = require("./serialize.js");
+const USAGE_ATTRIBUTES = {
+    input_tokens: sc.GEN_AI_USAGE_INPUT_TOKENS,
+    output_tokens: sc.GEN_AI_USAGE_OUTPUT_TOKENS,
+    total_tokens: sc.GEN_AI_USAGE_TOTAL_TOKENS,
+    cache_read_input_tokens: sc.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS,
+    cache_creation_input_tokens: sc.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,
+};
+const COST_ATTRIBUTES = {
+    input: sc.GEN_AI_USAGE_INPUT_COST,
+    output: sc.GEN_AI_USAGE_OUTPUT_COST,
+    total: sc.GEN_AI_USAGE_COST,
+};
+/**
+ * Tracks the root AtlanSpan of the currently active trace so scoreTrace() can
+ * target it (SPEC §9.4). Set by client.startAsCurrentSpan.
+ */
+exports.ROOT_SPAN_CONTEXT_KEY = (0, api_1.createContextKey)("atlan.root_span");
+const SCORE_EVENT_NAME = "atlan.score";
+function resolveSpanType(asType) {
+    const resolved = sc.SPAN_TYPE_ALIASES[asType] ?? asType;
+    if (!sc.SPAN_TYPES.includes(resolved)) {
+        logger_js_1.logger.warn(`unknown span type ${asType}; using 'task'`);
+        return "task";
+    }
+    return resolved;
+}
+function asInt(value) {
+    if (typeof value === "boolean")
+        return null;
+    if (typeof value === "number" && Number.isInteger(value))
+        return value;
+    return null;
+}
+function asFloat(value) {
+    if (typeof value === "boolean")
+        return null;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    return null;
+}
+class AtlanSpan {
+    otel;
+    config;
+    mask;
+    constructor(otelSpan, config, mask) {
+        this.otel = otelSpan;
+        this.config = config;
+        this.mask = mask;
+    }
+    get otelSpan() {
+        return this.otel;
+    }
+    get traceId() {
+        return this.otel.spanContext().traceId;
+    }
+    get spanId() {
+        return this.otel.spanContext().spanId;
+    }
+    /** @internal */
+    _initialize(asType, asRoot) {
+        if (!this.otel.isRecording())
+            return;
+        this.otel.setAttribute(sc.ATLAN_SPAN_TYPE, resolveSpanType(asType));
+        if (asRoot)
+            this.otel.setAttribute(sc.ATLAN_INTERNAL_AS_ROOT, true);
+    }
+    serialize(value) {
+        return (0, serialize_js_1.serializePayload)(value, this.config.maxPayloadBytes);
+    }
+    update(fields) {
+        const span = this.otel;
+        if (!span.isRecording())
+            return this;
+        const contentOk = this.config.traceContent;
+        if (fields.input !== undefined && contentOk) {
+            const masked = (0, masking_js_1.applyMask)(this.mask, fields.input);
+            const key = (0, serialize_js_1.isMessageShaped)(masked) ? sc.GEN_AI_INPUT_MESSAGES : sc.ATLAN_INPUT;
+            span.setAttribute(key, this.serialize(masked));
+        }
+        if (fields.output !== undefined && contentOk) {
+            const masked = (0, masking_js_1.applyMask)(this.mask, fields.output);
+            const key = (0, serialize_js_1.isMessageShaped)(masked) ? sc.GEN_AI_OUTPUT_MESSAGES : sc.ATLAN_OUTPUT;
+            span.setAttribute(key, this.serialize(masked));
+        }
+        if (fields.metadata && contentOk) {
+            const masked = (0, masking_js_1.applyMask)(this.mask, fields.metadata);
+            if (masked !== null && typeof masked === "object" && !Array.isArray(masked)) {
+                span.setAttributes((0, propagation_js_1.flattenMetadata)(masked));
+            }
+            else {
+                // A mask that collapses metadata to a scalar (incl. the failure
+                // placeholder) lands under the reserved `value` key.
+                span.setAttributes((0, propagation_js_1.flattenMetadata)({ value: masked }));
+            }
+        }
+        if (fields.tags && fields.tags.length > 0) {
+            span.setAttribute(sc.ATLAN_TAGS, fields.tags.map((tag) => String(tag)));
+        }
+        if (fields.model !== undefined)
+            span.setAttribute(sc.GEN_AI_REQUEST_MODEL, fields.model);
+        if (fields.responseModel !== undefined) {
+            span.setAttribute(sc.GEN_AI_RESPONSE_MODEL, fields.responseModel);
+        }
+        if (fields.provider !== undefined)
+            span.setAttribute(sc.GEN_AI_PROVIDER_NAME, fields.provider);
+        if (fields.responseId !== undefined)
+            span.setAttribute(sc.GEN_AI_RESPONSE_ID, fields.responseId);
+        if (fields.usage) {
+            for (const [key, attribute] of Object.entries(USAGE_ATTRIBUTES)) {
+                const value = fields.usage[key];
+                if (value === undefined || value === null)
+                    continue;
+                const coerced = asInt(value);
+                if (coerced === null) {
+                    // SPEC §9.5: token counters MUST be OTLP IntValue.
+                    logger_js_1.logger.warn(`dropping non-integral usage ${key}=${JSON.stringify(value)}`);
+                    continue;
+                }
+                span.setAttribute(attribute, coerced);
+            }
+        }
+        if (fields.cost) {
+            for (const [key, attribute] of Object.entries(COST_ATTRIBUTES)) {
+                const value = fields.cost[key];
+                if (value === undefined || value === null)
+                    continue;
+                const coerced = asFloat(value);
+                if (coerced === null) {
+                    logger_js_1.logger.warn(`dropping non-numeric cost ${key}=${JSON.stringify(value)}`);
+                    continue;
+                }
+                span.setAttribute(attribute, coerced);
+            }
+        }
+        if (fields.toolName !== undefined)
+            span.setAttribute(sc.GEN_AI_TOOL_NAME, fields.toolName);
+        if (fields.toolCallId !== undefined) {
+            span.setAttribute(sc.GEN_AI_TOOL_CALL_ID, fields.toolCallId);
+        }
+        if (fields.toolArguments !== undefined && contentOk) {
+            span.setAttribute(sc.GEN_AI_TOOL_CALL_ARGUMENTS, this.serialize((0, masking_js_1.applyMask)(this.mask, fields.toolArguments)));
+        }
+        if (fields.toolResult !== undefined && contentOk) {
+            span.setAttribute(sc.GEN_AI_TOOL_CALL_RESULT, this.serialize((0, masking_js_1.applyMask)(this.mask, fields.toolResult)));
+        }
+        if (fields.level !== undefined) {
+            if (!sc.OBSERVATION_LEVELS.includes(fields.level)) {
+                logger_js_1.logger.warn(`unknown level ${fields.level}; ignoring`);
+            }
+            else {
+                span.setAttribute(sc.ATLAN_OBSERVATION_LEVEL, fields.level);
+                if (fields.level === "ERROR") {
+                    span.setStatus({
+                        code: api_1.SpanStatusCode.ERROR,
+                        ...(fields.statusMessage !== undefined ? { message: fields.statusMessage } : {}),
+                    });
+                }
+            }
+        }
+        if (fields.statusMessage !== undefined) {
+            span.setAttribute(sc.ATLAN_OBSERVATION_STATUS_MESSAGE, fields.statusMessage);
+        }
+        return this;
+    }
+    /**
+     * Attach a score to this span (SPEC §9.4): an `atlan.score` event plus a
+     * rollup attribute `atlan.score.{name}`.
+     *
+     * NUMERIC requires a numeric value; CATEGORICAL requires stringValue
+     * (numeric value defaults to 0.0); BOOLEAN encodes value as 0/1.
+     * Invalid scores are dropped with a warning — never thrown.
+     */
+    score(name, value, options = {}) {
+        const span = this.otel;
+        if (!span.isRecording())
+            return;
+        if (!name || typeof name !== "string") {
+            logger_js_1.logger.warn(`dropping score with invalid name ${JSON.stringify(name)}`);
+            return;
+        }
+        const dataType = options.dataType ?? "NUMERIC";
+        if (!sc.SCORE_DATA_TYPES.includes(dataType)) {
+            logger_js_1.logger.warn(`dropping score ${name} with unknown dataType ${String(dataType)}`);
+            return;
+        }
+        let numeric;
+        if (dataType === "NUMERIC") {
+            const coerced = asFloat(value);
+            if (coerced === null) {
+                logger_js_1.logger.warn(`dropping NUMERIC score ${name} with non-numeric value ${JSON.stringify(value)}`);
+                return;
+            }
+            numeric = coerced;
+        }
+        else if (dataType === "CATEGORICAL") {
+            if (!options.stringValue) {
+                logger_js_1.logger.warn(`dropping CATEGORICAL score ${name} without stringValue`);
+                return;
+            }
+            numeric = asFloat(value) ?? 0.0;
+        }
+        else {
+            // BOOLEAN
+            if (value === undefined || value === null) {
+                logger_js_1.logger.warn(`dropping BOOLEAN score ${name} without value`);
+                return;
+            }
+            numeric = value ? 1.0 : 0.0;
+        }
+        const eventAttributes = {
+            [`${sc.ATLAN_SCORE_PREFIX}name`]: name,
+            [`${sc.ATLAN_SCORE_PREFIX}value`]: numeric,
+            [`${sc.ATLAN_SCORE_PREFIX}data_type`]: dataType,
+        };
+        if (options.stringValue !== undefined) {
+            eventAttributes[`${sc.ATLAN_SCORE_PREFIX}string_value`] = options.stringValue;
+        }
+        if (options.comment !== undefined) {
+            eventAttributes[`${sc.ATLAN_SCORE_PREFIX}comment`] = options.comment;
+        }
+        span.addEvent(SCORE_EVENT_NAME, eventAttributes);
+        span.setAttribute(`${sc.ATLAN_SCORE_PREFIX}${name}`, numeric);
+    }
+    /**
+     * Attach a score to the current trace's root span when resolvable
+     * in-process, else to this span (SPEC §9.4).
+     */
+    scoreTrace(name, value, options = {}) {
+        const root = api_1.context.active().getValue(exports.ROOT_SPAN_CONTEXT_KEY);
+        if (root instanceof AtlanSpan &&
+            root !== this &&
+            root.traceId === this.traceId &&
+            root.otel.isRecording()) {
+            root.score(name, value, options);
+            return;
+        }
+        logger_js_1.logger.debug("scoreTrace falling back to the current span");
+        this.score(name, value, options);
+    }
+    /** Record an exception and mark the span ERROR (SPEC §9.2). */
+    recordFailure(error) {
+        if (!this.otel.isRecording())
+            return;
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.otel.recordException(err);
+        this.update({ level: "ERROR", statusMessage: err.message || err.name });
+    }
+    end(endTime) {
+        this.otel.end(endTime);
+    }
+}
+exports.AtlanSpan = AtlanSpan;
+function noopSpan(config) {
+    return new AtlanSpan(api_1.trace.wrapSpanContext(api_1.INVALID_SPAN_CONTEXT), config);
+}

package/dist/tracing/version.d.ts

@@ -0,0 +1,4 @@
+/** SDK identity (SPEC §2.2, §5.1). Kept in sync with package.json — the
+ * version test fails the build on drift. */
+export declare const SDK_LANGUAGE = "typescript";
+export declare const SDK_VERSION = "0.1.0";

package/dist/tracing/version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = exports.SDK_LANGUAGE = void 0;
+/** SDK identity (SPEC §2.2, §5.1). Kept in sync with package.json — the
+ * version test fails the build on drift. */
+exports.SDK_LANGUAGE = "typescript";
+exports.SDK_VERSION = "0.1.0";

package/dist/tracing/visitor.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Visitor identity client for Agent Gateway.
+ *
+ * identify() persists the source-qualified profile and returns its canonical
+ * artifact handle. It never installs mutable process-global identity; callers
+ * carry the handle through propagateAttributes({ visitorId }, fn).
+ */
+import { type ResolvedConfig } from "./config.js";
+export type VisitorType = "human" | "agent";
+export interface Visitor {
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly identitySource: string;
+    readonly externalId: string;
+    readonly name: string;
+    readonly email: string | undefined;
+    readonly visitorType: VisitorType;
+    readonly attributes: Readonly<Record<string, unknown>>;
+    readonly linkedUserId: string | undefined;
+    readonly linkStatus: "unlinked" | "linked" | "no_match";
+}
+export interface IdentifyVisitorOptions {
+    /** Namespace that owns externalId, for example "slack" or "atlan_directory". */
+    identitySource: string;
+    /** Stable ID from that source. Use an immutable database ID, not email. */
+    externalId: string;
+    /** Standard name/email traits plus bounded custom profile traits. */
+    traits?: Readonly<Record<string, unknown>>;
+    /** Omit on update to preserve the current value; new Visitors default to human. */
+    visitorType?: VisitorType;
+}
+export declare class VisitorIdentifyError extends Error {
+    readonly statusCode: number | undefined;
+    readonly code: string | undefined;
+    constructor(message: string, options?: {
+        statusCode?: number;
+        code?: string;
+    });
+}
+export declare function identifyVisitor(config: ResolvedConfig, options: IdentifyVisitorOptions): Promise<Visitor | undefined>;

package/dist/tracing/visitor.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * Visitor identity client for Agent Gateway.
+ *
+ * identify() persists the source-qualified profile and returns its canonical
+ * artifact handle. It never installs mutable process-global identity; callers
+ * carry the handle through propagateAttributes({ visitorId }, fn).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisitorIdentifyError = void 0;
+exports.identifyVisitor = identifyVisitor;
+const config_js_1 = require("./config.js");
+const version_js_1 = require("./version.js");
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+const VISITOR_TYPES = new Set(["human", "agent"]);
+class VisitorIdentifyError extends Error {
+    statusCode;
+    code;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "VisitorIdentifyError";
+        this.statusCode = options.statusCode;
+        this.code = options.code;
+    }
+}
+exports.VisitorIdentifyError = VisitorIdentifyError;
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(value, field) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new VisitorIdentifyError(`visitor identify returned an invalid ${field}`);
+    }
+    return value;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function decodeVisitor(value) {
+    if (!isRecord(value)) {
+        throw new VisitorIdentifyError("visitor identify returned an invalid payload");
+    }
+    const visitorType = requiredString(value.visitor_type, "visitor_type");
+    if (!VISITOR_TYPES.has(visitorType)) {
+        throw new VisitorIdentifyError("visitor identify returned an invalid visitor_type");
+    }
+    const linkStatus = requiredString(value.link_status, "link_status");
+    if (!new Set(["unlinked", "linked", "no_match"]).has(linkStatus)) {
+        throw new VisitorIdentifyError("visitor identify returned an invalid link_status");
+    }
+    const attributes = value.attributes ?? {};
+    if (!isRecord(attributes)) {
+        throw new VisitorIdentifyError("visitor identify returned invalid attributes");
+    }
+    return Object.freeze({
+        id: requiredString(value.id, "id"),
+        workspaceId: requiredString(value.workspace_id, "workspace_id"),
+        identitySource: requiredString(value.identity_source, "identity_source"),
+        externalId: requiredString(value.external_id, "external_id"),
+        name: requiredString(value.display_name, "display_name"),
+        email: optionalString(value.email),
+        visitorType: visitorType,
+        attributes: Object.freeze({ ...attributes }),
+        linkedUserId: optionalString(value.linked_user_id),
+        linkStatus: linkStatus,
+    });
+}
+/**
+ * Read at most `MAX_RESPONSE_BYTES`, stopping at the cap rather than measuring
+ * after the fact.
+ *
+ * `response.text()` buffers the whole body first, so the size check it fed ran
+ * only once the bytes were already resident — the limit rejected an oversized
+ * response without ever having refused to hold it, which is the one thing it
+ * existed to do. `atlanai-sdk-python` bounds the read itself
+ * (`response.read(_MAX_RESPONSE_BYTES + 1)`); this is that behaviour, expressed
+ * against a stream.
+ *
+ * Cancelling the reader also drops the connection, so an endpoint that streams
+ * forever costs one chunk past the cap rather than the caller's memory.
+ */
+async function readBounded(response) {
+    if (!response.body)
+        return "";
+    const stream = response.body;
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done || value === undefined)
+                break;
+            total += value.byteLength;
+            if (total > MAX_RESPONSE_BYTES) {
+                throw new VisitorIdentifyError("visitor identify response exceeded 1 MiB");
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        // Releases the connection whether we finished or bailed at the cap.
+        await reader.cancel().catch(() => { });
+    }
+    const joined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        joined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(joined);
+}
+async function responseJson(response) {
+    const raw = await readBounded(response);
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new VisitorIdentifyError("visitor identify returned invalid JSON");
+    }
+}
+async function identifyVisitor(config, options) {
+    if (!config.apiKey || !config.workspaceId || !(0, config_js_1.validAtlanBaseUrl)(config.baseUrl)) {
+        return undefined;
+    }
+    const identitySource = options.identitySource.trim().toLowerCase();
+    const externalId = options.externalId.trim();
+    if (identitySource.length === 0)
+        throw new TypeError("identitySource is required");
+    if (externalId.length === 0)
+        throw new TypeError("externalId is required");
+    if (options.visitorType !== undefined && !VISITOR_TYPES.has(options.visitorType)) {
+        throw new TypeError("visitorType must be 'human' or 'agent'");
+    }
+    const profile = { ...(options.traits ?? {}) };
+    const namePresent = Object.hasOwn(profile, "name");
+    const name = profile.name;
+    delete profile.name;
+    if (namePresent && typeof name !== "string") {
+        throw new TypeError("traits.name must be a string");
+    }
+    const emailPresent = Object.hasOwn(profile, "email");
+    const email = profile.email;
+    delete profile.email;
+    if (emailPresent && email !== null && typeof email !== "string") {
+        throw new TypeError("traits.email must be a string or null");
+    }
+    const body = {
+        workspace_id: config.workspaceId,
+        identity_source: identitySource,
+        external_id: externalId,
+        ...(namePresent ? { name } : {}),
+        ...(emailPresent ? { email } : {}),
+        ...(options.visitorType !== undefined ? { visitor_type: options.visitorType } : {}),
+        ...(Object.keys(profile).length > 0 ? { attributes: profile } : {}),
+    };
+    let encoded;
+    try {
+        encoded = JSON.stringify(body);
+    }
+    catch {
+        throw new TypeError("visitor traits must be JSON-serializable");
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.round(config.timeoutS * 1000));
+    // Held until the body is consumed, not just until the headers land. Clearing it
+    // the moment `fetch` resolved left every body read below unbounded, so a peer
+    // that sent headers and then stalled ignored `timeoutS` completely — the one
+    // shape a request timeout is for. `signal` aborts the body stream too, so the
+    // deadline now covers the whole exchange.
+    try {
+        let response;
+        try {
+            response = await fetch(`${config.baseUrl}/agent/v1/visitors/identify`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${config.apiKey}`,
+                    "X-Atlan-Workspace-Id": config.workspaceId,
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                    "x-atlan-sdk-name": version_js_1.SDK_LANGUAGE,
+                    "x-atlan-sdk-version": version_js_1.SDK_VERSION,
+                    // Identify ourselves rather than relying on whatever the runtime's
+                    // fetch sends by default. Edge bot filtering in front of the gateway
+                    // 403s `Python-urllib/*` on every route, which is what broke the
+                    // Python SDK's identify in production; `node` happens to sit on the
+                    // allowed side of that denylist today, so this parity fix removes a
+                    // coincidence rather than a symptom.
+                    "User-Agent": `atlanai/${version_js_1.SDK_VERSION}`,
+                },
+                body: encoded,
+                signal: controller.signal,
+            });
+        }
+        catch {
+            throw new VisitorIdentifyError("visitor identify could not reach Agent Gateway");
+        }
+        if (response.status !== 200 && response.status !== 201) {
+            let code;
+            try {
+                const problem = await responseJson(response);
+                if (isRecord(problem) && typeof problem.code === "string")
+                    code = problem.code;
+            }
+            catch {
+                // The status is the contract when an intermediary replaces the problem body.
+            }
+            throw new VisitorIdentifyError(`visitor identify failed with HTTP ${response.status}`, {
+                statusCode: response.status,
+                ...(code !== undefined ? { code } : {}),
+            });
+        }
+        return finish(await responseJson(response), identitySource, externalId, config);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/** Decode and confirm the reply describes the identity that was asked for. */
+function finish(payload, identitySource, externalId, config) {
+    const visitor = decodeVisitor(payload);
+    if (visitor.workspaceId !== config.workspaceId) {
+        throw new VisitorIdentifyError("visitor identify returned the wrong workspace");
+    }
+    if (visitor.identitySource !== identitySource || visitor.externalId !== externalId) {
+        throw new VisitorIdentifyError("visitor identify returned a different identity");
+    }
+    return visitor;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@atlanai/sdk",
+  "version": "0.1.0",
+  "description": "Atlan Agent Gateway management SDK",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./raw/*": {
+      "types": "./dist/raw/*/index.d.ts",
+      "require": "./dist/raw/*/index.js",
+      "default": "./dist/raw/*/index.js"
+    },
+    "./manifest.json": "./dist/manifest.json",
+    "./resources.json": "./dist/resources.json",
+    "./tracing": {
+      "types": "./dist/tracing/index.d.ts",
+      "import": "./dist/tracing/index.js",
+      "default": "./dist/tracing/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.tracing.json",
+    "test": "npm run build && node --test test/*.cjs && npm run test:tracing",
+    "pack:check": "npm pack --dry-run",
+    "test:tracing": "vitest run"
+  },
+  "devDependencies": {
+    "@langfuse/otel": "^5.11.0",
+    "@langfuse/tracing": "^5.11.0",
+    "@types/node": "^22.20.1",
+    "ai": "6.0.271",
+    "typescript": "5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^2.0.1",
+    "@opentelemetry/exporter-trace-otlp-proto": ">=0.200.0 <1",
+    "@opentelemetry/otlp-exporter-base": ">=0.200.0 <1",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-trace-base": "^2.0.1"
+  },
+  "overrides": {
+    "postcss": "8.5.26"
+  }
+}