@hue-run/sdk 0.21.0 → 0.22.0

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

@@ -0,0 +1,498 @@
+import { canonicalJson, ConversionError, isObject, sha256Hex, } from "../traces-import-convert.js";
+import { identityText } from "./identity.js";
+import { genAiMessages } from "./messages.js";
+import { nanosFrom, readRecords } from "./rows.js";
+const object = (value) => isObject(value) ? value : undefined;
+const text = (value) => typeof value === "string" && value ? value : undefined;
+const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+/** Keys of another format's record: a value holding one is never a transcript. */
+const FOREIGN_KEYS = [
+    "span_id",
+    "root_span_id",
+    "trace_id",
+    "traceId",
+    "resourceSpans",
+    "resource_spans",
+    "schema_version",
+    "steps",
+    "observations",
+];
+const foreign = (value) => FOREIGN_KEYS.some((key) => key in value);
+// --- Message lists ---------------------------------------------------------------------------
+/** A Responses API item type: messages, tool calls and their outputs, reasoning and the rest. */
+const RESPONSES_ITEM = /^(?:message|reasoning|compaction|compaction_trigger|item_reference|configuration_update|additional_tools|program|program_output|tool_search_output|mcp_list_tools|mcp_approval_request|mcp_approval_response|[a-z_]+_call(?:_output)?)$/;
+/** A typed Responses item (never an Anthropic response, which names its model). */
+function isResponsesItem(value) {
+    const item = object(value);
+    if (!item || typeof item.type !== "string" || !RESPONSES_ITEM.test(item.type))
+        return false;
+    if ("model" in item || foreign(item))
+        return false;
+    return item.type !== "message" || typeof item.role === "string";
+}
+/** An untyped message (`{role, content}`), which the Responses API also takes as input. */
+const isEasyMessage = (value) => {
+    const item = object(value);
+    return (!!item &&
+        item.type === undefined &&
+        typeof item.role === "string" &&
+        (typeof item.content === "string" || Array.isArray(item.content)));
+};
+/** A list of Responses items: every element an item or a message, at least one typed. */
+const isItemList = (value) => Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((item) => isResponsesItem(item) || isEasyMessage(item)) &&
+    value.some(isResponsesItem);
+/**
+ * A message list's items as the message shapes `genAiMessages` reads: a Responses item it reads
+ * no message from (a hosted tool call, encrypted reasoning) becomes a message holding that item as
+ * a part of its own type, from the tool for an `…_output` item and from the assistant otherwise.
+ */
+export function chatItems(items) {
+    return items.map((raw) => {
+        if (genAiMessages([raw]))
+            return raw;
+        const item = object(raw);
+        const type = text(item?.type);
+        if (!item || !type || item.role !== undefined)
+            return raw;
+        return { role: type.endsWith("_output") ? "tool" : "assistant", parts: [item] };
+    });
+}
+/** Each item read as one GenAI message, or a ConversionError naming the first that is not. */
+function readMessages(items, what) {
+    return items.map((item, index) => {
+        const message = genAiMessages([item])?.[0];
+        if (!message)
+            throw new ConversionError(`${what} ${index + 1} is not a chat message`);
+        return message;
+    });
+}
+/** System instructions as GenAI parts: text as it is, Anthropic text blocks as text parts. */
+function systemParts(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    return genAiMessages([{ role: "system", content: value }])?.[0]?.parts ?? value;
+}
+// --- Model API bodies (also read by the Helicone format) -------------------------------------
+/** The conversation a model request sends, as message shapes: chat `messages` (OpenAI, Anthropic)
+ * or Responses `input`; anything else as recorded. */
+export function requestContent(body) {
+    const fields = object(body);
+    if (!fields)
+        return body;
+    if (Array.isArray(fields.messages))
+        return chatItems(fields.messages);
+    if (typeof fields.input === "string")
+        return [{ role: "user", content: fields.input }];
+    if (isItemList(fields.input))
+        return chatItems(fields.input);
+    return body;
+}
+/** A request's system instructions: Anthropic `system` or Responses `instructions`. */
+export const requestInstructions = (body) => systemParts(object(body)?.system ?? object(body)?.instructions);
+/** A model response's content as message shapes: Responses `output` items; a chat completion or
+ * Anthropic message as recorded, which `genAiMessages` reads. */
+export function responseContent(body) {
+    const fields = object(body);
+    return fields && Array.isArray(fields.output) ? chatItems(fields.output) : body;
+}
+/** Token usage of an OpenAI (chat or Responses) or Anthropic response. Anthropic's input count
+ * leaves out cached tokens, so they are added back as the GenAI conventions count input. */
+export function responseUsage(usage) {
+    const fields = object(usage);
+    if (!fields)
+        return undefined;
+    const input = object(fields.input_tokens_details) ?? object(fields.prompt_tokens_details);
+    const output = object(fields.output_tokens_details) ?? object(fields.completion_tokens_details);
+    const cacheRead = count(fields.cache_read_input_tokens) ?? count(input?.cached_tokens);
+    const cacheWrite = count(fields.cache_creation_input_tokens);
+    const anthropic = "cache_read_input_tokens" in fields || "cache_creation_input_tokens" in fields;
+    const inputTokens = count(fields.input_tokens) ?? count(fields.prompt_tokens);
+    return {
+        input: anthropic && inputTokens !== undefined
+            ? inputTokens + (cacheRead ?? 0) + (cacheWrite ?? 0)
+            : inputTokens,
+        output: count(fields.output_tokens) ?? count(fields.completion_tokens),
+        cacheRead,
+        cacheWrite,
+        reasoning: count(output?.reasoning_tokens),
+    };
+}
+/** What a transcript's turns may repeat together, as much as one file may decompress to: each
+ * turn's span holds the conversation before it, so a long transcript repeats its early messages
+ * once per turn. */
+const MAX_REPEATED_BYTES = 64 * 1024 * 1024;
+/** The trace's rows: the agent, a chat span per turn and a tool span per call. */
+function transcriptRows(traceKey, transcript) {
+    // Spans carry the items in shapes the emitter reads; records keep them as the source wrote them.
+    const raw = transcript.history;
+    const items = chatItems(raw);
+    const history = readMessages(items, "message");
+    const answerItems = transcript.answer ? chatItems(transcript.answer.items) : undefined;
+    const answer = answerItems ? readMessages(answerItems, "output item") : undefined;
+    const turns = [];
+    for (let index = 0; index < history.length; index++) {
+        if (history[index].role !== "assistant")
+            continue;
+        let end = index;
+        while (end < history.length && history[end].role === "assistant")
+            end++;
+        turns.push({ at: index, end, messages: history.slice(index, end) });
+        index = end - 1;
+    }
+    // The conversation each turn repeats, measured before any of it is copied.
+    const before = [0];
+    for (const item of items)
+        before.push(before.at(-1) + Buffer.byteLength(JSON.stringify(item)));
+    let repeated = answer ? before[items.length] : 0;
+    for (const turn of turns)
+        repeated += before[turn.at];
+    if (repeated > MAX_REPEATED_BYTES)
+        throw new ConversionError(`a transcript whose turns together repeat more than ${MAX_REPEATED_BYTES} bytes of conversation`);
+    // A tool call's result, by call id, with the message that holds it.
+    const results = new Map();
+    for (const [index, message] of history.entries())
+        for (const part of message.parts)
+            if (part.type === "tool_call_response" &&
+                typeof part.id === "string" &&
+                !results.has(part.id))
+                results.set(part.id, { response: part.response ?? null, item: raw[index] });
+    const model = transcript.model ?? transcript.answer?.model;
+    const system = transcript.system;
+    const firstTurn = turns[0]?.at ?? history.length;
+    const last = turns.at(-1);
+    const lastOutput = answerItems ?? (last ? items.slice(last.at, last.end) : undefined);
+    const rows = [
+        {
+            traceKey,
+            spanKey: "agent",
+            name: "invoke_agent",
+            kind: "agent",
+            ...(firstTurn > 0 ? { input: items.slice(0, firstTurn) } : {}),
+            ...(lastOutput?.length ? { output: lastOutput } : {}),
+            ...(system !== undefined ? { systemInstructions: system } : {}),
+            ...(transcript.user !== undefined ? { user: transcript.user } : {}),
+            ...(transcript.session !== undefined ? { session: transcript.session } : {}),
+            ...(transcript.tools !== undefined
+                ? { attributes: { "gen_ai.tool.definitions": JSON.stringify(transcript.tools) } }
+                : {}),
+            record: transcript.record,
+            sequence: 0,
+        },
+    ];
+    let sequence = 1;
+    const addTurn = (number, input, output, fields) => {
+        rows.push({
+            traceKey,
+            spanKey: `turn-${number}`,
+            parentKey: "agent",
+            name: model ? `chat ${model}` : "chat",
+            kind: "llm",
+            ...(model ? { model } : {}),
+            ...(input.length ? { input } : {}),
+            output: output.items,
+            ...(system !== undefined ? { systemInstructions: system } : {}),
+            record: output.record,
+            sequence: sequence++,
+            ...fields,
+        });
+        let call = 0;
+        for (const [index, message] of output.messages.entries())
+            for (const part of message.parts) {
+                if (part.type !== "tool_call")
+                    continue;
+                const id = typeof part.id === "string" ? part.id : undefined;
+                const name = typeof part.name === "string" && part.name ? part.name : "tool";
+                const result = id === undefined ? undefined : results.get(id);
+                rows.push({
+                    traceKey,
+                    spanKey: `turn-${number}.tool-${++call}`,
+                    parentKey: "agent",
+                    name: `execute_tool ${name}`,
+                    kind: "tool",
+                    tool: {
+                        name,
+                        ...(id !== undefined ? { callId: id } : {}),
+                        arguments: part.arguments ?? null,
+                        ...(result ? { result: result.response } : {}),
+                    },
+                    ...(id !== undefined && transcript.failed?.has(id) ? { error: {} } : {}),
+                    record: result?.item ?? output.raw[index],
+                    sequence: sequence++,
+                });
+            }
+    };
+    for (const [index, turn] of turns.entries()) {
+        const own = raw.slice(turn.at, turn.end);
+        addTurn(index + 1, items.slice(0, turn.at), {
+            items: items.slice(turn.at, turn.end),
+            raw: own,
+            messages: turn.messages,
+            record: own.length === 1 ? own[0] : own,
+        }, {});
+    }
+    if (transcript.answer && answerItems && answer) {
+        const { usage, start, error } = transcript.answer;
+        addTurn(turns.length + 1, items, {
+            items: answerItems,
+            raw: transcript.answer.items,
+            messages: answer,
+            record: transcript.answer.record,
+        }, {
+            ...(transcript.answer.model ? { responseModel: transcript.answer.model } : {}),
+            ...(usage ? { usage } : {}),
+            ...(start !== undefined ? { start } : {}),
+            ...(error ? { error } : {}),
+        });
+    }
+    return rows;
+}
+/** Converts one transcript; a malformed one refuses only its own trace. `id` reads the source's
+ * own id; without one the trace id derives from the content. */
+function convertTranscript(value, context, read, id) {
+    // Parsed JSON, an object or a list as `detect` claimed it.
+    const json = value;
+    const traceKey = (!Array.isArray(json) && id?.(json)) || sha256Hex(canonicalJson(json));
+    readRecords(context, [json], () => traceKey, () => {
+        for (const row of transcriptRows(traceKey, read(json)))
+            context.row(row);
+    });
+}
+// --- OpenAI Chat Completions -----------------------------------------------------------------
+/** A request's end user: OpenAI's `safety_identifier` or the older `user` field. */
+const openAiUser = (fields) => identityText(fields.safety_identifier) ?? identityText(fields.user);
+/** Anthropic content block types OpenAI chat never sends. */
+const ANTHROPIC_BLOCKS = new Set([
+    "tool_use",
+    "tool_result",
+    "thinking",
+    "redacted_thinking",
+    "document",
+    "search_result",
+    "server_tool_use",
+    "web_search_tool_result",
+    "web_fetch_tool_result",
+    "code_execution_tool_result",
+    "mcp_tool_use",
+    "mcp_tool_result",
+    "container_upload",
+]);
+const OPENAI_ROLES = new Set(["system", "developer", "tool", "function"]);
+/** A request with a message list: `messages` holding at least one `{role}` message. */
+const isChatRequest = (value) => {
+    const fields = object(value);
+    return (!!fields &&
+        !foreign(fields) &&
+        !("object" in fields) &&
+        Array.isArray(fields.messages) &&
+        fields.messages.some((message) => typeof object(message)?.role === "string"));
+};
+/** Whether a chat request carries something only the Anthropic Messages API sends, and nothing
+ * only OpenAI's does. */
+function anthropicRequest(fields) {
+    const messages = fields.messages.map(object);
+    const openAi = messages.some((message) => OPENAI_ROLES.has(text(message?.role) ?? "") ||
+        message?.tool_calls !== undefined ||
+        message?.tool_call_id !== undefined ||
+        message?.function_call !== undefined) ||
+        (Array.isArray(fields.tools) && fields.tools.some((tool) => object(tool)?.type === "function"));
+    if (openAi)
+        return false;
+    return ("system" in fields ||
+        "anthropic_version" in fields ||
+        "stop_sequences" in fields ||
+        (Array.isArray(fields.tools) &&
+            fields.tools.some((tool) => "input_schema" in (object(tool) ?? {}))) ||
+        messages.some((message) => Array.isArray(message?.content) &&
+            message.content.some((block) => ANTHROPIC_BLOCKS.has(text(object(block)?.type) ?? ""))));
+}
+export const openaiChat = {
+    id: "openai_chat",
+    manifestFormat: "otlp_json",
+    detect: (value) => isChatRequest(value) && !anthropicRequest(value),
+    convert(value, context) {
+        convertTranscript(value, context, (fields) => {
+            const request = fields;
+            const user = openAiUser(request);
+            return {
+                record: request,
+                history: request.messages,
+                ...(text(request.model) ? { model: text(request.model) } : {}),
+                ...(request.tools !== undefined ? { tools: request.tools } : {}),
+                ...(user !== undefined ? { user } : {}),
+            };
+        });
+    },
+};
+// --- Anthropic Messages ----------------------------------------------------------------------
+const isAnthropicResponse = (value) => {
+    const fields = object(value);
+    return (!!fields &&
+        fields.type === "message" &&
+        fields.role === "assistant" &&
+        Array.isArray(fields.content) &&
+        typeof fields.model === "string");
+};
+/** Tool use ids whose result block says `is_error`. */
+function failedToolUses(messages) {
+    const failed = new Set();
+    for (const message of messages) {
+        const content = object(message)?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content.map(object))
+            if (block?.type === "tool_result" && block.is_error === true && text(block.tool_use_id))
+                failed.add(text(block.tool_use_id));
+    }
+    return failed;
+}
+export const anthropicMessages = {
+    id: "anthropic_messages",
+    manifestFormat: "otlp_json",
+    detect: (value) => isAnthropicResponse(value) || (isChatRequest(value) && anthropicRequest(value)),
+    convert(value, context) {
+        convertTranscript(value, context, (fields) => {
+            const message = fields;
+            if (isAnthropicResponse(message))
+                return {
+                    record: message,
+                    history: [],
+                    answer: {
+                        items: [message],
+                        record: message,
+                        model: text(message.model),
+                        usage: responseUsage(message.usage),
+                    },
+                };
+            const messages = message.messages;
+            const user = identityText(object(message.metadata)?.user_id);
+            const system = systemParts(message.system);
+            return {
+                record: message,
+                history: messages,
+                ...(text(message.model) ? { model: text(message.model) } : {}),
+                ...(system !== undefined ? { system } : {}),
+                ...(message.tools !== undefined ? { tools: message.tools } : {}),
+                ...(user !== undefined ? { user } : {}),
+                failed: failedToolUses(messages),
+            };
+        }, (fields) => (isAnthropicResponse(fields) ? text(fields.id) : undefined));
+    },
+};
+// --- OpenAI Responses ------------------------------------------------------------------------
+const isResponseObject = (value) => {
+    const fields = object(value);
+    return !!fields && fields.object === "response" && Array.isArray(fields.output);
+};
+/** The fields of a Responses API request, and the answer (`output`, `usage`) logged beside it.
+ * `input` and `output` are common names, so a value with any other field is left to the format
+ * that owns it. */
+const RESPONSES_REQUEST_FIELDS = new Set([
+    "access_programs",
+    "background",
+    "context_management",
+    "conversation",
+    "include",
+    "input",
+    "instructions",
+    "max_output_tokens",
+    "max_tool_calls",
+    "metadata",
+    "model",
+    "moderation",
+    "parallel_tool_calls",
+    "previous_response_id",
+    "prompt",
+    "prompt_cache_key",
+    "prompt_cache_options",
+    "prompt_cache_retention",
+    "reasoning",
+    "safety_identifier",
+    "service_tier",
+    "store",
+    "stream",
+    "stream_options",
+    "temperature",
+    "text",
+    "tool_choice",
+    "tools",
+    "top_logprobs",
+    "top_p",
+    "truncation",
+    "user",
+    "output",
+    "usage",
+]);
+/** A request (`input`), with the answer beside it (`output`) when it was logged too. */
+const isResponsesRequest = (value) => {
+    const fields = object(value);
+    if (!fields || !Object.keys(fields).every((key) => RESPONSES_REQUEST_FIELDS.has(key)))
+        return false;
+    return ((isItemList(fields.input) &&
+        (fields.output === undefined || fields.output === null || isItemList(fields.output))) ||
+        (typeof fields.input === "string" && isItemList(fields.output)));
+};
+/** A Responses conversation id: `conversation` as an id or `{id}`. */
+const conversationOf = (fields) => identityText(fields.conversation) ?? identityText(object(fields.conversation)?.id);
+export const openaiResponses = {
+    id: "openai_responses",
+    manifestFormat: "otlp_json",
+    detect: (value) => isResponseObject(value) || isResponsesRequest(value) || isItemList(value),
+    convert(value, context) {
+        convertTranscript(value, context, (read) => {
+            if (Array.isArray(read))
+                return { record: read, history: read };
+            const fields = read;
+            const user = openAiUser(fields);
+            const session = conversationOf(fields);
+            const system = systemParts(fields.instructions);
+            const failed = fields.status === "failed";
+            const error = object(fields.error);
+            const output = Array.isArray(fields.output) ? fields.output : undefined;
+            const input = fields.input === undefined || fields.input === null
+                ? []
+                : typeof fields.input === "string"
+                    ? [{ role: "user", content: fields.input }]
+                    : fields.input;
+            if (!Array.isArray(input))
+                throw new ConversionError("input is not a list of items");
+            return {
+                record: fields,
+                history: input,
+                ...(output
+                    ? {
+                        answer: {
+                            items: output,
+                            record: output,
+                            ...(isResponseObject(fields) && text(fields.model)
+                                ? { model: text(fields.model) }
+                                : {}),
+                            usage: responseUsage(fields.usage),
+                            ...(typeof fields.created_at === "number"
+                                ? { start: nanosFrom(fields.created_at, "s") }
+                                : {}),
+                            ...(error || failed
+                                ? {
+                                    error: {
+                                        ...(text(error?.message) ? { message: text(error?.message) } : {}),
+                                        ...(text(error?.code) ? { type: text(error?.code) } : {}),
+                                    },
+                                }
+                                : {}),
+                        },
+                    }
+                    : {}),
+                ...(!isResponseObject(fields) && text(fields.model)
+                    ? { model: text(fields.model) }
+                    : {}),
+                ...(system !== undefined ? { system } : {}),
+                ...(fields.tools !== undefined ? { tools: fields.tools } : {}),
+                ...(user !== undefined ? { user } : {}),
+                ...(session !== undefined ? { session } : {}),
+            };
+        }, (fields) => (isResponseObject(fields) ? text(fields.id) : undefined));
+    },
+};

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

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

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

@@ -0,0 +1,159 @@
+import { ConversionError, isObject } from "../traces-import-convert.js";
+import { identityText } from "./identity.js";
+import { count, first, isoNanos, metadataUser, object, SESSION_FIELDS, text, } from "./row-platform-fields.js";
+import { readRecords } from "./rows.js";
+/**
+ * W&B Weave calls (`CallSchema` of Weave's trace server): one call per span, joined into traces by
+ * `trace_id` with `parent_id`. Read from a single call, JSON Lines of calls (the calls stream
+ * query's answer, a UI export), a JSON array of them, the calls query answer (`{"calls": […]}`)
+ * and the call read answer (`{"call": …}`).
+ *
+ * - The op's kind (`attributes.weave.kind`) names the span's: `llm` a model call, `tool` a tool
+ *   call, `agent`, and `search` a retrieval; `guardrail`, `scorer` and other ops record no
+ *   operation. Weave records kinds since January 2026; a call without one from an op Weave's
+ *   integrations patch (`openai.chat.completions.create`, `anthropic.Messages.create`,
+ *   `litellm.completion`, … a model call; `mcp.server.fastmcp.FastMCP.call_tool` and
+ *   `crewai_tools.*._run` a tool call) is read as the kind those integrations give it now. The
+ *   name is the call's `display_name`, else its op's name.
+ * - Token counts come from an `llm` call's `summary.usage`, recorded per model; Weave sums a
+ *   parent's usage over its children, so no other call's is read.
+ * - The conversation is the call's `thread_id`, else its `attributes`' (`thread_id`,
+ *   `session_id`, …); the user comes from its `attributes` (`userId`, `user_id`, …, in the order
+ *   Hue reads a metadata map). `wb_user_id` names the W&B account that logged the call, never the
+ *   end user.
+ * - A trace with an `Evaluation.*` op, or whose root is a scorer, is evaluation traffic; a scorer
+ *   applied inside the application's own op (a guardrail) is a span of its production trace. A
+ *   call exported both before and after it ended keeps the ended copy.
+ */
+const isCall = (value) => isObject(value) &&
+    typeof value.id === "string" &&
+    typeof value.trace_id === "string" &&
+    typeof value.op_name === "string" &&
+    typeof value.started_at === "string";
+/** The calls a query answer (`calls`) or read answer (`call`) holds, when it holds any. */
+function envelopeCalls(value) {
+    if (!isObject(value))
+        return undefined;
+    if (Array.isArray(value.calls) && value.calls.some(isCall))
+        return value.calls;
+    if (isCall(value.call))
+        return [value.call];
+    return undefined;
+}
+const KINDS = {
+    llm: "llm",
+    tool: "tool",
+    agent: "agent",
+    search: "retrieval",
+};
+/** An op's own name from its ref (`weave:///<entity>/<project>/op/<name>:<digest>`). */
+const opName = (ref) => /\/op\/([^/:]+)(?::[^/]*)?$/.exec(ref)?.[1] ?? ref;
+/** The ops Weave's integrations patch, by the kind they give each since kinds were recorded
+ * (weave `integrations/*`): a call from before then has the op but not the kind. */
+const INTEGRATION_KINDS = [
+    [/^openai\.(?:beta\.)?chat\.completions\.(?:create|parse)$/, "llm"],
+    [/^openai\.responses\.(?:create|parse)$/, "llm"],
+    [/^anthropic\.(?:beta\.)?(?:Async)?Messages\.(?:create|stream)$/, "llm"],
+    [/^(?:cerebras|groq|groq\.async)\.chat\.completions\.create$/, "llm"],
+    [/^mistralai\.(?:async_client\.)?chat\.(?:complete|stream)$/, "llm"],
+    [/^cohere\.(?:Async)?Client(?:V2)?\.chat(?:_stream)?$/, "llm"],
+    [/^litellm\.a?completion$/, "llm"],
+    [/^huggingface_hub\.(?:Async)?InferenceClient\.chat_completion$/, "llm"],
+    [/^google\.genai\.models\.(?:Async)?Models\.generate_content(?:_stream)?$/, "llm"],
+    [/^vertexai\.(?:GenerativeModel\.generate_content|ChatSession\.send_message)(?:_async)?$/, "llm"],
+    [/^BedrockRuntime\.(?:converse|invoke)$/, "llm"],
+    [/^crewai\.LLM\.call$/, "llm"],
+    [/^mcp\.server\.fastmcp\.FastMCP\.call_tool$/, "tool"],
+    [/^crewai_tools\.[^.]+\._run$/, "tool"],
+];
+function readCall(call, context) {
+    const traceKey = text(call.trace_id);
+    const spanKey = text(call.id);
+    if (!traceKey || !spanKey)
+        throw new ConversionError("a call without an id or trace_id");
+    const attributes = object(call.attributes);
+    if (call.attributes != null && !attributes)
+        throw new ConversionError("attributes is not an object");
+    const summary = object(call.summary);
+    if (call.summary != null && !summary)
+        throw new ConversionError("summary is not an object");
+    const op = opName(call.op_name);
+    const weaveKind = text(object(attributes?.weave)?.kind);
+    const kind = weaveKind !== undefined
+        ? Object.hasOwn(KINDS, weaveKind)
+            ? KINDS[weaveKind]
+            : undefined
+        : INTEGRATION_KINDS.find(([pattern]) => pattern.test(op))?.[1];
+    const start = isoNanos(call.started_at);
+    const end = call.ended_at == null ? undefined : isoNanos(call.ended_at);
+    const inputs = call.inputs ?? undefined;
+    const output = call.output ?? undefined;
+    const row = {
+        traceKey,
+        spanKey,
+        ...(text(call.parent_id) ? { parentKey: text(call.parent_id) } : {}),
+        name: text(call.display_name) ?? op,
+        ...(kind ? { kind } : {}),
+        start,
+        ...(end !== undefined ? { end } : {}),
+        ...(inputs !== undefined ? { input: inputs } : {}),
+        ...(output !== undefined ? { output } : {}),
+        record: call,
+        ...(attributes ? { metadata: attributes } : {}),
+        revision: end !== undefined ? "1" : "0",
+        attributes: {
+            "weave.op_name": call.op_name,
+            ...(attributes ? { "weave.attributes": JSON.stringify(attributes) } : {}),
+        },
+    };
+    const exception = text(call.exception);
+    if (exception !== undefined || text(object(summary?.weave)?.status) === "error")
+        row.error = exception !== undefined ? { message: exception } : {};
+    if (kind === "llm") {
+        const usage = object(summary?.usage);
+        const models = usage ? Object.keys(usage) : [];
+        const model = text(object(inputs)?.model) ?? (models.length === 1 ? models[0] : undefined);
+        const responseModel = text(object(output)?.model);
+        if (model)
+            row.model = model;
+        if (responseModel)
+            row.responseModel = responseModel;
+        const counts = models.length === 1 ? object(usage[models[0]]) : undefined;
+        if (counts)
+            row.usage = {
+                input: count(counts.prompt_tokens) ?? count(counts.input_tokens),
+                output: count(counts.completion_tokens) ?? count(counts.output_tokens),
+                cacheRead: count(counts.cache_read_input_tokens),
+                cacheWrite: count(counts.cache_creation_input_tokens),
+            };
+    }
+    if (kind === "tool")
+        row.tool = {
+            name: row.name,
+            ...(inputs !== undefined ? { arguments: inputs } : {}),
+            ...(output !== undefined ? { result: output } : {}),
+        };
+    else {
+        const user = metadataUser(attributes);
+        const session = identityText(call.thread_id) ?? first(attributes, SESSION_FIELDS);
+        if (user !== undefined)
+            row.user = user;
+        if (session !== undefined)
+            row.session = session;
+    }
+    if (op.startsWith("Evaluation.") || (weaveKind === "scorer" && row.parentKey === undefined))
+        row.origin = "evaluation";
+    context.row(row);
+}
+export const weaveCalls = {
+    id: "weave_calls",
+    manifestFormat: "otlp_json",
+    detect: (value) => isCall(value) || envelopeCalls(value) !== undefined,
+    convert(value, context) {
+        readRecords(context, isCall(value) ? [value] : (envelopeCalls(value) ?? []), (record) => (isCall(record) ? text(record.trace_id) : undefined), (record) => {
+            if (!isCall(record))
+                throw new ConversionError("a record that is not a Weave call");
+            readCall(record, context);
+        });
+    },
+};

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

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