@tracehatch/sdk 0.3.0

package/dist/index.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkU5REKR34_cjs=require('./chunk-U5REKR34.cjs');Object.defineProperty(exports,"TraceHandle",{enumerable:true,get:function(){return chunkU5REKR34_cjs.b}});Object.defineProperty(exports,"Tracehatch",{enumerable:true,get:function(){return chunkU5REKR34_cjs.l}});Object.defineProperty(exports,"addTags",{enumerable:true,get:function(){return chunkU5REKR34_cjs.g}});Object.defineProperty(exports,"flush",{enumerable:true,get:function(){return chunkU5REKR34_cjs.n}});Object.defineProperty(exports,"flushWithResult",{enumerable:true,get:function(){return chunkU5REKR34_cjs.o}});Object.defineProperty(exports,"init",{enumerable:true,get:function(){return chunkU5REKR34_cjs.m}});Object.defineProperty(exports,"score",{enumerable:true,get:function(){return chunkU5REKR34_cjs.i}});Object.defineProperty(exports,"setMetadata",{enumerable:true,get:function(){return chunkU5REKR34_cjs.h}});Object.defineProperty(exports,"setSession",{enumerable:true,get:function(){return chunkU5REKR34_cjs.f}});Object.defineProperty(exports,"setUser",{enumerable:true,get:function(){return chunkU5REKR34_cjs.e}});Object.defineProperty(exports,"shutdown",{enumerable:true,get:function(){return chunkU5REKR34_cjs.p}});Object.defineProperty(exports,"span",{enumerable:true,get:function(){return chunkU5REKR34_cjs.j}});Object.defineProperty(exports,"startTrace",{enumerable:true,get:function(){return chunkU5REKR34_cjs.c}});Object.defineProperty(exports,"tool",{enumerable:true,get:function(){return chunkU5REKR34_cjs.k}});Object.defineProperty(exports,"trace",{enumerable:true,get:function(){return chunkU5REKR34_cjs.d}});//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/index.d.cts

@@ -0,0 +1,243 @@
+type Attributes = { [x: string]: string | number | boolean | string[]; }
+
+type SpanWire = { id: string; trace_id: string; name: string; kind: "agent" | "generation" | "tool" | "retrieval" | "embedding" | "guardrail" | "custom"; status: "error" | "ok" | "cancelled"; started_at: string; ended_at: string; attempt: number; parent_id?: string | null | undefined; error?: { type?: string | undefined; message?: string | undefined; stack?: string | undefined; } | undefined; attributes?: Record<string, string | number | boolean | string[]> | undefined; input?: unknown; output?: unknown; messages?: unknown; events?: { ts: string; level: "debug" | "info" | "warn" | "error"; name: string; attributes?: Record<string, string | number | boolean | string[]> | undefined; }[] | undefined; input_bytes?: number | undefined; output_bytes?: number | undefined; messages_bytes?: number | undefined; input_truncated?: boolean | undefined; output_truncated?: boolean | undefined; messages_truncated?: boolean | undefined; }
+
+type TraceEnvelopeWire = { id: string; name: string; status: "error" | "ok" | "cancelled" | "pending"; started_at: string; agent?: string | undefined; session_id?: string | undefined; user?: { id: string; name?: string | undefined; email?: string | undefined; } | undefined; release?: string | undefined; tags?: string[] | undefined; metadata?: Record<string, unknown> | undefined; ended_at?: string | undefined; root_span_id?: string | undefined; expected_span_count?: number | undefined; input?: unknown; output?: unknown; scores?: { id: string; name: string; value: string | number; comment?: string | undefined; span_id?: string | undefined; }[] | undefined; }
+
+type SpanEventLevel = "debug" | "info" | "warn" | "error"
+
+/** What a span did (`spans.kind`, scope 02). */
+declare const SPAN_KIND: readonly ["agent", "generation", "tool", "retrieval", "embedding", "guardrail", "custom"];
+type SpanKind = (typeof SPAN_KIND)[number];
+
+/** Platform-neutral redaction, also bundled into the SDK. */
+interface RedactionOptions {
+    /** Built-in detectors and credential-key filtering are enabled by default. */
+    builtIns?: boolean;
+    /** Additional expressions are applied globally without mutating their lastIndex. */
+    rules?: readonly {
+        name: string;
+        pattern: RegExp;
+    }[];
+}
+
+type User = NonNullable<TraceEnvelopeWire["user"]>;
+type Outcome = "ok" | "error" | "cancelled";
+/** Delivery counters cover this client lifetime; acceptance is not persistence. */
+interface FlushResult {
+    status: "disabled" | "empty" | "accepted" | "timeout" | "failed";
+    acceptedSpans: number;
+    droppedSpans: number;
+    pendingSpans: number;
+    /** A safe SDK/API code, never request details or arbitrary server text. */
+    lastError?: {
+        code: string;
+        httpStatus?: number;
+    };
+}
+interface ScoreOptions {
+    name: string;
+    value: number | string;
+    comment?: string;
+    /** Omit to score the trace; set an existing span handle's id to score that span. */
+    spanId?: string;
+}
+interface InitOptions {
+    apiKey?: string;
+    /** Trusted API origin or base; required with an API key, here or via TRACEHATCH_BASE_URL. */
+    baseUrl?: string;
+    release?: string;
+    agent?: string;
+    captureBodies?: boolean;
+    redact?: false | RedactionOptions;
+    sampling?: {
+        rate: number;
+    };
+    debug?: boolean;
+    flushOnExit?: boolean;
+}
+interface SpanOptions {
+    input?: unknown;
+    attributes?: Attributes;
+    signal?: AbortSignal;
+}
+interface TraceOptions {
+    agent?: string;
+    rootName?: string;
+    input?: unknown;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    user?: User;
+    signal?: AbortSignal;
+}
+interface SpanHandle {
+    readonly id: string;
+    setOutput(value: unknown): void;
+    setAttributes(attributes: Attributes): void;
+    addEvent(name: string, attributes?: Attributes, level?: SpanEventLevel): void;
+}
+interface ToolOptions extends SpanOptions {
+    /** Extra attempts after the initial call; 0 by default, at most 999. */
+    retries?: number;
+    backoffMs?: number;
+}
+interface EndOptions {
+    status?: Outcome;
+    output?: unknown;
+    error?: unknown;
+    /** Wall-clock end (ISO) for steps recorded after they happened. */
+    endedAt?: string;
+}
+
+interface ExporterStats {
+    queuedSpans: number;
+    queuedBytes: number;
+    inFlightBatches: number;
+    droppedSpans: number;
+}
+
+declare class Tracehatch {
+    readonly options: {
+        captureBodies: boolean;
+        redact: false | RedactionOptions;
+        release?: string;
+        agent?: string;
+    };
+    private exporter?;
+    private enabled;
+    private rate;
+    private onExit?;
+    private closing?;
+    constructor(options: InitOptions);
+    get isEnabled(): boolean;
+    samples(id: string): boolean;
+    enqueue(span: SpanWire, trace: TraceEnvelopeWire): void;
+    flush(timeoutMs?: number): Promise<void>;
+    /** Inspect delivery during setup without making ordinary flush() reject. */
+    flushWithResult(timeoutMs?: number): Promise<FlushResult>;
+    shutdown(): Promise<void>;
+    stats(): ExporterStats;
+}
+/**
+ * Configure once per process. With an API key, every provider call made
+ * through `fetch`, every inbound HTTP request with a model call, and every
+ * explicit `trace`/`span`/`tool` is recorded. Agent and release default to
+ * the package name and the deployment's commit.
+ */
+declare function init(options?: InitOptions): Tracehatch;
+declare function flush(timeoutMs?: number): Promise<void>;
+declare function flushWithResult(timeoutMs?: number): Promise<FlushResult>;
+declare function shutdown(): Promise<void>;
+
+/** Timing the SDK's own capture paths supply for steps that already happened. */
+interface InternalSpanOptions {
+    startedAt?: string;
+}
+declare class RecordingSpan implements SpanHandle {
+    readonly trace: TraceHandle | undefined;
+    readonly parent?: RecordingSpan | undefined;
+    readonly id: string;
+    private ended;
+    private outputSet;
+    private removeAbort?;
+    private data;
+    private readonly isTool;
+    private toolCallId?;
+    constructor(trace: TraceHandle | undefined, name: string, kind: SpanKind, options?: SpanOptions, parent?: RecordingSpan | undefined, rootId?: string, internal?: InternalSpanOptions);
+    get isRecording(): boolean;
+    get isEnded(): boolean;
+    get hasOutput(): boolean;
+    private sanitize;
+    run<T>(fn: () => T): T;
+    setInput(value: unknown): void;
+    setOutput(value: unknown): void;
+    /** Size-only stream capture must never retain the generated content. */
+    setOutputBytes(bytes: number): void;
+    /** A stream assembler can truncate before the generic body size limit. */
+    markOutputTruncated(): void;
+    setMessages(value: unknown): void;
+    setAttributes(attributes: Attributes): void;
+    addEvent(name: string, attributes?: Attributes, level?: SpanEventLevel): void;
+    setAttempt(attempt: number): void;
+    end(options?: EndOptions): void;
+}
+declare function span<T>(name: string, kind: SpanKind, fn: (handle: SpanHandle) => T, options?: SpanOptions): Promise<Awaited<T>>;
+declare function tool<T>(name: string, fn: (handle: SpanHandle) => T, options?: ToolOptions): Promise<Awaited<T>>;
+
+/** Behaviour only the SDK's own capture paths need. */
+interface InternalTraceOptions {
+    /** End without sending anything when no span other than the root was recorded. */
+    discardIfEmpty?: boolean;
+    /** Only SDK-created runs derive transcript content from their provider calls. */
+    inferProviderBodies?: boolean;
+}
+interface EndTraceOptions {
+    outcome?: Outcome;
+    output?: unknown;
+    error?: unknown;
+    /** Wall-clock end (ISO) when the run ended earlier than the call, e.g. an automatic run. */
+    endedAt?: string;
+}
+declare class TraceHandle {
+    readonly client: Tracehatch;
+    private readonly internal;
+    readonly id: `run_${string}`;
+    readonly root: RecordingSpan;
+    private sampled;
+    private ended;
+    private ending;
+    private outputSet;
+    private inputSet;
+    private inferredInputSet;
+    private readonly activeSpans;
+    private readonly captures;
+    private readonly recordedToolCalls;
+    private expectedSpanCount;
+    private data;
+    private removeAbort?;
+    constructor(client: Tracehatch, name: string, options?: TraceOptions, internal?: InternalTraceOptions);
+    get isRecording(): boolean;
+    get isEnded(): boolean;
+    get hasOutput(): boolean;
+    /** True once a span other than the root was recorded. */
+    get hasChildren(): boolean;
+    registerSpan(span: RecordingSpan): void;
+    unregisterSpan(span: RecordingSpan): void;
+    /** Exact provider call identity lets explicit tool instrumentation take precedence. */
+    rememberToolCall(callId: string): void;
+    hasRecordedToolCall(callId: string): boolean;
+    /** A provider response still being read from its clone; `end()` waits for it. */
+    track(capture: Promise<unknown>): void;
+    private settle;
+    private sanitize;
+    snapshot(): TraceEnvelopeWire;
+    run<T>(fn: (handle: TraceHandle) => T): T;
+    setInput(value: unknown): void;
+    setOutput(value: unknown): void;
+    /** Capture internals only: explicit application values always take precedence. */
+    captureProviderInput(value: unknown): void;
+    captureProviderOutput(value: unknown): void;
+    setUser(user: User): void;
+    setSession(id: string): void;
+    addTags(...tags: string[]): void;
+    setMetadata(metadata: Record<string, unknown>): void;
+    /** Scores travel with subsequent completed spans, including the final root. */
+    score(options: ScoreOptions): void;
+    /**
+     * End the run. A provider response still being read (a stream the caller
+     * consumes after the run's callback returned, or a body parsed in parallel
+     * with the caller) delays the end until it finishes, bounded by
+     * `captureSettleMs`, so the generation is recorded instead of cancelled.
+     */
+    end(options?: EndTraceOptions): void;
+}
+declare function startTrace(name: string, options?: TraceOptions): TraceHandle;
+declare function trace<T>(name: string, fn: (handle: TraceHandle) => T, options?: TraceOptions): Promise<Awaited<T>>;
+declare function setUser(user: User): void;
+declare function setSession(id: string): void;
+declare function addTags(...tags: string[]): void;
+declare function setMetadata(metadata: Record<string, unknown>): void;
+declare function score(options: ScoreOptions): void;
+
+export { type Attributes, type FlushResult, type InitOptions, type Outcome, type RedactionOptions, type ScoreOptions, type SpanHandle, type SpanKind, type SpanOptions, type ToolOptions, TraceHandle, type TraceOptions, Tracehatch, type User, addTags, flush, flushWithResult, init, score, setMetadata, setSession, setUser, shutdown, span, startTrace, tool, trace };

package/dist/index.d.ts

@@ -0,0 +1,243 @@
+type Attributes = { [x: string]: string | number | boolean | string[]; }
+
+type SpanWire = { id: string; trace_id: string; name: string; kind: "agent" | "generation" | "tool" | "retrieval" | "embedding" | "guardrail" | "custom"; status: "error" | "ok" | "cancelled"; started_at: string; ended_at: string; attempt: number; parent_id?: string | null | undefined; error?: { type?: string | undefined; message?: string | undefined; stack?: string | undefined; } | undefined; attributes?: Record<string, string | number | boolean | string[]> | undefined; input?: unknown; output?: unknown; messages?: unknown; events?: { ts: string; level: "debug" | "info" | "warn" | "error"; name: string; attributes?: Record<string, string | number | boolean | string[]> | undefined; }[] | undefined; input_bytes?: number | undefined; output_bytes?: number | undefined; messages_bytes?: number | undefined; input_truncated?: boolean | undefined; output_truncated?: boolean | undefined; messages_truncated?: boolean | undefined; }
+
+type TraceEnvelopeWire = { id: string; name: string; status: "error" | "ok" | "cancelled" | "pending"; started_at: string; agent?: string | undefined; session_id?: string | undefined; user?: { id: string; name?: string | undefined; email?: string | undefined; } | undefined; release?: string | undefined; tags?: string[] | undefined; metadata?: Record<string, unknown> | undefined; ended_at?: string | undefined; root_span_id?: string | undefined; expected_span_count?: number | undefined; input?: unknown; output?: unknown; scores?: { id: string; name: string; value: string | number; comment?: string | undefined; span_id?: string | undefined; }[] | undefined; }
+
+type SpanEventLevel = "debug" | "info" | "warn" | "error"
+
+/** What a span did (`spans.kind`, scope 02). */
+declare const SPAN_KIND: readonly ["agent", "generation", "tool", "retrieval", "embedding", "guardrail", "custom"];
+type SpanKind = (typeof SPAN_KIND)[number];
+
+/** Platform-neutral redaction, also bundled into the SDK. */
+interface RedactionOptions {
+    /** Built-in detectors and credential-key filtering are enabled by default. */
+    builtIns?: boolean;
+    /** Additional expressions are applied globally without mutating their lastIndex. */
+    rules?: readonly {
+        name: string;
+        pattern: RegExp;
+    }[];
+}
+
+type User = NonNullable<TraceEnvelopeWire["user"]>;
+type Outcome = "ok" | "error" | "cancelled";
+/** Delivery counters cover this client lifetime; acceptance is not persistence. */
+interface FlushResult {
+    status: "disabled" | "empty" | "accepted" | "timeout" | "failed";
+    acceptedSpans: number;
+    droppedSpans: number;
+    pendingSpans: number;
+    /** A safe SDK/API code, never request details or arbitrary server text. */
+    lastError?: {
+        code: string;
+        httpStatus?: number;
+    };
+}
+interface ScoreOptions {
+    name: string;
+    value: number | string;
+    comment?: string;
+    /** Omit to score the trace; set an existing span handle's id to score that span. */
+    spanId?: string;
+}
+interface InitOptions {
+    apiKey?: string;
+    /** Trusted API origin or base; required with an API key, here or via TRACEHATCH_BASE_URL. */
+    baseUrl?: string;
+    release?: string;
+    agent?: string;
+    captureBodies?: boolean;
+    redact?: false | RedactionOptions;
+    sampling?: {
+        rate: number;
+    };
+    debug?: boolean;
+    flushOnExit?: boolean;
+}
+interface SpanOptions {
+    input?: unknown;
+    attributes?: Attributes;
+    signal?: AbortSignal;
+}
+interface TraceOptions {
+    agent?: string;
+    rootName?: string;
+    input?: unknown;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    user?: User;
+    signal?: AbortSignal;
+}
+interface SpanHandle {
+    readonly id: string;
+    setOutput(value: unknown): void;
+    setAttributes(attributes: Attributes): void;
+    addEvent(name: string, attributes?: Attributes, level?: SpanEventLevel): void;
+}
+interface ToolOptions extends SpanOptions {
+    /** Extra attempts after the initial call; 0 by default, at most 999. */
+    retries?: number;
+    backoffMs?: number;
+}
+interface EndOptions {
+    status?: Outcome;
+    output?: unknown;
+    error?: unknown;
+    /** Wall-clock end (ISO) for steps recorded after they happened. */
+    endedAt?: string;
+}
+
+interface ExporterStats {
+    queuedSpans: number;
+    queuedBytes: number;
+    inFlightBatches: number;
+    droppedSpans: number;
+}
+
+declare class Tracehatch {
+    readonly options: {
+        captureBodies: boolean;
+        redact: false | RedactionOptions;
+        release?: string;
+        agent?: string;
+    };
+    private exporter?;
+    private enabled;
+    private rate;
+    private onExit?;
+    private closing?;
+    constructor(options: InitOptions);
+    get isEnabled(): boolean;
+    samples(id: string): boolean;
+    enqueue(span: SpanWire, trace: TraceEnvelopeWire): void;
+    flush(timeoutMs?: number): Promise<void>;
+    /** Inspect delivery during setup without making ordinary flush() reject. */
+    flushWithResult(timeoutMs?: number): Promise<FlushResult>;
+    shutdown(): Promise<void>;
+    stats(): ExporterStats;
+}
+/**
+ * Configure once per process. With an API key, every provider call made
+ * through `fetch`, every inbound HTTP request with a model call, and every
+ * explicit `trace`/`span`/`tool` is recorded. Agent and release default to
+ * the package name and the deployment's commit.
+ */
+declare function init(options?: InitOptions): Tracehatch;
+declare function flush(timeoutMs?: number): Promise<void>;
+declare function flushWithResult(timeoutMs?: number): Promise<FlushResult>;
+declare function shutdown(): Promise<void>;
+
+/** Timing the SDK's own capture paths supply for steps that already happened. */
+interface InternalSpanOptions {
+    startedAt?: string;
+}
+declare class RecordingSpan implements SpanHandle {
+    readonly trace: TraceHandle | undefined;
+    readonly parent?: RecordingSpan | undefined;
+    readonly id: string;
+    private ended;
+    private outputSet;
+    private removeAbort?;
+    private data;
+    private readonly isTool;
+    private toolCallId?;
+    constructor(trace: TraceHandle | undefined, name: string, kind: SpanKind, options?: SpanOptions, parent?: RecordingSpan | undefined, rootId?: string, internal?: InternalSpanOptions);
+    get isRecording(): boolean;
+    get isEnded(): boolean;
+    get hasOutput(): boolean;
+    private sanitize;
+    run<T>(fn: () => T): T;
+    setInput(value: unknown): void;
+    setOutput(value: unknown): void;
+    /** Size-only stream capture must never retain the generated content. */
+    setOutputBytes(bytes: number): void;
+    /** A stream assembler can truncate before the generic body size limit. */
+    markOutputTruncated(): void;
+    setMessages(value: unknown): void;
+    setAttributes(attributes: Attributes): void;
+    addEvent(name: string, attributes?: Attributes, level?: SpanEventLevel): void;
+    setAttempt(attempt: number): void;
+    end(options?: EndOptions): void;
+}
+declare function span<T>(name: string, kind: SpanKind, fn: (handle: SpanHandle) => T, options?: SpanOptions): Promise<Awaited<T>>;
+declare function tool<T>(name: string, fn: (handle: SpanHandle) => T, options?: ToolOptions): Promise<Awaited<T>>;
+
+/** Behaviour only the SDK's own capture paths need. */
+interface InternalTraceOptions {
+    /** End without sending anything when no span other than the root was recorded. */
+    discardIfEmpty?: boolean;
+    /** Only SDK-created runs derive transcript content from their provider calls. */
+    inferProviderBodies?: boolean;
+}
+interface EndTraceOptions {
+    outcome?: Outcome;
+    output?: unknown;
+    error?: unknown;
+    /** Wall-clock end (ISO) when the run ended earlier than the call, e.g. an automatic run. */
+    endedAt?: string;
+}
+declare class TraceHandle {
+    readonly client: Tracehatch;
+    private readonly internal;
+    readonly id: `run_${string}`;
+    readonly root: RecordingSpan;
+    private sampled;
+    private ended;
+    private ending;
+    private outputSet;
+    private inputSet;
+    private inferredInputSet;
+    private readonly activeSpans;
+    private readonly captures;
+    private readonly recordedToolCalls;
+    private expectedSpanCount;
+    private data;
+    private removeAbort?;
+    constructor(client: Tracehatch, name: string, options?: TraceOptions, internal?: InternalTraceOptions);
+    get isRecording(): boolean;
+    get isEnded(): boolean;
+    get hasOutput(): boolean;
+    /** True once a span other than the root was recorded. */
+    get hasChildren(): boolean;
+    registerSpan(span: RecordingSpan): void;
+    unregisterSpan(span: RecordingSpan): void;
+    /** Exact provider call identity lets explicit tool instrumentation take precedence. */
+    rememberToolCall(callId: string): void;
+    hasRecordedToolCall(callId: string): boolean;
+    /** A provider response still being read from its clone; `end()` waits for it. */
+    track(capture: Promise<unknown>): void;
+    private settle;
+    private sanitize;
+    snapshot(): TraceEnvelopeWire;
+    run<T>(fn: (handle: TraceHandle) => T): T;
+    setInput(value: unknown): void;
+    setOutput(value: unknown): void;
+    /** Capture internals only: explicit application values always take precedence. */
+    captureProviderInput(value: unknown): void;
+    captureProviderOutput(value: unknown): void;
+    setUser(user: User): void;
+    setSession(id: string): void;
+    addTags(...tags: string[]): void;
+    setMetadata(metadata: Record<string, unknown>): void;
+    /** Scores travel with subsequent completed spans, including the final root. */
+    score(options: ScoreOptions): void;
+    /**
+     * End the run. A provider response still being read (a stream the caller
+     * consumes after the run's callback returned, or a body parsed in parallel
+     * with the caller) delays the end until it finishes, bounded by
+     * `captureSettleMs`, so the generation is recorded instead of cancelled.
+     */
+    end(options?: EndTraceOptions): void;
+}
+declare function startTrace(name: string, options?: TraceOptions): TraceHandle;
+declare function trace<T>(name: string, fn: (handle: TraceHandle) => T, options?: TraceOptions): Promise<Awaited<T>>;
+declare function setUser(user: User): void;
+declare function setSession(id: string): void;
+declare function addTags(...tags: string[]): void;
+declare function setMetadata(metadata: Record<string, unknown>): void;
+declare function score(options: ScoreOptions): void;
+
+export { type Attributes, type FlushResult, type InitOptions, type Outcome, type RedactionOptions, type ScoreOptions, type SpanHandle, type SpanKind, type SpanOptions, type ToolOptions, TraceHandle, type TraceOptions, Tracehatch, type User, addTags, flush, flushWithResult, init, score, setMetadata, setSession, setUser, shutdown, span, startTrace, tool, trace };

package/dist/index.js

@@ -0,0 +1,2 @@
+export{b as TraceHandle,l as Tracehatch,g as addTags,n as flush,o as flushWithResult,m as init,i as score,h as setMetadata,f as setSession,e as setUser,p as shutdown,j as span,c as startTrace,k as tool,d as trace}from'./chunk-KHVJY566.js';//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@tracehatch/sdk",
+  "version": "0.3.0",
+  "description": "Record AI agent runs, model calls, sessions and tools in Node.js with one import.",
+  "license": "MIT",
+  "homepage": "https://tracehatch.com",
+  "keywords": [
+    "ai",
+    "observability",
+    "tracing",
+    "agents",
+    "llm",
+    "openai",
+    "anthropic",
+    "sessions"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/salmandotweb/unravel.git",
+    "directory": "packages/sdk"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "sideEffects": [
+    "./dist/auto.js",
+    "./dist/auto.cjs"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./auto": {
+      "import": {
+        "types": "./dist/auto.d.ts",
+        "default": "./dist/auto.js"
+      },
+      "require": {
+        "types": "./dist/auto.d.cts",
+        "default": "./dist/auto.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "GUIDE.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "tracehatch": {
+    "minApi": "1"
+  }
+}