@theoremjs/agents 0.0.0-stage → 0.3.0

package/esm/src/kernel/types.js

@@ -0,0 +1 @@
+export {};

package/esm/src/kernel/util/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function base64ToBytes(data: string): Uint8Array<ArrayBuffer>;
+export declare function bytesToBase64(bytes: Uint8Array): string;

package/esm/src/kernel/util/base64.js

@@ -0,0 +1,13 @@
+export function base64ToBytes(data) {
+    const bin = atob(data);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        out[i] = bin.charCodeAt(i);
+    return out;
+}
+export function bytesToBase64(bytes) {
+    let bin = '';
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    return btoa(bin);
+}

package/esm/src/kernel/util/exact-type.d.ts

@@ -0,0 +1,31 @@
+export type Probe<X> = <T>() => T extends X ? 1 : 2;
+export type OptionalKeys<T> = {
+    [K in keyof T]-?: Record<never, never> extends Pick<T, K> ? K : never;
+}[keyof T];
+export type MarkedOnce<T> = T extends object ? {
+    [K in keyof T]-?: K extends OptionalKeys<T> ? {
+        optional: T[K];
+    } : T[K];
+} : T;
+/**
+ * Boxed in `Seen` so a union stays one entry. `T`'s own optional fields are marked first,
+ * or a type would pass for one it merely nests in.
+ */
+export type IsSeen<T, Seen> = true extends (Seen extends [infer S] ? Probe<MarkedOnce<S>> extends Probe<MarkedOnce<T>> ? true : false : never) ? true : false;
+/**
+ * The identity check behind `Probe` ignores optionality, so a field only one side leaves out
+ * would pass unmarked. A recursive type is compared as it is where it recurs.
+ */
+export type Marked<T, Seen = never> = IsSeen<T, Seen> extends true ? T : MarkedEach<T, Seen | [T]>;
+export type MarkedEach<T, Seen> = T extends (...args: never[]) => unknown ? T : T extends readonly unknown[] ? {
+    [I in keyof T]: Marked<T[I], Seen>;
+} : T extends object ? {
+    [K in keyof T]-?: K extends OptionalKeys<T> ? {
+        optional: Marked<T[K], Seen>;
+    } : Marked<T[K], Seen>;
+} : T;
+/**
+ * JSR's `no-slow-types` forbids publishing inferred types, so a hand-written type is checked
+ * against its schema: `true satisfies Equals<z.infer<typeof turnStop>, TurnStop>;`.
+ */
+export type Equals<A, B> = Probe<Marked<A>> extends Probe<Marked<B>> ? true : false;

package/esm/src/kernel/util/exact-type.js

@@ -0,0 +1 @@
+export {};

package/esm/src/kernel/util/find-last.d.ts

@@ -0,0 +1,3 @@
+/** `Array.prototype.findLast` is ES2023; this stays ES2022-safe. */
+export declare function findLast<T, S extends T>(items: readonly T[], predicate: (item: T) => item is S): S | undefined;
+export declare function findLast<T>(items: readonly T[], predicate: (item: T) => boolean): T | undefined;

package/esm/src/kernel/util/find-last.js

@@ -0,0 +1,9 @@
+export function findLast(items, predicate) {
+    for (let i = items.length - 1; i >= 0; i -= 1) {
+        const item = items[i];
+        if (item !== undefined && predicate(item)) {
+            return item;
+        }
+    }
+    return undefined;
+}

package/esm/src/kernel/util/mime.d.ts

@@ -0,0 +1,2 @@
+/** Lower-case `type/subtype`, parameters removed. */
+export declare function mimeEssence(mime: string): string;

package/esm/src/kernel/util/mime.js

@@ -0,0 +1,4 @@
+/** Lower-case `type/subtype`, parameters removed. */
+export function mimeEssence(mime) {
+    return (mime.split(';')[0] ?? '').trim().toLowerCase();
+}

package/esm/src/kernel/util/record.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/esm/src/kernel/util/record.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/esm/src/observability/destinations.d.ts

@@ -0,0 +1,9 @@
+import type { TraceSink } from './trace-sink.js';
+declare function isTraceSink(value: unknown): value is TraceSink;
+declare function registerTraceDestination(id: string, destination: TraceSink): void;
+declare function getTraceDestination(id: string): TraceSink | undefined;
+declare function requireTraceDestination(id: string): TraceSink;
+declare function listTraceDestinationIds(): string[];
+/** For tests. */
+declare function clearTraceDestinations(): void;
+export { clearTraceDestinations, getTraceDestination, isTraceSink, listTraceDestinationIds, registerTraceDestination, requireTraceDestination, };

package/esm/src/observability/destinations.js

@@ -0,0 +1,38 @@
+// THEOREM does not invent filesystem roots: hosts register a named destination once per process.
+import { TheoremError } from '../guardrails/error.js';
+const destinations = new Map();
+function isTraceSink(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'write' in value &&
+        typeof value.write === 'function');
+}
+function registerTraceDestination(id, destination) {
+    const key = id.trim();
+    if (!key) {
+        throw new TheoremError('config', 'registerTraceDestination requires a non-empty id');
+    }
+    // Hosts may call from plain JS: the registry holds only writers.
+    if (!isTraceSink(destination)) {
+        throw new TheoremError('config', `Trace destination '${key}' must be a TraceSink`);
+    }
+    destinations.set(key, destination);
+}
+function getTraceDestination(id) {
+    return destinations.get(id);
+}
+function requireTraceDestination(id) {
+    const found = getTraceDestination(id);
+    if (!found) {
+        throw new TheoremError('config', `Trace destination '${id}' is not registered`);
+    }
+    return found;
+}
+function listTraceDestinationIds() {
+    return [...destinations.keys()].sort();
+}
+/** For tests. */
+function clearTraceDestinations() {
+    destinations.clear();
+}
+export { clearTraceDestinations, getTraceDestination, isTraceSink, listTraceDestinationIds, registerTraceDestination, requireTraceDestination, };

package/esm/src/observability/jsonl.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The file trace sink: daily rotating JSONL under a host-chosen directory. Its own entry point, so
+ * browser bundles and Workers never pull the filesystem into their module graph.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import type { TraceSink } from './trace-sink.js';
+/** Retention and rotation are not here: they arrive with each write (`TraceWriteContext`) from the profile. */
+export interface JsonlSinkOptions {
+    now?: () => number;
+}
+/**
+ * Daily rotating JSONL files under an absolute, host-chosen `dir`. Each write removes day files
+ * older than the record's retention (`<= 0` keeps every file) and starts a new file once the
+ * day's reaches the profile's `rotateAfterMiB`.
+ */
+export declare function jsonlSink(dir: string, options?: JsonlSinkOptions): TraceSink;

package/esm/src/observability/jsonl.js

@@ -0,0 +1,117 @@
+/**
+ * The file trace sink: daily rotating JSONL under a host-chosen directory. Its own entry point, so
+ * browser bundles and Workers never pull the filesystem into their module graph.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import { appendFile, mkdir, readdir, rm, stat } from 'node:fs/promises';
+import { cwd } from 'node:process';
+import { TheoremError } from '../guardrails/error.js';
+import { isRecord } from '../kernel/util/record.js';
+const HOURS_PER_DAY = 24;
+const MIN_PER_HOUR = 60;
+const SEC_PER_MIN = 60;
+const MS_PER_SEC = 1000;
+const KIB = 1024;
+const OWNER_ONLY_DIR = 0o700;
+const OWNER_ONLY_FILE = 0o600;
+const MIB = KIB * KIB;
+const FILE_DAY = /^turns-(\d{4}-\d{2}-\d{2})(?:-\d+)?\.jsonl$/;
+function dayStamp(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+function fileDay(name) {
+    return FILE_DAY.exec(name)?.[1];
+}
+/** Remove day files older than `retainForDays`; `<= 0` keeps every file. */
+async function pruneTraces(dir, now, retainForDays) {
+    if (retainForDays <= 0) {
+        return;
+    }
+    const retainMs = retainForDays * HOURS_PER_DAY * MIN_PER_HOUR * SEC_PER_MIN * MS_PER_SEC;
+    const cutoff = now - retainMs;
+    for (const name of await readdir(dir)) {
+        const day = fileDay(name);
+        if (day && Date.parse(`${day}T00:00:00.000Z`) < cutoff) {
+            await rm(`${dir}/${name}`);
+        }
+    }
+}
+function isMissing(err) {
+    return isRecord(err) && err.code === 'ENOENT';
+}
+async function pickFile(dir, now, rotateBytes) {
+    const day = dayStamp(now);
+    const base = `${dir}/turns-${day}.jsonl`;
+    try {
+        if ((await stat(base)).size < rotateBytes) {
+            return base;
+        }
+    }
+    catch (err) {
+        if (isMissing(err)) {
+            return base;
+        }
+        throw err;
+    }
+    return `${dir}/turns-${day}-${now}.jsonl`;
+}
+/**
+ * Daily rotating JSONL files under an absolute, host-chosen `dir`. Each write removes day files
+ * older than the record's retention (`<= 0` keeps every file) and starts a new file once the
+ * day's reaches the profile's `rotateAfterMiB`.
+ */
+export function jsonlSink(dir, options = {}) {
+    const safeDir = validateTraceDir(dir);
+    const now = options.now ?? Date.now;
+    return {
+        write: async (record, context) => {
+            const at = now();
+            // Records hold conversation content: readable by the host's user only.
+            await mkdir(safeDir, { recursive: true, mode: OWNER_ONLY_DIR });
+            await pruneTraces(safeDir, at, context.retainForDays);
+            const path = await pickFile(safeDir, at, context.rotateAfterMiB * MIB);
+            await appendFile(path, `${JSON.stringify(record)}\n`, { mode: OWNER_ONLY_FILE });
+        },
+    };
+}
+function insideDir(path, root) {
+    let base = root;
+    if (root.endsWith('/')) {
+        base = root.slice(0, -1);
+    }
+    if (path === base) {
+        return true;
+    }
+    return path.startsWith(`${base}/`);
+}
+function normalizeAbsolutePath(path) {
+    const trimmed = path.trim();
+    if (!trimmed) {
+        throw new TheoremError('config', 'trace directory must be non-empty');
+    }
+    if (!trimmed.startsWith('/')) {
+        throw new TheoremError('config', 'trace directory must be absolute');
+    }
+    const parts = [];
+    for (const part of trimmed.split('/')) {
+        if (!part || part === '.') {
+            continue;
+        }
+        if (part === '..') {
+            parts.pop();
+            continue;
+        }
+        parts.push(part);
+    }
+    return `/${parts.join('/')}`;
+}
+/** An absolute directory outside the working directory, normalized; throws `config` otherwise. */
+function validateTraceDir(dir) {
+    const normalized = normalizeAbsolutePath(dir);
+    if (insideDir(normalized, normalizeAbsolutePath(cwd()))) {
+        throw new TheoremError('config', 'trace directory must be outside the project checkout');
+    }
+    return normalized;
+}

package/esm/src/observability/mod.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Trace sinks, the destination registry, observability policy, the span builder and the trace
+ * catalog. THEOREM owns no database: hosts register destinations or pass a sink into `runTurn`.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+export { clearTraceDestinations, getTraceDestination, isTraceSink, listTraceDestinationIds, registerTraceDestination, requireTraceDestination, } from './destinations.js';
+export type { OtlpAnyValue, OtlpKeyValue, OtlpSpan, OtlpTraceRequest } from './otlp.js';
+export { toOtlpJson } from './otlp.js';
+export { resolveTraceWriter } from './policy.js';
+export { resolveObservabilityPolicy } from './resolve-policy.js';
+export { memorySink, noopSink, writeTrace, } from './trace.js';
+export type { TraceAttributeGroup, TraceAttributeMeta, TraceEventMeta, TraceOptionMeta, TraceSpanMeta, TraceSpanType, TraceValueFormat, } from './trace-catalog.js';
+export { TRACE_ATTRIBUTE_GROUPS, TRACE_FIELDS, TRACE_SPAN_TYPES, TRACE_STATUS, traceAttributeMeta, traceEventAttributeMeta, traceEventMeta, traceSpanMeta, } from './trace-catalog.js';
+export type { TraceRecord } from './trace-record.js';
+export { buildRecord, contentOf, inlineContent } from './trace-record.js';
+export { traceRecordSchema } from './trace-schema.js';
+export type { TraceSink, TraceWriteContext } from './trace-sink.js';
+export type { SpanHandle, SpanLinkInput, SpanOptions, TraceAttributes, TraceAttributeValue, TraceBytes, TraceClock, TraceContent, TraceJson, TraceSpan, TraceSpanEvent, TraceSpanKind, TraceSpanLink, TraceSpanStatus, TraceTree, } from './trace-span.js';
+export { readTraceparent, startTrace, traceBytes, traceContent, traceJson, } from './trace-span.js';
+export type { ProfileObservabilitySpec, ResolvedObservabilityPolicy, ResolvedTraceInclude, ResolvedTraceScrub, TraceIncludeSpec, TraceScrubSpec, } from './types.js';

package/esm/src/observability/mod.js

@@ -0,0 +1,16 @@
+/**
+ * Trace sinks, the destination registry, observability policy, the span builder and the trace
+ * catalog. THEOREM owns no database: hosts register destinations or pass a sink into `runTurn`.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+export { clearTraceDestinations, getTraceDestination, isTraceSink, listTraceDestinationIds, registerTraceDestination, requireTraceDestination, } from './destinations.js';
+export { toOtlpJson } from './otlp.js';
+export { resolveTraceWriter } from './policy.js';
+export { resolveObservabilityPolicy } from './resolve-policy.js';
+export { memorySink, noopSink, writeTrace, } from './trace.js';
+export { TRACE_ATTRIBUTE_GROUPS, TRACE_FIELDS, TRACE_SPAN_TYPES, TRACE_STATUS, traceAttributeMeta, traceEventAttributeMeta, traceEventMeta, traceSpanMeta, } from './trace-catalog.js';
+export { buildRecord, contentOf, inlineContent } from './trace-record.js';
+export { traceRecordSchema } from './trace-schema.js';
+export { readTraceparent, startTrace, traceBytes, traceContent, traceJson, } from './trace-span.js';

package/esm/src/observability/openinference.d.ts

@@ -0,0 +1,11 @@
+/**
+ * OpenInference attributes for Phoenix, whose message views, reasoning tokens and cost read only
+ * OpenInference names; they are copied beside the semconv names so `toOtlpJson` stays neutral.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import { type TraceRecord } from './trace-record.js';
+/** Pure: input records are not changed. Export with `toOtlpJson(withOpenInference(records))`. */
+declare function withOpenInference(records: readonly TraceRecord[]): TraceRecord[];
+export { withOpenInference };

package/esm/src/observability/openinference.js

@@ -0,0 +1,205 @@
+/**
+ * OpenInference attributes for Phoenix, whose message views, reasoning tokens and cost read only
+ * OpenInference names; they are copied beside the semconv names so `toOtlpJson` stays neutral.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import { isRecord } from '../kernel/util/record.js';
+import { inlineContent } from './trace-record.js';
+const MODEL_CALLS = new Set(['chat', 'generate_content']);
+const AGENT_CALLS = new Set(['invoke_agent']);
+/** A decision (`theorem.decision.*`): one model call over JSON state, with no messages. */
+const DECISION = 'decide';
+/** Eval spans carry no semconv operation: a trial grades one turn, a run chains the trials. */
+const EVAL_KINDS = {
+    'theorem.eval.trial': 'EVALUATOR',
+    'theorem.eval.run': 'CHAIN',
+};
+/** Model calls only: a viewer sums usage across a trace, and an agent span's is already a sum. */
+function openInferenceUsage(attributes) {
+    const reasoning = attributes['gen_ai.usage.reasoning.output_tokens'];
+    const cost = attributes['theorem.usage.cost_usd'];
+    return {
+        ...(typeof reasoning === 'number'
+            ? { 'llm.token_count.completion_details.reasoning': reasoning }
+            : {}),
+        // A partial cost would read as the call's total; it keeps only its theorem.* name.
+        ...(typeof cost === 'number' && attributes['theorem.usage.cost_partial'] !== true
+            ? { 'llm.cost.total': cost }
+            : {}),
+    };
+}
+function messagesOf(record, value) {
+    const inlined = inlineContent(record, value);
+    if (!Array.isArray(inlined))
+        return [];
+    return inlined.flatMap((message) => {
+        if (!isRecord(message) || typeof message.role !== 'string')
+            return [];
+        const parts = Array.isArray(message.parts) ? message.parts.filter(isRecord) : [];
+        return [{ role: message.role, parts: parts }];
+    });
+}
+function partText(part) {
+    if (part.type === 'text' && typeof part.content === 'string')
+        return part.content;
+    if (part.type === 'structured' && part.content !== undefined)
+        return JSON.stringify(part.content);
+    if (part.type === 'tool_call' || part.type === 'tool_call_response')
+        return undefined;
+    if (typeof part.modality === 'string')
+        return `[${part.modality}]`;
+    return undefined;
+}
+/** A text part that repeats the structured part's JSON is shown once, as the JSON. */
+function repeatsStructured(part, structured) {
+    if (structured === undefined || part.type !== 'text' || typeof part.content !== 'string') {
+        return false;
+    }
+    try {
+        return JSON.stringify(JSON.parse(part.content)) === JSON.stringify(structured.content);
+    }
+    catch {
+        return false;
+    }
+}
+function messageText(message) {
+    const structured = message.parts.find((part) => part.type === 'structured');
+    return message.parts
+        .filter((part) => !repeatsStructured(part, structured))
+        .flatMap((part) => partText(part) ?? [])
+        .join('\n');
+}
+function messageAttributes(prefix, message) {
+    const out = { [`${prefix}.message.role`]: message.role };
+    const text = messageText(message);
+    if (text !== '')
+        out[`${prefix}.message.content`] = text;
+    let calls = 0;
+    for (const part of message.parts) {
+        if (part.type === 'tool_call') {
+            const call = `${prefix}.message.tool_calls.${calls}.tool_call`;
+            calls += 1;
+            if (typeof part.id === 'string')
+                out[`${call}.id`] = part.id;
+            if (typeof part.name === 'string')
+                out[`${call}.function.name`] = part.name;
+            if (typeof part.arguments === 'string')
+                out[`${call}.function.arguments`] = part.arguments;
+        }
+        else if (part.type === 'tool_call_response') {
+            if (typeof part.id === 'string')
+                out[`${prefix}.message.tool_call_id`] = part.id;
+            if (typeof part.response === 'string')
+                out[`${prefix}.message.content`] = part.response;
+        }
+    }
+    return out;
+}
+function messagesAttributes(key, messages) {
+    return Object.assign({}, ...messages.map((message, index) => messageAttributes(`${key}.${index}`, message)));
+}
+/** `input.value` / `output.value`: the text a person would read, else the messages as JSON. */
+function valueAttributes(side, messages) {
+    if (messages.length === 0)
+        return {};
+    const texts = messages.map(messageText).filter((text) => text !== '');
+    if (texts.length === messages.length && texts.length === 1 && texts[0] !== undefined) {
+        return { [`${side}.value`]: texts[0], [`${side}.mime_type`]: 'text/plain' };
+    }
+    return {
+        [`${side}.value`]: JSON.stringify(messages.map((message) => ({ role: message.role, content: messageText(message) }))),
+        [`${side}.mime_type`]: 'application/json',
+    };
+}
+function openInferenceModelMessages(record, span) {
+    const system = messagesOf(record, span.attributes['gen_ai.system_instructions'] === undefined
+        ? undefined
+        : [{ role: 'system', parts: span.attributes['gen_ai.system_instructions'] }]);
+    const input = [...system, ...messagesOf(record, span.attributes['gen_ai.input.messages'])];
+    const output = messagesOf(record, span.attributes['gen_ai.output.messages'] ?? span.attributes['theorem.output.delivered']);
+    return {
+        ...messagesAttributes('llm.input_messages', input),
+        ...messagesAttributes('llm.output_messages', output),
+        ...valueAttributes('input', input.filter((message) => message.role !== 'system')),
+        ...valueAttributes('output', output),
+    };
+}
+function openInferenceAgentValues(record, span) {
+    return {
+        ...valueAttributes('input', messagesOf(record, span.attributes['gen_ai.input.messages'])),
+        ...valueAttributes('output', messagesOf(record, span.attributes['gen_ai.output.messages'])),
+    };
+}
+function jsonValue(record, side, value) {
+    if (value === undefined)
+        return {};
+    return {
+        [`${side}.value`]: JSON.stringify(inlineContent(record, value)),
+        [`${side}.mime_type`]: 'application/json',
+    };
+}
+/**
+ * Phoenix derives no kind for an operation semconv does not name, and has no price for Jev, so
+ * the kind, model, tokens and cost are stated. It has no messages, so Phoenix cannot replay it.
+ */
+function openInferenceDecision(record, span) {
+    const { attributes } = span;
+    const input = attributes['gen_ai.usage.input_tokens'];
+    const output = attributes['gen_ai.usage.output_tokens'];
+    const model = attributes['gen_ai.response.model'] ?? attributes['gen_ai.request.model'];
+    return {
+        'openinference.span.kind': 'LLM',
+        ...(typeof model === 'string' ? { 'llm.model_name': model } : {}),
+        ...(typeof attributes['gen_ai.provider.name'] === 'string'
+            ? { 'llm.provider': attributes['gen_ai.provider.name'] }
+            : {}),
+        ...(typeof input === 'number' ? { 'llm.token_count.prompt': input } : {}),
+        ...(typeof output === 'number' ? { 'llm.token_count.completion': output } : {}),
+        ...(typeof input === 'number' && typeof output === 'number'
+            ? { 'llm.token_count.total': input + output }
+            : {}),
+        ...openInferenceUsage(attributes),
+        ...jsonValue(record, 'input', attributes['theorem.decision.state']),
+        ...jsonValue(record, 'output', attributes['theorem.decision.answers']),
+    };
+}
+function withSpanAttributes(record, span) {
+    const operation = span.attributes['gen_ai.operation.name'];
+    if (MODEL_CALLS.has(operation)) {
+        return {
+            ...span,
+            attributes: {
+                ...span.attributes,
+                ...openInferenceUsage(span.attributes),
+                ...openInferenceModelMessages(record, span),
+            },
+        };
+    }
+    if (AGENT_CALLS.has(operation)) {
+        return {
+            ...span,
+            attributes: { ...span.attributes, ...openInferenceAgentValues(record, span) },
+        };
+    }
+    if (operation === DECISION) {
+        return {
+            ...span,
+            attributes: { ...span.attributes, ...openInferenceDecision(record, span) },
+        };
+    }
+    const evalKind = EVAL_KINDS[span.name];
+    if (evalKind !== undefined) {
+        return { ...span, attributes: { ...span.attributes, 'openinference.span.kind': evalKind } };
+    }
+    return span;
+}
+/** Pure: input records are not changed. Export with `toOtlpJson(withOpenInference(records))`. */
+function withOpenInference(records) {
+    return records.map((record) => ({
+        ...record,
+        spans: record.spans.map((span) => withSpanAttributes(record, span)),
+    }));
+}
+export { withOpenInference };

package/esm/src/observability/otlp.d.ts

@@ -0,0 +1,68 @@
+import { type TraceRecord } from './trace-record.js';
+type OtlpAnyValue = {
+    stringValue: string;
+} | {
+    boolValue: boolean;
+} | {
+    intValue: string;
+} | {
+    doubleValue: number;
+} | {
+    arrayValue: {
+        values: OtlpAnyValue[];
+    };
+} | {
+    kvlistValue: {
+        values: OtlpKeyValue[];
+    };
+};
+interface OtlpKeyValue {
+    key: string;
+    value: OtlpAnyValue;
+}
+interface OtlpSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind: number;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes: OtlpKeyValue[];
+    events: {
+        timeUnixNano: string;
+        name: string;
+        attributes: OtlpKeyValue[];
+    }[];
+    links: {
+        traceId: string;
+        spanId: string;
+        attributes: OtlpKeyValue[];
+    }[];
+    status: {
+        code: number;
+        message?: string;
+    };
+}
+/** An OTLP/JSON `ExportTraceServiceRequest` (the body of `POST /v1/traces`). */
+interface OtlpTraceRequest {
+    resourceSpans: {
+        resource: {
+            attributes: OtlpKeyValue[];
+        };
+        scopeSpans: {
+            scope: {
+                name: string;
+            };
+            schemaUrl: string;
+            spans: OtlpSpan[];
+        }[];
+    }[];
+}
+/**
+ * One resource per record, one scope, with every stored reference inlined. For a backend that
+ * takes protobuf only, send this through an OpenTelemetry Collector.
+ */
+declare function toOtlpJson(records: readonly TraceRecord[]): OtlpTraceRequest;
+export type { OtlpAnyValue, OtlpKeyValue, OtlpSpan, OtlpTraceRequest };
+export { toOtlpJson };