@hue-run/sdk 0.21.1 → 0.22.0

package/dist/cli/import-formats/containers.js

@@ -0,0 +1,399 @@
+import * as zlib from "node:zlib";
+import { parseJsonText } from "../traces-import-convert.js";
+import { isZipSignature } from "../traces-import-zip.js";
+/**
+ * What every format reads through: a file's compression (gzip, zstd) undone, its text decoded,
+ * and its JSON read as one document or, failing that, as JSON Lines whose every line is read on
+ * its own, a line that is not JSON named with its number instead of refusing the file.
+ *
+ * Damage is contained the same way: a gzip or zstd file that breaks off, or carries bytes after
+ * its last member or frame, is read up to the break and the rest named; a line that is not UTF-8
+ * is named and the other lines read; Python's bare `NaN` and `Infinity` are read as null and
+ * named.
+ */
+const GZIP = [0x1f, 0x8b];
+const ZSTD = [0x28, 0xb5, 0x2f, 0xfd];
+const startsWith = (bytes, magic, at = 0) => bytes.byteLength >= at + magic.length && magic.every((byte, index) => bytes[at + index] === byte);
+/** A zstd skippable frame (`0x184D2A50` to `0x184D2A5F`, little-endian): `pzstd` opens with one. */
+const skippable = (bytes, at = 0) => bytes.byteLength >= at + 4 &&
+    (bytes[at] & 0xf0) === 0x50 &&
+    bytes[at + 1] === 0x2a &&
+    bytes[at + 2] === 0x4d &&
+    bytes[at + 3] === 0x18;
+const isZstd = (bytes, at = 0) => startsWith(bytes, ZSTD, at) || skippable(bytes, at);
+const tooLarge = (error) => error instanceof RangeError ||
+    error?.code === "ERR_BUFFER_TOO_LARGE";
+/** The file's content with its compression undone, or why it cannot be read. `maxBytes` bounds
+ * the decompressed size. */
+export function decodeContainer(bytes, maxBytes) {
+    if (!bytes.byteLength)
+        return { unsupported: "the file is empty" };
+    let decoded = { bytes };
+    if (startsWith(bytes, GZIP))
+        decoded = gunzip(bytes, maxBytes);
+    else if (isZstd(bytes))
+        decoded = unzstd(bytes, maxBytes);
+    if ("unsupported" in decoded)
+        return decoded;
+    if (decoded.bytes !== bytes) {
+        if (startsWith(decoded.bytes, GZIP) || isZstd(decoded.bytes))
+            return { unsupported: "a file compressed twice; decompress it first" };
+        if (!decoded.bytes.byteLength)
+            return { unsupported: "the file is empty" };
+    }
+    // An archive is read where the walk finds it on disk; one inside another is not opened.
+    if (isZipSignature(decoded.bytes))
+        return { unsupported: "a ZIP archive inside the input; extract it first" };
+    return decoded;
+}
+const oversized = (format, maxBytes) => ({
+    unsupported: `a ${format} file that decompresses to more than ${maxBytes} bytes`,
+});
+/** gzip, every member of it. A file that breaks off, or holds bytes after its last member, is
+ * read member by member up to the break, the rest named; a member that fails its checksum leaves
+ * the file unread. */
+function gunzip(bytes, maxBytes) {
+    try {
+        return { bytes: zlib.gunzipSync(bytes, { maxOutputLength: maxBytes }) };
+    }
+    catch (error) {
+        if (tooLarge(error))
+            return oversized("gzip", maxBytes);
+    }
+    const parts = [];
+    let size = 0;
+    let pos = 0;
+    let note;
+    while (pos < bytes.byteLength) {
+        const start = startsWith(bytes, GZIP, pos) ? memberData(bytes, pos) : undefined;
+        if (start === undefined) {
+            // Zero padding after the last member is what a tape or block device writes.
+            const rest = bytes.subarray(pos);
+            if (!rest.every((byte) => byte === 0))
+                note = `${rest.byteLength} bytes after the last gzip member are not gzip and were not read`;
+            break;
+        }
+        let inflated;
+        try {
+            inflated = zlib.inflateRawSync(bytes.subarray(start), {
+                info: true,
+                finishFlush: zlib.constants.Z_SYNC_FLUSH,
+                maxOutputLength: maxBytes - size,
+            });
+        }
+        catch (error) {
+            if (tooLarge(error))
+                return oversized("gzip", maxBytes);
+            note = "the gzip file is damaged; what follows the damage was not read";
+            break;
+        }
+        parts.push(inflated.buffer);
+        size += inflated.buffer.byteLength;
+        // A complete member ends with its 8-byte trailer (CRC-32 and size).
+        const end = start + inflated.engine.bytesWritten + 8;
+        if (end > bytes.byteLength) {
+            note = "the gzip file breaks off; what follows the last complete line was not read";
+            break;
+        }
+        // A member whose data does not match its trailer is damaged, and none of the file is trusted.
+        const trailer = new DataView(bytes.buffer, bytes.byteOffset + end - 8, 8);
+        if (trailer.getUint32(0, true) !== zlib.crc32(inflated.buffer) ||
+            trailer.getUint32(4, true) !== inflated.buffer.byteLength >>> 0)
+            return { unsupported: "a damaged gzip file" };
+        pos = end;
+    }
+    // A file that reads whole, every member matching its trailer, yet failed to decompress is
+    // damaged somewhere this cannot see: none of it is trusted.
+    if (!note || !size)
+        return {
+            unsupported: note?.includes("breaks off") ? "a truncated gzip file" : "a damaged gzip file",
+        };
+    return { bytes: Buffer.concat(parts), note };
+}
+/** Where a gzip member's compressed data starts, past its header; undefined when the header is
+ * damaged or cut off. */
+function memberData(bytes, pos) {
+    if (bytes[pos + 2] !== 8)
+        return undefined;
+    const flags = bytes[pos + 3];
+    let at = pos + 10;
+    if (flags & 0x04) {
+        if (at + 2 > bytes.byteLength)
+            return undefined;
+        at += 2 + (bytes[at] | (bytes[at + 1] << 8));
+    }
+    for (const flag of [0x08, 0x10]) {
+        if (!(flags & flag))
+            continue;
+        while (at < bytes.byteLength && bytes[at] !== 0)
+            at++;
+        at++;
+    }
+    if (flags & 0x02)
+        at += 2;
+    return at < bytes.byteLength ? at : undefined;
+}
+/** The end of the zstd frame (or skippable frame) at `pos`, or why there is none: `truncated`
+ * when the frame runs past the content, `other` when no frame starts there. */
+function frameEnd(bytes, pos) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (skippable(bytes, pos)) {
+        if (pos + 8 > bytes.byteLength)
+            return "truncated";
+        const end = pos + 8 + view.getUint32(pos + 4, true);
+        return end > bytes.byteLength ? "truncated" : end;
+    }
+    if (!startsWith(bytes, ZSTD, pos))
+        return "other";
+    if (pos + 5 > bytes.byteLength)
+        return "truncated";
+    const descriptor = bytes[pos + 4];
+    const contentSize = descriptor >> 6;
+    const singleSegment = (descriptor >> 5) & 1;
+    const checksum = (descriptor >> 2) & 1;
+    const dictionary = descriptor & 3;
+    let at = pos +
+        5 +
+        (singleSegment ? 0 : 1) +
+        [0, 1, 2, 4][dictionary] +
+        [singleSegment ? 1 : 0, 2, 4, 8][contentSize];
+    for (;;) {
+        if (at + 3 > bytes.byteLength)
+            return "truncated";
+        const header = bytes[at] | (bytes[at + 1] << 8) | (bytes[at + 2] << 16);
+        const type = (header >> 1) & 3;
+        if (type === 3)
+            return "other";
+        at += 3 + (type === 1 ? 1 : header >>> 3);
+        if (header & 1)
+            break;
+    }
+    at += checksum ? 4 : 0;
+    return at > bytes.byteLength ? "truncated" : at;
+}
+/** zstd, every frame of it: Node.js decompresses only a file's first frame on its own, so each
+ * frame is found and decompressed in turn. Skippable frames are passed over; a frame that breaks
+ * off, and bytes after the last frame, are named. */
+function unzstd(bytes, maxBytes) {
+    // zstd is in node:zlib from Node.js 22.15; earlier releases of the supported range lack it.
+    if (typeof zlib.zstdDecompressSync !== "function")
+        return {
+            unsupported: "a zstd file, which this Node.js cannot decompress (Node.js 22.15 or later can); decompress it first",
+        };
+    const parts = [];
+    let size = 0;
+    let pos = 0;
+    let frames = 0;
+    let stop;
+    while (pos < bytes.byteLength) {
+        const end = frameEnd(bytes, pos);
+        if (end === "other" || end === "truncated") {
+            stop = end === "other" ? "trailing" : "truncated";
+            break;
+        }
+        if (!skippable(bytes, pos)) {
+            let output;
+            try {
+                output = zlib.zstdDecompressSync(bytes.subarray(pos, end), {
+                    maxOutputLength: maxBytes - size,
+                });
+            }
+            catch (error) {
+                if (tooLarge(error))
+                    return oversized("zstd", maxBytes);
+                stop = "damaged";
+                break;
+            }
+            parts.push(output);
+            size += output.byteLength;
+            frames++;
+        }
+        pos = end;
+    }
+    if (!frames)
+        return {
+            unsupported: stop === "truncated"
+                ? "a truncated zstd file"
+                : stop
+                    ? "a damaged zstd file"
+                    : "a zstd file without data",
+        };
+    const note = stop === "trailing"
+        ? `${bytes.byteLength - pos} bytes after the last zstd frame are not zstd and were not read`
+        : stop === "truncated"
+            ? "the zstd file breaks off; what follows the last complete frame was not read"
+            : stop === "damaged"
+                ? "the zstd file is damaged; what follows the damage was not read"
+                : undefined;
+    return { bytes: Buffer.concat(parts), ...(note ? { note } : {}) };
+}
+/** Whether text that failed to parse breaks off inside a string or an open object or list. */
+function truncated(text) {
+    if (!/^\s*[{[]/.test(text))
+        return false;
+    let depth = 0;
+    let inString = false;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (inString) {
+            if (char === "\\")
+                index++;
+            else if (char === '"')
+                inString = false;
+        }
+        else if (char === '"')
+            inString = true;
+        else if (char === "{" || char === "[")
+            depth++;
+        else if (char === "}" || char === "]")
+            depth--;
+    }
+    return inString || depth > 0;
+}
+/** Text with every bare `NaN`, `Infinity` and `-Infinity` outside a string (which Python's
+ * `json.dumps` writes by default) as `null`; undefined when it holds none. */
+function withoutNonFinite(text) {
+    if (!/NaN|Infinity/.test(text))
+        return undefined;
+    let out = "";
+    let from = 0;
+    let replaced = false;
+    let inString = false;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (inString) {
+            if (char === "\\")
+                index++;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char !== "N" && char !== "I" && char !== "-")
+            continue;
+        const token = /^(?:-?Infinity|NaN)/.exec(text.slice(index, index + 9))?.[0];
+        if (!token ||
+            /[\w$]/.test(text[index - 1] ?? "") ||
+            /[\w$]/.test(text[index + token.length] ?? ""))
+            continue;
+        out += `${text.slice(from, index)}null`;
+        from = index + token.length;
+        index = from - 1;
+        replaced = true;
+    }
+    return replaced ? out + text.slice(from) : undefined;
+}
+const NON_FINITE = "NaN or Infinity, which JSON cannot hold, read as null";
+/** JSON text parsed, with Python's bare `NaN` and `Infinity` read as null when nothing else
+ * stands in the way; throws when it is not JSON even so. */
+function parseRepairing(text) {
+    try {
+        return parseJsonText(text);
+    }
+    catch (error) {
+        const repaired = withoutNonFinite(text);
+        if (repaired === undefined)
+            throw error;
+        return { ...parseJsonText(repaired), note: NON_FINITE };
+    }
+}
+/** Text decoded from bytes: UTF-8, or UTF-16 after its byte order mark. A UTF-8 file with lines
+ * that are not UTF-8 keeps its other lines, the bad ones blanked and named. */
+function decodeText(bytes) {
+    const utf16 = bytes[0] === 0xff && bytes[1] === 0xfe
+        ? "le"
+        : bytes[0] === 0xfe && bytes[1] === 0xff
+            ? "be"
+            : undefined;
+    if (utf16) {
+        // UTF-16 as Windows PowerShell's `>` writes it; big-endian is swapped to little first.
+        const body = Buffer.from(bytes.subarray(2));
+        if (body.byteLength % 2)
+            return { unsupported: "not UTF-16 text" };
+        if (utf16 === "be")
+            body.swap16();
+        try {
+            return { text: new TextDecoder("utf-16le", { fatal: true }).decode(body), badLines: [] };
+        }
+        catch {
+            return { unsupported: "not UTF-16 text" };
+        }
+    }
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+    try {
+        return { text: decoder.decode(bytes), badLines: [] };
+    }
+    catch {
+        // Some line is not UTF-8: each line is decoded on its own.
+    }
+    const lines = [];
+    const badLines = [];
+    let start = 0;
+    while (start <= bytes.byteLength) {
+        let end = bytes.indexOf(0x0a, start);
+        if (end < 0)
+            end = bytes.byteLength;
+        try {
+            lines.push(decoder.decode(bytes.subarray(start, end)));
+        }
+        catch {
+            lines.push("");
+            badLines.push(lines.length);
+        }
+        start = end + 1;
+    }
+    return { text: lines.join("\n"), badLines };
+}
+/** The JSON values of decoded content, the lines that are not JSON, or why none can be read. */
+export function parseValues(bytes) {
+    const decoded = decodeText(bytes);
+    if ("unsupported" in decoded)
+        return decoded;
+    const { text, badLines } = decoded;
+    const problems = badLines.map((line) => ({
+        line,
+        reason: "not UTF-8 text",
+    }));
+    if (!badLines.length)
+        try {
+            const parsed = parseRepairing(text);
+            return { values: [{ ...parsed, text }], problems: [] };
+        }
+        catch {
+            // Not one document: JSON Lines, read line by line.
+        }
+    const lines = text.split(/\r?\n/);
+    const filled = lines.filter((line) => line.trim()).length + badLines.length;
+    if (filled < 2)
+        return {
+            unsupported: badLines.length
+                ? `not UTF-8 text (line ${badLines[0]})`
+                : truncated(text)
+                    ? "truncated JSON"
+                    : "not JSON",
+        };
+    const values = [];
+    for (const [index, line] of lines.entries()) {
+        if (!line.trim())
+            continue;
+        try {
+            values.push({ ...parseRepairing(line), text: line, line: index + 1 });
+        }
+        catch {
+            problems.push({ line: index + 1, reason: truncated(line) ? "truncated JSON" : "not JSON" });
+        }
+    }
+    problems.sort((a, b) => a.line - b.line);
+    if (values.length)
+        return { values, problems };
+    return {
+        unsupported: badLines.length
+            ? `not UTF-8 text (line ${badLines[0]})`
+            : truncated(text)
+                ? "truncated JSON"
+                : "not JSON",
+    };
+}

package/dist/cli/import-formats/datadog.d.ts

@@ -0,0 +1,2 @@
+import type { ImportAdapter } from "./adapter.js";
+export declare const datadogLlmObs: ImportAdapter;

package/dist/cli/import-formats/datadog.js

@@ -0,0 +1,264 @@
+import { ConversionError, isObject, parseNestedJsonText, } from "../traces-import-convert.js";
+import { identityText } from "./identity.js";
+import { unsigned } from "./otel-spans.js";
+import { readRecords } from "./rows.js";
+const object = (value) => isObject(value) ? value : undefined;
+const text = (value) => typeof value === "string" && value ? value : undefined;
+const isSpan = (value) => {
+    const attributes = object(object(value)?.attributes);
+    return (object(value)?.type === "span" &&
+        attributes !== undefined &&
+        typeof attributes.span_id === "string" &&
+        typeof attributes.trace_id === "string");
+};
+function recordsOf(value) {
+    if (isSpan(value))
+        return [value];
+    const page = object(value);
+    return page && Array.isArray(page.data) && page.data.some(isSpan) ? page.data : undefined;
+}
+const KINDS = {
+    llm: "llm",
+    tool: "tool",
+    agent: "agent",
+    embedding: "embedding",
+    retrieval: "retrieval",
+};
+/** A root span's `parent_id`. */
+const NO_PARENT = new Set(["undefined", "", "0"]);
+/** `start_ns` as Unix nanoseconds, the unit it was read in (nanoseconds per unit) and the rule
+ * that read it when it was not nanoseconds. */
+function startOf(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const count = unsigned(value);
+    if (!count)
+        throw new ConversionError("start_ns is not a positive integer");
+    if (count < 100000000000000n)
+        return { start: count * 1000000n, scale: 1000000n, unit: "ms" };
+    if (count < 100000000000000000n)
+        return { start: count * 1000n, scale: 1000n, unit: "us" };
+    return { start: count, scale: 1n };
+}
+/** `duration` in the unit `start_ns` was read in, as nanoseconds. */
+function durationOf(value, scale) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        return BigInt(Math.round(value * Number(scale)));
+    const count = unsigned(value);
+    if (count === undefined)
+        throw new ConversionError("duration is not a count of nanoseconds");
+    return count * scale;
+}
+/** Tags (`key:value`) by key; a key tagged twice keeps its first value. */
+function tagMap(tags) {
+    const map = new Map();
+    if (tags === undefined || tags === null)
+        return map;
+    if (!Array.isArray(tags))
+        throw new ConversionError("tags is not a list of text");
+    for (const tag of tags) {
+        if (typeof tag !== "string")
+            throw new ConversionError("tags is not a list of text");
+        const at = tag.indexOf(":");
+        const key = at < 0 ? tag : tag.slice(0, at);
+        if (!map.has(key))
+            map.set(key, at < 0 ? "" : tag.slice(at + 1));
+    }
+    return map;
+}
+/** Datadog's messages as GenAI messages: content as a text part, tool calls and tool results as
+ * `tool_call` and `tool_call_response` parts. */
+function messagesOf(raw, role) {
+    if (!Array.isArray(raw) || !raw.length)
+        return undefined;
+    return raw.map((item) => {
+        const message = object(item);
+        if (!message)
+            throw new ConversionError("a message that is not an object");
+        const parts = [];
+        if (typeof message.content === "string" && message.content)
+            parts.push({ type: "text", content: message.content });
+        for (const [field, kind] of [
+            ["tool_calls", "tool_call"],
+            ["tool_results", "tool_call_response"],
+        ]) {
+            const calls = message[field] ?? [];
+            if (!Array.isArray(calls))
+                throw new ConversionError(`${field} is not a list`);
+            for (const value of calls) {
+                const call = object(value);
+                if (!call)
+                    throw new ConversionError(`${field} holds a value that is not an object`);
+                parts.push({
+                    type: kind,
+                    ...(text(call.tool_id) ? { id: text(call.tool_id) } : {}),
+                    ...(text(call.name) ? { name: text(call.name) } : {}),
+                    ...(kind === "tool_call"
+                        ? { arguments: call.arguments ?? null }
+                        : { response: call.result ?? null }),
+                });
+            }
+        }
+        return { role: text(message.role) ?? role, parts };
+    });
+}
+/** A span's input or output: its messages when it has any, else its value, else the object. */
+function contentOf(raw, role) {
+    const io = object(raw);
+    if (!io)
+        return raw ?? undefined;
+    const messages = messagesOf(io.messages, role);
+    if (messages)
+        return messages;
+    if (typeof io.value === "string")
+        return io.value;
+    return Object.keys(io).length ? io : undefined;
+}
+/** A tool's arguments or result: the JSON a value holds, else the text. */
+function toolValue(raw) {
+    const io = object(raw);
+    const value = io ? io.value : raw;
+    if (typeof value !== "string")
+        return value ?? undefined;
+    try {
+        return parseNestedJsonText(value).value;
+    }
+    catch {
+        return value;
+    }
+}
+const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+function readSpan(resource, context) {
+    const span = object(resource.attributes);
+    const traceKey = span?.trace_id;
+    const spanKey = span?.span_id;
+    if (!span ||
+        resource.type !== "span" ||
+        typeof traceKey !== "string" ||
+        typeof spanKey !== "string")
+        throw new ConversionError("a record that is not a Datadog span");
+    const parent = text(span.parent_id);
+    const metadata = object(span.metadata);
+    if (span.metadata != null && !metadata)
+        throw new ConversionError("metadata is not an object");
+    const metrics = object(span.metrics);
+    if (span.metrics != null && !metrics)
+        throw new ConversionError("metrics is not an object");
+    const tags = tagMap(span.tags);
+    const spanKind = text(span.span_kind);
+    const kind = spanKind && Object.hasOwn(KINDS, spanKind) ? KINDS[spanKind] : undefined;
+    const started = startOf(span.start_ns);
+    const duration = durationOf(span.duration, started?.scale ?? 1n);
+    const timing = started?.unit
+        ? [
+            `start_ns_read_as_${started.unit}`,
+            ...(duration !== undefined ? [`duration_read_as_${started.unit}`] : []),
+        ].join("; ")
+        : undefined;
+    const tool = kind === "tool";
+    const row = {
+        traceKey,
+        spanKey,
+        ...(parent && !NO_PARENT.has(parent) ? { parentKey: parent } : {}),
+        name: text(span.name) ?? spanKind ?? "span",
+        ...(kind ? { kind } : {}),
+        ...(started ? { start: started.start } : {}),
+        ...(started && duration !== undefined ? { end: started.start + duration } : {}),
+        ...(timing ? { timing } : {}),
+        record: resource,
+        ...(metadata ? { metadata } : {}),
+        attributes: {
+            ...(spanKind ? { "datadog.span_kind": spanKind } : {}),
+            ...(text(span.ml_app) ? { "datadog.ml_app": text(span.ml_app) } : {}),
+            ...(Array.isArray(span.tags) ? { "datadog.tags": span.tags } : {}),
+            ...(metadata && Object.keys(metadata).length
+                ? { "datadog.metadata": JSON.stringify(metadata) }
+                : {}),
+            ...(metrics ? { "datadog.metrics": JSON.stringify(metrics) } : {}),
+            ...(object(span.evaluation) ? { "datadog.evaluation": JSON.stringify(span.evaluation) } : {}),
+            ...(text(span.intent) ? { "datadog.intent": text(span.intent) } : {}),
+            ...(Array.isArray(span.tool_definitions)
+                ? { "gen_ai.tool.definitions": JSON.stringify(span.tool_definitions) }
+                : {}),
+        },
+    };
+    const service = tags.get("service");
+    if (service)
+        row.resource = { "service.name": service };
+    const environment = tags.get("env");
+    if (environment)
+        row.environment = environment;
+    if (spanKind === "experiment" || tags.get("experiment_id"))
+        row.origin = "evaluation";
+    if (tool) {
+        const args = toolValue(span.input);
+        const result = toolValue(span.output);
+        row.tool = {
+            name: text(span.name) ?? "tool",
+            ...(args !== undefined ? { arguments: args } : {}),
+            ...(result !== undefined ? { result } : {}),
+        };
+    }
+    else {
+        const input = contentOf(span.input, "user");
+        const output = contentOf(span.output, "assistant");
+        if (input !== undefined)
+            row.input = input;
+        if (output !== undefined)
+            row.output = output;
+        // Who asked, never from a tool span: a tool's record may name the account it acted on.
+        const user = tags.get("user_id") ??
+            tags.get("user.id") ??
+            tags.get("usr.id") ??
+            identityText(metadata?.user_id) ??
+            identityText(metadata?.userId);
+        const session = identityText(span.session_id) ??
+            tags.get("session_id") ??
+            identityText(metadata?.session_id) ??
+            identityText(metadata?.sessionId) ??
+            identityText(metadata?.thread_id) ??
+            identityText(metadata?.conversation_id);
+        if (user)
+            row.user = user;
+        if (session)
+            row.session = session;
+    }
+    if (kind === "llm") {
+        if (text(span.model_name))
+            row.model = text(span.model_name);
+        if (text(span.model_provider))
+            row.provider = text(span.model_provider);
+        row.usage = {
+            input: count(metrics?.input_tokens),
+            output: count(metrics?.output_tokens),
+            cacheRead: count(metrics?.cache_read_input_tokens),
+            cacheWrite: count(metrics?.cache_write_input_tokens),
+            reasoning: count(metrics?.reasoning_output_tokens),
+        };
+    }
+    if (span.status === "error") {
+        const error = object(span.error);
+        const message = text(error?.message) ?? text(span["error.message"]);
+        const type = text(error?.type) ?? text(span["error.type"]) ?? tags.get("error_type");
+        row.error = { ...(message ? { message } : {}), ...(type ? { type } : {}) };
+    }
+    context.row(row);
+}
+export const datadogLlmObs = {
+    id: "datadog_llmobs",
+    manifestFormat: "otlp_json",
+    detect: (value) => recordsOf(value) !== undefined,
+    convert(value, context) {
+        readRecords(context, recordsOf(value) ?? [], (record) => {
+            const traceId = object(object(record)?.attributes)?.trace_id;
+            return typeof traceId === "string" && traceId ? traceId : undefined;
+        }, (record) => {
+            const resource = object(record);
+            if (!resource)
+                throw new ConversionError("a record that is not an object");
+            readSpan(resource, context);
+        });
+    },
+};

package/dist/cli/import-formats/helicone.d.ts

@@ -0,0 +1,2 @@
+import type { ImportAdapter } from "./adapter.js";
+export declare const helicone: ImportAdapter;