@loongsuite/otel-util-genai 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,262 @@
+# @loongsuite/otel-util-genai
+
+OpenTelemetry GenAI utility library for Node.js — standardized telemetry collection for Generative AI operations including LLM, Agent, Embedding, Tool, Retrieval, Rerank, Memory, Entry, and ReAct Step.
+
+This is the Node.js equivalent of the Python `opentelemetry-util-genai` package, following the same semantic conventions and API design patterns.
+
+## Installation
+
+```bash
+npm install @loongsuite/otel-util-genai
+```
+
+## Features
+
+- **LLM (Chat/Completion)**: Track LLM requests with full message content, token usage, and streaming TTFT
+- **Agent**: Create and invoke agents with tool definitions and conversation context
+- **Embedding**: Monitor embedding generation with dimension counts and encoding formats
+- **Tool Execution**: Trace tool calls with arguments and results
+- **Retrieval**: Observe document retrieval from vector stores with query and results
+- **Rerank**: Track document reranking operations with scoring details
+- **Memory**: Record memory operations (add, search, update, delete, etc.)
+- **Entry**: Mark AI application system entry points with session/user context
+- **ReAct Step**: Track individual Reasoning-Acting iterations in agents
+
+## Quick Start
+
+### Using TelemetryHandler (LLM only)
+
+```typescript
+import {
+  TelemetryHandler,
+  createLLMInvocation,
+} from "@loongsuite/otel-util-genai";
+
+const handler = new TelemetryHandler();
+
+// Callback pattern (recommended)
+await handler.llm(
+  createLLMInvocation({
+    requestModel: "gpt-4",
+    provider: "openai",
+    inputMessages: [
+      { role: "user", parts: [{ type: "text", content: "Hello!" }] },
+    ],
+  }),
+  async (inv) => {
+    // Call your LLM API here...
+    inv.outputMessages = [
+      {
+        role: "assistant",
+        parts: [{ type: "text", content: "Hi there!" }],
+        finishReason: "stop",
+      },
+    ];
+    inv.inputTokens = 5;
+    inv.outputTokens = 10;
+  },
+);
+
+// Or manual start/stop pattern
+const inv = createLLMInvocation({ requestModel: "gpt-4", provider: "openai" });
+handler.startLlm(inv);
+try {
+  // Call your LLM API...
+  inv.inputTokens = 5;
+  inv.outputTokens = 10;
+  handler.stopLlm(inv);
+} catch (err) {
+  handler.failLlm(inv, {
+    message: String(err),
+    type: err instanceof Error ? err.constructor.name : "Error",
+  });
+}
+```
+
+### Using ExtendedTelemetryHandler (All operations)
+
+```typescript
+import {
+  ExtendedTelemetryHandler,
+  createEmbeddingInvocation,
+  createRetrievalInvocation,
+  createInvokeAgentInvocation,
+  createMemoryInvocation,
+} from "@loongsuite/otel-util-genai";
+
+const handler = new ExtendedTelemetryHandler();
+
+// Embedding
+handler.embedding(
+  createEmbeddingInvocation("text-embedding-3-small"),
+  (inv) => {
+    inv.inputTokens = 100;
+    inv.dimensionCount = 1536;
+  },
+);
+
+// Retrieval
+handler.retrieval(
+  createRetrievalInvocation({ dataSourceId: "my_vector_store", topK: 5 }),
+  (inv) => {
+    inv.documents = [
+      { id: "doc1", score: 0.95, content: "..." },
+      { id: "doc2", score: 0.87, content: "..." },
+    ];
+  },
+);
+
+// Agent
+await handler.invokeAgent(
+  createInvokeAgentInvocation("openai", { agentName: "research-agent" }),
+  async (inv) => {
+    // ... agent invocation
+    inv.inputTokens = 500;
+    inv.outputTokens = 200;
+  },
+);
+
+// Memory
+handler.memory(createMemoryInvocation("search", { userId: "user-1" }), (inv) => {
+  inv.outputMessages = [{ content: "remembered context" }];
+});
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|---|---|---|
+| `OTEL_SEMCONV_STABILITY_OPT_IN` | Set to `gen_ai_latest_experimental` to enable experimental features | - |
+| `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` | Content capturing mode: `NO_CONTENT`, `SPAN_ONLY`, `EVENT_ONLY`, `SPAN_AND_EVENT` | `NO_CONTENT` |
+| `OTEL_INSTRUMENTATION_GENAI_EMIT_EVENT` | Whether to emit `gen_ai.client.inference.operation.details` events: `true`/`false` | Based on content mode |
+
+## Supported Operation Types
+
+| Operation | Span Kind | `gen_ai.operation.name` | Handler Method |
+|---|---|---|---|
+| LLM Chat | LLM | `chat` | `llm()` / `startLlm()` |
+| Create Agent | AGENT | `create_agent` | `createAgent()` / `startCreateAgent()` |
+| Invoke Agent | AGENT | `invoke_agent` | `invokeAgent()` / `startInvokeAgent()` |
+| Embedding | EMBEDDING | `embeddings` | `embedding()` / `startEmbedding()` |
+| Execute Tool | TOOL | `execute_tool` | `executeTool()` / `startExecuteTool()` |
+| Retrieval | RETRIEVER | `retrieval` | `retrieval()` / `startRetrieval()` |
+| Rerank | RERANKER | `rerank_documents` | `rerank()` / `startRerank()` |
+| Memory | MEMORY | `memory_operation` | `memory()` / `startMemory()` |
+| Entry | ENTRY | `enter` | `entry()` / `startEntry()` |
+| ReAct Step | STEP | `react` | `reactStep()` / `startReactStep()` |
+
+## Semantic Conventions
+
+This library follows the [OpenTelemetry GenAI Semantic Conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/) with LoongSuite extensions for:
+
+- `gen_ai.span.kind` — Logical span kind classification
+- Extended operation names (`retrieval`, `rerank_documents`, `enter`, `react`)
+- Memory operation attributes (`gen_ai.memory.*`)
+- Cache token usage (`gen_ai.usage.cache_creation.input_tokens`, `gen_ai.usage.cache_read.input_tokens`)
+- Total token calculation (`gen_ai.usage.total_tokens`)
+- Time to first token (`gen_ai.response.time_to_first_token`)
+
+## API Reference
+
+### Core Classes
+
+- **`TelemetryHandler`** — Manages LLM invocation lifecycles with span, metrics, and event emission
+- **`ExtendedTelemetryHandler`** — Extends `TelemetryHandler` with support for all GenAI operation types
+
+### Factory Functions
+
+- `createLLMInvocation(init?)` — Create an LLM invocation with defaults
+- `createEmbeddingInvocation(requestModel, init?)` — Create an embedding invocation
+- `createExecuteToolInvocation(toolName, init?)` — Create a tool execution invocation
+- `createCreateAgentInvocation(provider, init?)` — Create an agent creation invocation
+- `createInvokeAgentInvocation(provider, init?)` — Create an agent invocation
+- `createRetrievalInvocation(init?)` — Create a retrieval invocation
+- `createRerankInvocation(provider, init?)` — Create a rerank invocation
+- `createMemoryInvocation(operation, init?)` — Create a memory invocation
+- `createEntryInvocation(init?)` — Create an entry invocation
+- `createReactStepInvocation(init?)` — Create a ReAct step invocation
+
+### Singleton Accessors
+
+- `getTelemetryHandler(options?)` — Get or create the default `TelemetryHandler`
+- `getExtendedTelemetryHandler(options?)` — Get or create the default `ExtendedTelemetryHandler`
+
+## Event Log → Trace conversion
+
+The package can convert a flat list of records that follow the
+[loongsuite-pilot AI event schema](https://github.com/alibaba/loongsuite-pilot)
+into an OTel span tree (`ENTRY → AGENT → STEP → LLM/TOOL`) that satisfies the
+ARMS GenAI semantic conventions. This lets agent plugins keep emitting only
+event logs and delegate trace shape to this SDK.
+
+```ts
+import { readFileSync } from "node:fs";
+import {
+  BasicTracerProvider,
+  BatchSpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import {
+  ExtendedTelemetryHandler,
+  convertEventLogToTrace,
+} from "@loongsuite/otel-util-genai";
+
+const provider = new BasicTracerProvider({
+  spanProcessors: [new BatchSpanProcessor(new OTLPTraceExporter())],
+});
+const handler = new ExtendedTelemetryHandler({ tracerProvider: provider });
+
+const records = JSON.parse(readFileSync("turn-events.json", "utf-8"));
+const { traceIds, spanCount, warnings } = convertEventLogToTrace(records, {
+  handler,
+  strict: false,
+});
+await provider.forceFlush();
+
+console.log(`Exported ${spanCount} spans across ${traceIds.length} traces`);
+if (warnings.length) console.warn(warnings);
+```
+
+### Helper: returning `ReadableSpan[]` directly
+
+If you don't already own a TracerProvider — for example you're building a
+downstream pilot/exporter that needs the span data as values to feed into
+your own `OTLPTraceExporter` — use the helper:
+
+```ts
+import { convertEventLogToReadableSpans } from "@loongsuite/otel-util-genai";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+
+const exporter = new OTLPTraceExporter({ url, headers });
+const { spans, traceIds, warnings } = await convertEventLogToReadableSpans(records);
+exporter.export(spans, (result) => {
+  if (result.code !== 0) console.error("export failed", result.error);
+});
+```
+
+The helper internally spins up a private `BasicTracerProvider` +
+`InMemorySpanExporter`, runs the conversion, captures finished spans, and
+tears the provider down. It is never registered globally, so it cannot
+pollute the host process's OTel context. Requires
+`@opentelemetry/sdk-trace-base` at runtime (declared as an optional peer
+dep — install it in the consumer package).
+
+### Behavior summary
+
+- Records are grouped by `gen_ai.turn.id` (one OTel trace per turn) then by
+  `gen_ai.step.id` (one STEP span per step).
+- Each `llm.request` + `llm.response` pair becomes one LLM span; each
+  `tool.call` + `tool.result` pair becomes one TOOL span.
+- `trace_id` on the records is honored — generated spans inherit it via a
+  synthetic parent context. If `trace_id` is missing the SDK allocates one.
+- `gen_ai.input.messages_delta` is accumulated across the whole turn to
+  reconstruct full `gen_ai.input.messages` for each LLM span.
+- `strict: true` throws `EventLogConversionError` on the first issue;
+  otherwise non-fatal problems are returned in `warnings`.
+
+For downstream consumers (e.g. loongsuite-pilot's OTLP trace flusher), see
+[`PILOT_INTEGRATION.md`](./PILOT_INTEGRATION.md) for a full walkthrough.
+
+## License
+
+Apache License 2.0

package/dist/environment-variables.d.ts

@@ -0,0 +1,8 @@
+export declare const OTEL_SEMCONV_STABILITY_OPT_IN = "OTEL_SEMCONV_STABILITY_OPT_IN";
+export declare const OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT";
+export declare const OTEL_INSTRUMENTATION_GENAI_EMIT_EVENT = "OTEL_INSTRUMENTATION_GENAI_EMIT_EVENT";
+export declare const OTEL_INSTRUMENTATION_GENAI_COMPLETION_HOOK = "OTEL_INSTRUMENTATION_GENAI_COMPLETION_HOOK";
+export declare const OTEL_INSTRUMENTATION_GENAI_UPLOAD_BASE_PATH = "OTEL_INSTRUMENTATION_GENAI_UPLOAD_BASE_PATH";
+export declare const OTEL_INSTRUMENTATION_GENAI_UPLOAD_FORMAT = "OTEL_INSTRUMENTATION_GENAI_UPLOAD_FORMAT";
+export declare const OTEL_INSTRUMENTATION_GENAI_UPLOAD_MAX_QUEUE_SIZE = "OTEL_INSTRUMENTATION_GENAI_UPLOAD_MAX_QUEUE_SIZE";
+//# sourceMappingURL=environment-variables.d.ts.map

package/dist/environment-variables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment-variables.d.ts","sourceRoot":"","sources":["../src/environment-variables.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,6BAA6B,kCAAkC,CAAC;AAC7E,eAAO,MAAM,kDAAkD,uDACT,CAAC;AACvD,eAAO,MAAM,qCAAqC,0CACT,CAAC;AAC1C,eAAO,MAAM,0CAA0C,+CACT,CAAC;AAC/C,eAAO,MAAM,2CAA2C,gDACT,CAAC;AAChD,eAAO,MAAM,wCAAwC,6CACT,CAAC;AAC7C,eAAO,MAAM,gDAAgD,qDACT,CAAC"}

package/dist/environment-variables.js

@@ -0,0 +1,21 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+export const OTEL_SEMCONV_STABILITY_OPT_IN = "OTEL_SEMCONV_STABILITY_OPT_IN";
+export const OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT";
+export const OTEL_INSTRUMENTATION_GENAI_EMIT_EVENT = "OTEL_INSTRUMENTATION_GENAI_EMIT_EVENT";
+export const OTEL_INSTRUMENTATION_GENAI_COMPLETION_HOOK = "OTEL_INSTRUMENTATION_GENAI_COMPLETION_HOOK";
+export const OTEL_INSTRUMENTATION_GENAI_UPLOAD_BASE_PATH = "OTEL_INSTRUMENTATION_GENAI_UPLOAD_BASE_PATH";
+export const OTEL_INSTRUMENTATION_GENAI_UPLOAD_FORMAT = "OTEL_INSTRUMENTATION_GENAI_UPLOAD_FORMAT";
+export const OTEL_INSTRUMENTATION_GENAI_UPLOAD_MAX_QUEUE_SIZE = "OTEL_INSTRUMENTATION_GENAI_UPLOAD_MAX_QUEUE_SIZE";
+//# sourceMappingURL=environment-variables.js.map

package/dist/environment-variables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment-variables.js","sourceRoot":"","sources":["../src/environment-variables.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AAEjC,MAAM,CAAC,MAAM,6BAA6B,GAAG,+BAA+B,CAAC;AAC7E,MAAM,CAAC,MAAM,kDAAkD,GAC7D,oDAAoD,CAAC;AACvD,MAAM,CAAC,MAAM,qCAAqC,GAChD,uCAAuC,CAAC;AAC1C,MAAM,CAAC,MAAM,0CAA0C,GACrD,4CAA4C,CAAC;AAC/C,MAAM,CAAC,MAAM,2CAA2C,GACtD,6CAA6C,CAAC;AAChD,MAAM,CAAC,MAAM,wCAAwC,GACnD,0CAA0C,CAAC;AAC7C,MAAM,CAAC,MAAM,gDAAgD,GAC3D,kDAAkD,CAAC"}

package/dist/event-log/converter.d.ts

@@ -0,0 +1,19 @@
+import { type ConvertOptions, type ConvertResult, type EventLogRecord } from "./types.js";
+export { EventName } from "./types.js";
+/**
+ * Convert a flat event log into OTel spans using the supplied handler.
+ *
+ * Span hierarchy produced per turn (matches ARMS GenAI semantic conventions):
+ *
+ *   ENTRY
+ *    └── AGENT
+ *         └── STEP (one per gen_ai.step.id)
+ *              ├── LLM (one per llm.request+llm.response pair)
+ *              └── TOOL (one per tool.call+tool.result pair)
+ *
+ * trace_id from the event log is honored — all spans of a turn inherit it via
+ * a synthetic parent SpanContext. If trace_id is missing or invalid, the SDK
+ * allocates a fresh one.
+ */
+export declare function convertEventLogToTrace(records: EventLogRecord[], options?: ConvertOptions): ConvertResult;
+//# sourceMappingURL=converter.d.ts.map

package/dist/event-log/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../src/event-log/converter.ts"],"names":[],"mappings":"AAiBA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EAKpB,MAAM,YAAY,CAAC;AAsBpB,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,cAAc,EAAE,EACzB,OAAO,CAAC,EAAE,cAAc,GACvB,aAAa,CA4Bf"}