@atlanai/sdk 0.2.2 → 0.2.3

package/README.md

@@ -120,7 +120,10 @@ await logger.flush();
 Tracing has its own API key and lifecycle. It does not reuse the management
 client's transport. It ships as a separate subpath
 (`@atlanai/sdk/tracing`) so importing it doesn't pull OpenTelemetry into a
-management-only bundle.
+management-only bundle. npm still installs the OpenTelemetry dependencies with
+the package because npm cannot make dependencies conditional on an imported
+subpath; splitting tracing into a second package would trade that install size
+for a second version and release lifecycle.
 
 Vercel AI SDK v3-v6 uses its native OpenTelemetry path:
 
@@ -138,7 +141,8 @@ context manifests, serverless flushing, and the tested integration matrix.
 ## Errors
 
 Every non-2xx response rejects with `AtlanAPIError`, with `.status`, `.code`,
-and (where the gateway includes one) `.traceId`:
+and (where the gateway includes one) `.traceId`. A failure before any response
+is also normalized as `AtlanAPIError` with `status === 0`:
 
 ```typescript
 import { AtlanAPIError } from "@atlanai/sdk";

package/dist/client.d.ts

@@ -1,5 +1,6 @@
 import { type Operation } from "./operations";
 import { type Resource } from "./resources";
+import type { ResourceMap, ResourceRoots } from "./resource-types";
 type TokenProvider = () => string | Promise<string>;
 type FetchImplementation = typeof fetch;
 type GeneratedConfiguration = {
@@ -45,11 +46,13 @@ export declare class ServiceNamespace {
 }
 /** Build a namespace that also answers its operations by method name. */
 export declare function createService(name: string, module: GeneratedModule, configuration: GeneratedConfiguration, serviceOperations: readonly Omit<Operation, "service">[]): Service;
+export interface AtlanClient extends ResourceRoots {
+}
 export declare class AtlanClient {
     /** Per-service generated clients, for an operation the map has not surfaced. */
     readonly raw: Readonly<Record<string, Service>>;
     /** Every resource, keyed by its dotted path. */
-    readonly resources: Readonly<Record<string, Resource>>;
+    readonly resources: ResourceMap & Readonly<Record<string, Resource>>;
     readonly workspace: string | undefined;
     constructor(options: AtlanClientOptions);
     /**

package/dist/client.js

@@ -154,6 +154,9 @@ function wrapGeneratedAPI(api, operationMethods) {
                     if (response instanceof Response) {
                         throw await errors_1.AtlanAPIError.fromResponse(response);
                     }
+                    const cause = error?.cause;
+                    if (cause instanceof errors_1.AtlanAPIError)
+                        throw cause;
                     throw error;
                 }
             };
@@ -264,10 +267,19 @@ function withTimeout(baseFetch, timeoutMs) {
         const callerSignal = init?.signal;
         const forwardAbort = () => controller.abort(callerSignal?.reason);
         callerSignal?.addEventListener("abort", forwardAbort, { once: true });
-        const timer = setTimeout(() => controller.abort(new Error("request timed out")), timeoutMs);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort(new Error("request timed out"));
+        }, timeoutMs);
         try {
             return await baseFetch(input, { ...init, signal: controller.signal });
         }
+        catch (error) {
+            if (callerSignal?.aborted || error instanceof errors_1.AtlanAPIError)
+                throw error;
+            throw errors_1.AtlanAPIError.fromConnectionError(timedOut);
+        }
         finally {
             clearTimeout(timer);
             callerSignal?.removeEventListener("abort", forwardAbort);

package/dist/errors.d.ts

@@ -12,4 +12,5 @@ export declare class AtlanAPIError extends Error {
         traceId?: string;
     });
     static fromResponse(response: Response): Promise<AtlanAPIError>;
+    static fromConnectionError(timedOut?: boolean): AtlanAPIError;
 }

package/dist/errors.js

@@ -9,7 +9,10 @@ class AtlanAPIError extends Error {
     traceId;
     constructor(options) {
         const suffix = options.code ? ` (${options.code})` : "";
-        super(`Atlan API request failed with status ${options.status}${suffix}`);
+        const message = options.status === 0
+            ? `${options.title ?? "Could not reach the Atlan Gateway"}${options.detail ? `; ${options.detail}` : ""}`
+            : `Atlan API request failed with status ${options.status}${suffix}`;
+        super(message);
         this.name = "AtlanAPIError";
         this.status = options.status;
         this.code = options.code ?? "";
@@ -39,5 +42,13 @@ class AtlanAPIError extends Error {
             traceId: typeof problem.trace_id === "string" ? problem.trace_id : undefined,
         });
     }
+    static fromConnectionError(timedOut = false) {
+        return new AtlanAPIError({
+            status: 0,
+            code: timedOut ? "request_timeout" : "connection_error",
+            title: timedOut ? "Atlan Gateway request timed out" : "Could not reach the Atlan Gateway",
+            detail: "Check gatewayOrigin, DNS, VPN, and network access",
+        });
+    }
 }
 exports.AtlanAPIError = AtlanAPIError;

package/dist/evals.d.ts

@@ -6,6 +6,7 @@ export interface ContextItem {
     name: string;
     digest: string;
     version: string;
+    artifactKind?: string;
     artifactId?: string;
     versionOrdinal?: number;
 }
@@ -14,6 +15,7 @@ export interface ContextManifestItem {
     name: string;
     digest: string;
     version: string;
+    artifact_kind?: string;
     artifact_id?: string;
     version_ordinal?: number;
 }
@@ -49,7 +51,7 @@ export interface EvalCase<Input, Expected = unknown, Metadata = Record<string, u
     expected?: Expected;
     metadata?: Metadata;
     tags?: readonly string[];
-    /** Registry dataset-record join; normally populated by `dataset`. */
+    /** Stable case checkpoint ID. Dataset-backed runs use the Registry record ID. */
     id?: string;
 }
 export interface EvalHooks<Expected, Metadata> {
@@ -149,6 +151,7 @@ export interface EvalResultWithSummary<Input, Output, Expected, Metadata> {
 /** Structural trace surface keeps the management bundle decoupled at build time. */
 export interface EvalTraceSpan {
     readonly traceId: string;
+    readonly spanId?: string;
     update(fields: Record<string, unknown>): EvalTraceSpan;
     score(name: string, value: unknown, options: {
         scorerId: string;
@@ -156,6 +159,7 @@ export interface EvalTraceSpan {
         comment?: string;
     }): void;
     recordFailure(error: unknown): void;
+    markEvidenceComplete?(): EvalTraceSpan;
 }
 interface EvalTraceClient {
     readonly isEnabled: boolean;