@agent-watch-ai/otel 0.0.0-stage → 0.1.0

package/dist/post.js

@@ -0,0 +1,149 @@
+import http from 'node:http';
+import https from 'node:https';
+import { ROOT_CONTEXT, context, createContextKey } from '@opentelemetry/api';
+/**
+ * The one way this package talks to Agent Watch: a JSON POST over `node:http`, shared by the
+ * processor's ingest batches and the gate's decision requests.
+ *
+ * - `node:http` rather than `fetch`: never through the gate's own `fetch` wrapper.
+ * - Its own keep-alive agent, so the sockets this package unrefs are never ones the application
+ *   shares, and a request does not pay a handshake every time.
+ * - Sent under a context with tracing suppressed: the customer's HTTP instrumentation neither
+ *   traces it nor injects trace headers into it.
+ * - Its socket is unref'd, so it never holds the process open, unless someone is waiting on the
+ *   answer: the request's caller (`holdProcess`), or a caller of `heldWhile` such as an awaited
+ *   forceFlush(). Then it is ref'd until the request settles or the wait ends.
+ * - Only https, or plain http to loopback: the bearer token never crosses a network in clear.
+ */
+const TRAILING_SLASHES = /\/+$/;
+const LOOPBACK_HOSTS = new Set(['localhost', '[::1]']);
+// The key @opentelemetry/core's suppressTracing() sets, without depending on core.
+const SUPPRESS_TRACING_KEY = createContextKey('OpenTelemetry SDK Context Key SUPPRESS_TRACING');
+// A context with tracing suppressed, for every request this package sends.
+const SUPPRESSED = ROOT_CONTEXT.setValue(SUPPRESS_TRACING_KEY, true);
+/** A 2xx body longer than `maxBytes`. */
+export class BodyTooLarge extends Error {
+}
+/** One Agent Watch route, with the token and the agent its requests use. */
+export class Endpoint {
+    token;
+    url;
+    agent;
+    // Sockets of requests on the wire, each with whether its own caller holds the process for it.
+    sockets = new Map();
+    held = 0;
+    /**
+     * Join the route onto the base URL and give it its own agent.
+     * @throws {Error} Plain http to anything but loopback.
+     * @param token SDK token, sent as a bearer token.
+     * @param base Ingest base URL.
+     * @param path The route, joined onto `base`.
+     */
+    constructor(token, base, path) {
+        this.token = token;
+        this.url = new URL(path, `${base.replace(TRAILING_SLASHES, '')}/`);
+        if (this.url.protocol !== 'https:' && !(this.url.protocol === 'http:' && isLoopback(this.url.hostname))) {
+            throw new Error('AgentWatchSpanProcessor needs an https endpoint; plain http is accepted only on loopback, so the token never crosses a network in clear');
+        }
+        this.agent = this.url.protocol === 'https:' ? new https.Agent({ keepAlive: true }) : new http.Agent({ keepAlive: true });
+    }
+    /**
+     * POST `body` as JSON. Resolves with any status, a redirect included (never followed: it would
+     * carry the token elsewhere); rejects on a network error, an abort or an oversized body.
+     * @param body The JSON text.
+     * @param options See `PostOptions`.
+     * @returns The status, and the body when `maxBytes` asked for it and the status is 2xx.
+     */
+    postJson(body, options = {}) {
+        const { signal, maxBytes = 0, holdProcess = false } = options;
+        const holding = () => holdProcess === true || (holdProcess !== false && !holdProcess.aborted);
+        return context.with(SUPPRESSED, () => new Promise((resolve, reject) => {
+            let socket = null;
+            const settle = (done) => {
+                if (socket !== null) {
+                    this.sockets.delete(socket);
+                    socket.unref();
+                }
+                done();
+            };
+            const client = this.url.protocol === 'https:' ? https : http;
+            const outgoing = client.request(this.url, {
+                method: 'POST',
+                agent: this.agent,
+                signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                    Authorization: `Bearer ${this.token}`,
+                    'User-Agent': 'agent-watch-otel'
+                }
+            }, (response) => {
+                const status = response.statusCode ?? 0;
+                const chunks = [];
+                let size = 0;
+                // A reset mid-body errors the response, and an 'error' with no listener would crash the host.
+                response.on('error', (error) => settle(() => reject(error)));
+                if (maxBytes === 0 || status < 200 || status > 299) {
+                    response.resume();
+                    settle(() => resolve({ status, text: '' }));
+                    return;
+                }
+                response.on('data', (chunk) => {
+                    size += chunk.length;
+                    if (size > maxBytes) {
+                        response.destroy();
+                        settle(() => reject(new BodyTooLarge()));
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                response.on('end', () => settle(() => resolve({ status, text: Buffer.concat(chunks).toString('utf8') })));
+            });
+            outgoing.on('socket', (assigned) => {
+                socket = assigned;
+                this.sockets.set(assigned, holding());
+                assigned[holding() || this.held > 0 ? 'ref' : 'unref']();
+            });
+            outgoing.on('error', (error) => settle(() => reject(error)));
+            if (holdProcess instanceof AbortSignal) {
+                holdProcess.addEventListener('abort', () => {
+                    if (socket !== null && this.sockets.has(socket)) {
+                        this.sockets.set(socket, false);
+                        if (this.held === 0) {
+                            socket.unref();
+                        }
+                    }
+                }, { once: true });
+            }
+            outgoing.end(body);
+        }));
+    }
+    /**
+     * Keep the process alive for this endpoint's requests while `work` runs: awaiting a promise
+     * does not keep Node's loop alive, so a short job awaiting delivery would otherwise exit first.
+     * Bounded by whatever bounds `work`.
+     * @param work What the caller awaits.
+     * @returns `work`'s result.
+     */
+    async heldWhile(work) {
+        this.held += 1;
+        this.sockets.forEach((_own, socket) => socket.ref());
+        try {
+            return await work();
+        }
+        finally {
+            this.held -= 1;
+            if (this.held === 0) {
+                this.sockets.forEach((own, socket) => own || socket.unref());
+            }
+        }
+    }
+    /** Release the sockets. */
+    destroy() {
+        this.agent.destroy();
+    }
+}
+// localhost, ::1 or anything in 127.0.0.0/8.
+function isLoopback(hostname) {
+    return LOOPBACK_HOSTS.has(hostname) || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname);
+}

package/dist/processor.d.ts

@@ -0,0 +1,103 @@
+import { type Context } from '@opentelemetry/api';
+import type { ReadableSpan, Span, SpanProcessor } from '@opentelemetry/sdk-trace-base';
+/**
+ * The one line a customer adds, and everything it must never do. A port of
+ * `python/agent-watch-otel/agent_watch_otel/processor.py`.
+ *
+ * `onEnd` runs inside the customer's `span.end()`, so:
+ * 1. It never touches the network. It hashes and enqueues; sending happens on a timer or an
+ *    immediate, never on the caller's stack. A full queue drops and counts.
+ * 2. It never throws, and nothing it starts ever rejects unhandled: an unhandled rejection is a
+ *    crash in Node, which is the one failure this package must not cause.
+ * 3. What is queued is already digests; no prompt text outlives `onEnd`'s frame.
+ * 4. Its own request is invisible to the customer's instrumentation, and never holds the
+ *    process open.
+ */
+/**
+ * Calls per request. The contract allows 250 (AWT-70's `RUNTIME_BATCH_MAX_CALLS`), but a call
+ * carries up to 512 shingle digests, about 18 KB of JSON, so 250 would be a 4.5 MB body; 100
+ * keeps one request under 2 MB.
+ */
+export declare const BATCH_MAX_CALLS = 100;
+/** Construction options. Every one is optional; token and endpoint fall back to the environment. */
+export interface AgentWatchSpanProcessorOptions {
+    /** SDK token scoped `ingest:production`. Defaults to `AGENT_WATCH_TOKEN`. */
+    readonly token?: string;
+    /** Ingest base URL. Defaults to `AGENT_WATCH_ENDPOINT`. */
+    readonly endpoint?: string;
+    /** This deployment's name. Defaults to the resource's `service.name`. */
+    readonly instanceId?: string;
+    /** Calls held while the sender is behind; past it, calls are dropped and counted. A positive integer. */
+    readonly maxQueue?: number;
+    /** How long a partial batch waits. Over 0 and at most 2^31-1. */
+    readonly flushMillis?: number;
+    /** Network timeout for one POST. */
+    readonly timeoutMillis?: number;
+    /** The whole budget `shutdown()` may spend, however many times it is called. */
+    readonly shutdownMillis?: number;
+}
+/** Delivered and dropped counts, each drop under its own reason. */
+export interface ProcessorStats {
+    readonly sent: number;
+    readonly droppedQueueFull: number;
+    readonly droppedSendFailed: number;
+    readonly droppedNoModel: number;
+    readonly droppedError: number;
+}
+/** Reports finished OpenInference `LLM` spans to Agent Watch as digests, beside the customer's own processors. */
+export declare class AgentWatchSpanProcessor implements SpanProcessor {
+    private readonly ingest;
+    private readonly instanceId;
+    private readonly maxQueue;
+    private readonly timeoutMillis;
+    private readonly shutdownMillis;
+    private readonly counters;
+    private readonly timer;
+    private readonly inFlight;
+    private readonly gate;
+    private queue;
+    private draining;
+    private abandoned;
+    private stopping;
+    /**
+     * Validate configuration and start the flush timer.
+     * @param options Token, endpoint and tuning; see `AgentWatchSpanProcessorOptions`.
+     * @throws {Error} No token, no endpoint, or an endpoint the token may not be sent to in clear
+     *   (plain http to anything but loopback). Raised here, on the application's startup path where
+     *   an operator sees it, and never later from `onEnd`.
+     */
+    constructor(options?: AgentWatchSpanProcessorOptions);
+    /**
+     * Delivered and dropped counts.
+     * @returns A snapshot copy.
+     */
+    stats(): ProcessorStats;
+    /**
+     * Nothing: a call is only reportable once it has its token counts.
+     * @param _span The started span.
+     * @param _parentContext Its parent context.
+     */
+    onStart(_span: Span, _parentContext: Context): void;
+    /**
+     * Hash a finished LLM span and queue it for the sender.
+     * @param span The span the SDK has just ended. Anything that is not an OpenInference `LLM` span is ignored.
+     */
+    onEnd(span: ReadableSpan): void;
+    /**
+     * Send everything queued. Resolves when the queue is empty; never rejects.
+     * @returns When every queued call has been sent or dropped.
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * Stop reading spans and give the sender a bounded moment to drain. Bounded and spent once: a
+     * second call returns the first call's promise. Whatever is still in flight when the budget runs
+     * out is aborted, so a hung socket cannot hold the process open either.
+     * @returns When the queue drained or the budget ran out, whichever came first.
+     */
+    shutdown(): Promise<void>;
+    private stop;
+    private drain;
+    private sendAll;
+    private send;
+    private count;
+}

package/dist/processor.js

@@ -0,0 +1,220 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import { diag } from '@opentelemetry/api';
+import { buildCall, isLlmSpan } from './call.js';
+import { RuntimeGate, installGate, uninstallGate } from './gate.js';
+import { Endpoint } from './post.js';
+/**
+ * The one line a customer adds, and everything it must never do. A port of
+ * `python/agent-watch-otel/agent_watch_otel/processor.py`.
+ *
+ * `onEnd` runs inside the customer's `span.end()`, so:
+ * 1. It never touches the network. It hashes and enqueues; sending happens on a timer or an
+ *    immediate, never on the caller's stack. A full queue drops and counts.
+ * 2. It never throws, and nothing it starts ever rejects unhandled: an unhandled rejection is a
+ *    crash in Node, which is the one failure this package must not cause.
+ * 3. What is queued is already digests; no prompt text outlives `onEnd`'s frame.
+ * 4. Its own request is invisible to the customer's instrumentation, and never holds the
+ *    process open.
+ */
+/**
+ * Calls per request. The contract allows 250 (AWT-70's `RUNTIME_BATCH_MAX_CALLS`), but a call
+ * carries up to 512 shingle digests, about 18 KB of JSON, so 250 would be a 4.5 MB body; 100
+ * keeps one request under 2 MB.
+ */
+export const BATCH_MAX_CALLS = 100;
+const CALLS_PATH = 'v1/runtime/calls';
+// The worst case is every queued call carrying 512 shingles: about 18 KB of JSON each, so
+// roughly 9 MB of payload (a little more as JS strings) held in the customer's heap.
+const DEFAULT_MAX_QUEUE = 512;
+const DEFAULT_FLUSH_MILLIS = 5000;
+// setInterval and setTimeout clamp anything above this to 1 ms, which would turn a typo into a busy loop.
+const MAX_TIMER_MILLIS = 2 ** 31 - 1;
+const DEFAULT_TIMEOUT_MILLIS = 10_000;
+// Shorter than the request timeout: an endpoint that accepts and never answers must not turn a
+// tidy stop into a SIGKILL at the end of the grace period.
+const DEFAULT_SHUTDOWN_MILLIS = 3000;
+/** Reports finished OpenInference `LLM` spans to Agent Watch as digests, beside the customer's own processors. */
+export class AgentWatchSpanProcessor {
+    ingest;
+    instanceId;
+    maxQueue;
+    timeoutMillis;
+    shutdownMillis;
+    counters = {
+        sent: 0, droppedQueueFull: 0, droppedSendFailed: 0, droppedNoModel: 0, droppedError: 0
+    };
+    timer;
+    inFlight = new Set();
+    gate;
+    queue = [];
+    draining = null;
+    abandoned = false;
+    stopping = null;
+    /**
+     * Validate configuration and start the flush timer.
+     * @param options Token, endpoint and tuning; see `AgentWatchSpanProcessorOptions`.
+     * @throws {Error} No token, no endpoint, or an endpoint the token may not be sent to in clear
+     *   (plain http to anything but loopback). Raised here, on the application's startup path where
+     *   an operator sees it, and never later from `onEnd`.
+     */
+    constructor(options = {}) {
+        const token = (options.token || process.env.AGENT_WATCH_TOKEN || '').trim();
+        const endpoint = (options.endpoint || process.env.AGENT_WATCH_ENDPOINT || '').trim();
+        if (token === '') {
+            throw new Error('AgentWatchSpanProcessor needs a token, or AGENT_WATCH_TOKEN in the environment');
+        }
+        if (endpoint === '') {
+            throw new Error('AgentWatchSpanProcessor needs an endpoint, or AGENT_WATCH_ENDPOINT in the environment');
+        }
+        this.ingest = new Endpoint(token, endpoint, CALLS_PATH);
+        this.instanceId = options.instanceId ?? '';
+        // A bad number falls back to its default rather than throwing: only a missing token or
+        // endpoint is worth refusing to start the customer's application over.
+        this.maxQueue = typeof options.maxQueue === 'number' && Number.isSafeInteger(options.maxQueue) && options.maxQueue > 0 ? options.maxQueue : DEFAULT_MAX_QUEUE;
+        this.timeoutMillis = timerMillis(options.timeoutMillis, DEFAULT_TIMEOUT_MILLIS);
+        this.shutdownMillis = timerMillis(options.shutdownMillis, DEFAULT_SHUTDOWN_MILLIS);
+        // Unref'd: this timer must never be what keeps the customer's process alive.
+        this.timer = setInterval(() => {
+            void this.drain();
+        }, timerMillis(options.flushMillis, DEFAULT_FLUSH_MILLIS)).unref();
+        // The gate (AWT-339): from here on, a request made inside an LLM span asks first.
+        this.gate = new RuntimeGate(token, endpoint);
+        installGate(this.gate);
+    }
+    /**
+     * Delivered and dropped counts.
+     * @returns A snapshot copy.
+     */
+    stats() {
+        return { ...this.counters };
+    }
+    /**
+     * Nothing: a call is only reportable once it has its token counts.
+     * @param _span The started span.
+     * @param _parentContext Its parent context.
+     */
+    onStart(_span, _parentContext) {
+        // Intentionally empty.
+    }
+    /**
+     * Hash a finished LLM span and queue it for the sender.
+     * @param span The span the SDK has just ended. Anything that is not an OpenInference `LLM` span is ignored.
+     */
+    onEnd(span) {
+        try {
+            if (this.stopping !== null || !isLlmSpan(span)) {
+                return;
+            }
+            const call = buildCall(span, this.instanceId);
+            if (call === null) {
+                this.count('droppedNoModel');
+                return;
+            }
+            if (this.queue.length >= this.maxQueue) {
+                this.count('droppedQueueFull');
+                return;
+            }
+            this.queue.push(call);
+            if (this.queue.length === BATCH_MAX_CALLS) {
+                // Off the span's stack. drain() is single-flight, so a second immediate is harmless.
+                setImmediate(() => void this.drain()).unref();
+            }
+        }
+        catch {
+            // Counted, not only logged: the stats account for every call read and never delivered.
+            this.count('droppedError');
+            diag.debug('agent-watch: span dropped');
+        }
+    }
+    /**
+     * Send everything queued. Resolves when the queue is empty; never rejects.
+     * @returns When every queued call has been sent or dropped.
+     */
+    forceFlush() {
+        return this.ingest.heldWhile(() => this.drain());
+    }
+    /**
+     * Stop reading spans and give the sender a bounded moment to drain. Bounded and spent once: a
+     * second call returns the first call's promise. Whatever is still in flight when the budget runs
+     * out is aborted, so a hung socket cannot hold the process open either.
+     * @returns When the queue drained or the budget ran out, whichever came first.
+     */
+    shutdown() {
+        this.stopping ??= this.ingest.heldWhile(() => this.stop());
+        return this.stopping;
+    }
+    async stop() {
+        clearInterval(this.timer);
+        uninstallGate(this.gate);
+        this.gate.close();
+        const budget = new AbortController();
+        // Ref'd: a caller awaits this, and the budget bounds it.
+        await Promise.race([this.drain(), sleep(this.shutdownMillis, undefined, { signal: budget.signal })]).catch(() => undefined);
+        budget.abort();
+        this.abandoned = true;
+        this.count('droppedSendFailed', this.queue.length);
+        this.queue = [];
+        for (const request of this.inFlight) {
+            request.abort();
+        }
+        this.ingest.destroy();
+    }
+    // Single flight: one batch on the wire at a time, as Python's single sender thread.
+    drain() {
+        // sendAll() catches per batch; this only stops a rejection from going unhandled.
+        this.draining ??= this.sendAll()
+            .catch(() => undefined)
+            .finally(() => {
+            this.draining = null;
+        });
+        return this.draining;
+    }
+    async sendAll() {
+        while (this.queue.length > 0 && !this.abandoned) {
+            const batch = this.queue.splice(0, BATCH_MAX_CALLS);
+            try {
+                await this.send(batch);
+            }
+            catch {
+                // `send` counts its own failures; reaching here means something else threw, after the
+                // batch left the queue. Counted as Python's sender counts it, then the next batch goes.
+                this.count('droppedSendFailed', batch.length);
+                diag.warn(`agent-watch: ${String(batch.length)} calls dropped, sender error`);
+            }
+        }
+    }
+    // A failed batch is dropped, not retried: the queue is the only buffer, and a retry would hold
+    // newer calls behind an endpoint that may be down for hours.
+    async send(batch) {
+        const request = new AbortController();
+        const timeout = setTimeout(() => request.abort(), this.timeoutMillis).unref();
+        this.inFlight.add(request);
+        try {
+            // The body is never read: a 400 from a strict schema names the field it refused.
+            const { status } = await this.ingest.postJson(JSON.stringify({ calls: batch }), { signal: request.signal });
+            // Anything but 2xx, a redirect included: a redirect is a misconfigured endpoint, and
+            // following one would carry the token elsewhere.
+            if (status < 200 || status > 299) {
+                this.count('droppedSendFailed', batch.length);
+                diag.warn(`agent-watch: ${String(batch.length)} calls dropped, ingest answered ${String(status)}`);
+                return;
+            }
+            this.count('sent', batch.length);
+        }
+        catch {
+            this.count('droppedSendFailed', batch.length);
+            diag.warn(`agent-watch: ${String(batch.length)} calls dropped, ingest unreachable`);
+        }
+        finally {
+            clearTimeout(timeout);
+            this.inFlight.delete(request);
+        }
+    }
+    count(name, amount = 1) {
+        this.counters[name] += amount;
+    }
+}
+// A timer delay in (0, 2^31-1], or the default.
+function timerMillis(value, fallback) {
+    return typeof value === 'number' && value > 0 && value <= MAX_TIMER_MILLIS ? value : fallback;
+}

package/dist/refusal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The one error the runtime gate raises, and the test for it.
+ *
+ * It says nothing but the fixed sentence: no cap, amount, feature or policy reaches the process
+ * (FR-016). A provider SDK that wraps transport errors surfaces it as the `cause` of its own
+ * connection error, so the test walks the `cause` chain. Identified by a registered symbol rather
+ * than `instanceof`, so a second copy of this package in the dependency tree still recognises it.
+ */
+declare const BRAND: unique symbol;
+/** The whole of what a refusal says. */
+export declare const REFUSAL_MESSAGE = "An Agent Watch budget refused this call.";
+/** Raised instead of sending a model call that an Agent Watch budget refuses. Never retryable. */
+export declare class AgentWatchRefusal extends Error {
+    /** A retry gets the same answer, from the held decision, without asking Agent Watch again. */
+    readonly retryable = false;
+    readonly [BRAND] = true;
+    /** The fixed sentence, and nothing else. */
+    constructor();
+}
+/**
+ * Whether an error is an Agent Watch refusal, or was caused by one.
+ * @param error Anything caught.
+ * @returns `true` when it or any error in its `cause` chain is an `AgentWatchRefusal`.
+ */
+export declare function isAgentWatchRefusal(error: unknown): boolean;
+export {};

package/dist/refusal.js

@@ -0,0 +1,39 @@
+/**
+ * The one error the runtime gate raises, and the test for it.
+ *
+ * It says nothing but the fixed sentence: no cap, amount, feature or policy reaches the process
+ * (FR-016). A provider SDK that wraps transport errors surfaces it as the `cause` of its own
+ * connection error, so the test walks the `cause` chain. Identified by a registered symbol rather
+ * than `instanceof`, so a second copy of this package in the dependency tree still recognises it.
+ */
+const BRAND = Symbol.for('agent-watch.otel.refusal');
+// Far deeper than any SDK nests; bounds a cycle of causes.
+const MAX_CAUSE_DEPTH = 16;
+/** The whole of what a refusal says. */
+export const REFUSAL_MESSAGE = 'An Agent Watch budget refused this call.';
+/** Raised instead of sending a model call that an Agent Watch budget refuses. Never retryable. */
+export class AgentWatchRefusal extends Error {
+    /** A retry gets the same answer, from the held decision, without asking Agent Watch again. */
+    retryable = false;
+    [BRAND] = true;
+    /** The fixed sentence, and nothing else. */
+    constructor() {
+        super(REFUSAL_MESSAGE);
+        this.name = 'AgentWatchRefusal';
+    }
+}
+/**
+ * Whether an error is an Agent Watch refusal, or was caused by one.
+ * @param error Anything caught.
+ * @returns `true` when it or any error in its `cause` chain is an `AgentWatchRefusal`.
+ */
+export function isAgentWatchRefusal(error) {
+    let current = error;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH && typeof current === 'object' && current !== null; depth++) {
+        if (current[BRAND] === true) {
+            return true;
+        }
+        current = current.cause;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@agent-watch-ai/otel",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Agent Watch's OpenTelemetry span processor: production LLM spend as digests, never prompt text.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Agent-Watch-AI/agent-watch-edge.git",
+    "directory": "node/agent-watch-otel"
+  },
+  "type": "module",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src tests",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/sdk-trace-base": "^1.0.0 || ^2.0.0"
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/core": "^2.12.0",
+    "@opentelemetry/resources": "^2.12.0",
+    "@opentelemetry/sdk-trace-base": "^2.12.0"
+  }
+}