@runtypelabs/flue-otel 0.1.0

package/dist/index.cjs

@@ -0,0 +1,939 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ADAPTER_NAME: () => ADAPTER_NAME,
+  ADAPTER_VERSION: () => ADAPTER_VERSION,
+  GEN_AI: () => GEN_AI,
+  RUNTYPE: () => RUNTYPE,
+  RUNTYPE_FLUE_INSTRUMENTATION_KEY: () => RUNTYPE_FLUE_INSTRUMENTATION_KEY,
+  RUNTYPE_SCHEMA_VERSION: () => RUNTYPE_SCHEMA_VERSION,
+  RUNTYPE_STOP_REASONS: () => RUNTYPE_STOP_REASONS,
+  RUNTYPE_TOOL_TYPES: () => RUNTYPE_TOOL_TYPES,
+  createRuntypeFlueInstrumentation: () => createRuntypeFlueInstrumentation,
+  runtypeFlueResourceAttributes: () => runtypeFlueResourceAttributes
+});
+module.exports = __toCommonJS(index_exports);
+var import_api2 = require("@opentelemetry/api");
+
+// src/compat.ts
+function resolveToolType(toolName, detail) {
+  if (isTaskDelegationTool(toolName, detail)) return "subagent";
+  if (detail.toolType === "datastore") return "data_connection";
+  return void 0;
+}
+function isTaskDelegationTool(toolName, detail) {
+  return detail.origin === "framework" && toolName === "task";
+}
+function isCallerShellCall(toolName, detail) {
+  return detail.origin === "caller" && toolName === "bash";
+}
+function mapFinishReason(finishReason) {
+  if (!finishReason) return void 0;
+  const normalized = finishReason.toLowerCase().replace(/[\s-]+/g, "_");
+  if (END_TURN_REASONS.has(normalized)) return "end_turn";
+  if (LENGTH_REASONS.has(normalized)) return "length";
+  if (CONTENT_FILTER_REASONS.has(normalized)) return "content_filter";
+  if (ERROR_REASONS.has(normalized)) return "error";
+  return "unknown";
+}
+var END_TURN_REASONS = /* @__PURE__ */ new Set([
+  "stop",
+  "end_turn",
+  "stop_sequence",
+  "complete",
+  "completed"
+]);
+var LENGTH_REASONS = /* @__PURE__ */ new Set(["length", "max_tokens", "maxtokens"]);
+var CONTENT_FILTER_REASONS = /* @__PURE__ */ new Set([
+  "content_filter",
+  "contentfilter",
+  "refusal",
+  "safety"
+]);
+var ERROR_REASONS = /* @__PURE__ */ new Set(["error", "aborted", "abort", "cancelled"]);
+function mapSettlementOutcome(outcome) {
+  if (outcome === "failed" || outcome === "aborted") return "error";
+  return void 0;
+}
+
+// package.json
+var version = "0.1.0";
+
+// src/semconv.ts
+var GEN_AI = {
+  operationName: "gen_ai.operation.name",
+  providerName: "gen_ai.provider.name",
+  agentName: "gen_ai.agent.name",
+  conversationId: "gen_ai.conversation.id",
+  requestModel: "gen_ai.request.model",
+  responseModel: "gen_ai.response.model",
+  responseId: "gen_ai.response.id",
+  requestStream: "gen_ai.request.stream",
+  reasoningLevel: "gen_ai.request.reasoning.level",
+  maxTokens: "gen_ai.request.max_tokens",
+  temperature: "gen_ai.request.temperature",
+  finishReasons: "gen_ai.response.finish_reasons",
+  usageInputTokens: "gen_ai.usage.input_tokens",
+  usageOutputTokens: "gen_ai.usage.output_tokens",
+  usageCacheReadTokens: "gen_ai.usage.cache_read.input_tokens",
+  usageCacheCreationTokens: "gen_ai.usage.cache_creation.input_tokens",
+  toolName: "gen_ai.tool.name",
+  toolCallId: "gen_ai.tool.call.id",
+  toolType: "gen_ai.tool.type",
+  conversationCompacted: "gen_ai.conversation.compacted",
+  errorType: "error.type",
+  serverAddress: "server.address",
+  serverPort: "server.port"
+};
+var GEN_AI_OPERATION_INVOKE_AGENT = "invoke_agent";
+var GEN_AI_OPERATION_CHAT = "chat";
+var GEN_AI_OPERATION_EXECUTE_TOOL = "execute_tool";
+var RUNTYPE = {
+  agentId: "runtype.agent.id",
+  schemaVersion: "runtype.schema.version",
+  adapterName: "runtype.adapter.name",
+  adapterVersion: "runtype.adapter.version",
+  executionId: "runtype.execution.id",
+  iteration: "runtype.iteration",
+  stopReason: "runtype.stop_reason",
+  toolsReported: "runtype.tools.reported",
+  toolType: "runtype.tool.type",
+  turnId: "runtype.turn.id",
+  turnIndex: "runtype.turn.index"
+};
+var FLUE = {
+  instanceId: "flue.instance.id",
+  submissionId: "flue.submission.id",
+  agentName: "flue.agent.name",
+  harnessName: "flue.harness.name",
+  sessionName: "flue.session.name",
+  parentSessionName: "flue.parent_session.name",
+  operationId: "flue.operation.id",
+  operationKind: "flue.operation.kind",
+  turnId: "flue.turn.id",
+  turnPurpose: "flue.turn.purpose",
+  taskId: "flue.task.id",
+  eventIndex: "flue.event.index",
+  toolOrigin: "flue.tool.origin",
+  compactionReason: "flue.compaction.reason",
+  usageTotalTokens: "flue.usage.total_tokens"
+};
+var RUNTYPE_TOOL_TYPES = [
+  "flow",
+  "mcp",
+  "builtin",
+  "custom",
+  "external",
+  "advisor",
+  "subagent",
+  "local",
+  "data_connection",
+  "search"
+];
+var RUNTYPE_STOP_REASONS = [
+  "end_turn",
+  "max_tool_calls",
+  "length",
+  "content_filter",
+  "error",
+  "unknown"
+];
+var RUNTYPE_SCHEMA_VERSION = "1";
+var ADAPTER_NAME = "@runtypelabs/flue-otel";
+var ADAPTER_VERSION = version;
+
+// src/projection.ts
+function runtypeFlueResourceAttributes(resource) {
+  return {
+    [RUNTYPE.schemaVersion]: RUNTYPE_SCHEMA_VERSION,
+    [RUNTYPE.adapterName]: ADAPTER_NAME,
+    [RUNTYPE.adapterVersion]: ADAPTER_VERSION,
+    ...resource?.agentId ? { [RUNTYPE.agentId]: resource.agentId } : {}
+  };
+}
+function createFlueProjection(options = {}) {
+  const open = /* @__PURE__ */ new Map();
+  const envelopes = /* @__PURE__ */ new Map();
+  const envelopeByChain = /* @__PURE__ */ new Map();
+  const envelopeBySubmission = /* @__PURE__ */ new Map();
+  const envelopeByOperationId = /* @__PURE__ */ new Map();
+  const envelopeByTaskScope = /* @__PURE__ */ new Map();
+  const turnPositions = /* @__PURE__ */ new Map();
+  const taskTurnCounts = /* @__PURE__ */ new Map();
+  function observe(observation) {
+    switch (observation.type) {
+      case "operation_start":
+        return onOperationStart(observation);
+      case "operation":
+        return onOperationEnd(observation);
+      case "task_start":
+        return onTaskStart(observation);
+      case "task":
+        return onTaskEnd(observation);
+      case "compaction_start":
+        return onCompactionStart(observation);
+      case "compaction":
+        return onCompactionEnd(observation);
+      case "turn_request":
+        return onTurnRequest(observation);
+      case "turn":
+        return onTurnEnd(observation);
+      case "tool_start":
+        return onToolStart(observation);
+      case "tool":
+        return onToolEnd(observation);
+      case "submission_settled":
+        return onSubmissionSettled(observation);
+      default:
+        return [];
+    }
+  }
+  function onOperationStart(event) {
+    const kind = readString(event, "operationKind");
+    if (kind !== "prompt" && kind !== "skill") return [];
+    const ref = operationKey(event);
+    if (open.has(ref)) return [];
+    if (event.taskId && open.has(taskKey(event))) return [];
+    const parentRef = resolveParentRef(event);
+    const chain = chainKey(event);
+    const isEnvelope = !envelopeByChain.has(chain);
+    if (isEnvelope) {
+      envelopeByChain.set(chain, ref);
+      if (event.submissionId) envelopeBySubmission.set(event.submissionId, ref);
+      if (event.operationId) envelopeByOperationId.set(event.operationId, ref);
+      envelopes.set(ref, freshEnvelope());
+    }
+    open.set(ref, {
+      ref,
+      ...parentRef ? { parentRef } : {},
+      chainKey: chain,
+      isTask: false,
+      ...isEnvelope ? {
+        scope: {
+          instanceId: event.instanceId,
+          harness: event.harness,
+          conversationId: event.conversationId,
+          session: event.session
+        }
+      } : {}
+    });
+    const agentId = event.agentName ? options.agents?.[event.agentName] : void 0;
+    return [
+      {
+        kind: "open",
+        ref,
+        name: isEnvelope ? event.agentName ? `invoke_agent ${event.agentName}` : "invoke_agent" : `flue.operation ${kind}`,
+        spanKind: "internal",
+        ...parentRef ? { parentRef } : {},
+        ...event.timestamp ? { startTime: event.timestamp } : {},
+        attributes: {
+          ...identifiers(event),
+          [FLUE.operationKind]: kind,
+          ...isEnvelope ? { [GEN_AI.operationName]: GEN_AI_OPERATION_INVOKE_AGENT } : {},
+          ...isEnvelope && event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
+          ...isEnvelope && event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
+          // The execution id LIFTS the tier and is claim-checked at ingest like
+          // any inbound id; it does not key the row, which stays derived from
+          // the trace id.
+          ...isEnvelope && event.submissionId ? { [RUNTYPE.executionId]: event.submissionId } : {},
+          ...isEnvelope && agentId ? { [RUNTYPE.agentId]: agentId } : {}
+        }
+      }
+    ];
+  }
+  function onOperationEnd(event) {
+    const ref = operationKey(event);
+    const record = open.get(ref);
+    if (!record) return [];
+    const intents = sweepDescendants(ref, event.timestamp);
+    const envelope = envelopes.get(ref);
+    const isError = readBoolean(event, "isError") === true;
+    if (envelope) {
+      intents.push({ kind: "update", ref, attributes: envelopeAttributes(envelope, isError) });
+      envelopes.delete(ref);
+      if (envelopeByChain.get(record.chainKey) === ref) envelopeByChain.delete(record.chainKey);
+      for (const [submissionId, submissionRef] of envelopeBySubmission) {
+        if (submissionRef === ref) envelopeBySubmission.delete(submissionId);
+      }
+      for (const [operationId, operationRef] of envelopeByOperationId) {
+        if (operationRef === ref) envelopeByOperationId.delete(operationId);
+      }
+      for (const [taskScope, taskEnvelopeRef] of envelopeByTaskScope) {
+        if (taskEnvelopeRef === ref) envelopeByTaskScope.delete(taskScope);
+      }
+      for (const [key, position] of turnPositions) {
+        if (position.envelopeRef === ref) turnPositions.delete(key);
+      }
+    }
+    intents.push(closeIntent(ref, event, isError, readErrorInfo(event)));
+    open.delete(ref);
+    return intents;
+  }
+  function onTaskStart(event) {
+    const ref = taskKey(event);
+    if (open.has(ref)) return [];
+    const envelopeRef = event.operationId ? envelopeByOperationId.get(event.operationId) : void 0;
+    if (envelopeRef) envelopeByTaskScope.set(ref, envelopeRef);
+    const callerScope = {
+      ...envelopeRef ? open.get(envelopeRef)?.scope ?? {} : {},
+      operationId: event.operationId,
+      turnId: event.turnId,
+      toolCallId: event.toolCallId
+    };
+    const parentRef = resolveParentRef(callerScope) ?? envelopeRef;
+    open.set(ref, {
+      ref,
+      ...parentRef ? { parentRef } : {},
+      chainKey: chainKey(event),
+      isTask: true
+    });
+    taskTurnCounts.set(ref, 0);
+    const agent = readString(event, "agent");
+    return [
+      {
+        kind: "open",
+        ref,
+        // Deliberately NOT `invoke_agent`: see this module's header. A second
+        // agent-invocation span in the trace is a coin flip over which one
+        // becomes the run's envelope.
+        name: agent ? `flue.task ${agent}` : "flue.task",
+        spanKind: "internal",
+        ...parentRef ? { parentRef } : {},
+        ...event.timestamp ? { startTime: event.timestamp } : {},
+        attributes: {
+          ...identifiers(event),
+          ...agent ? { [GEN_AI.agentName]: agent } : {}
+        }
+      }
+    ];
+  }
+  function onTaskEnd(event) {
+    const ref = taskKey(event);
+    if (!open.has(ref)) return [];
+    const intents = sweepDescendants(ref, event.timestamp);
+    intents.push(
+      closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event))
+    );
+    open.delete(ref);
+    taskTurnCounts.delete(ref);
+    return intents;
+  }
+  function onCompactionStart(event) {
+    const ref = compactionKey(event);
+    if (open.has(ref)) return [];
+    const parentRef = resolveParentRef(event);
+    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    const reason = readString(event, "reason");
+    return [
+      {
+        kind: "open",
+        ref,
+        name: "flue.compaction",
+        spanKind: "internal",
+        // `session.compact()` is callable by the host outside any turn, and a
+        // `compact` operation is not intercepted, so this can be parentless.
+        requiresParent: true,
+        ...parentRef ? { parentRef } : {},
+        ...event.timestamp ? { startTime: event.timestamp } : {},
+        attributes: {
+          ...identifiers(event),
+          ...reason ? { [FLUE.compactionReason]: reason } : {}
+        }
+      }
+    ];
+  }
+  function onCompactionEnd(event) {
+    const ref = compactionKey(event);
+    if (!open.has(ref)) return [];
+    const intents = sweepDescendants(ref, event.timestamp);
+    intents.push(
+      closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event))
+    );
+    open.delete(ref);
+    return intents;
+  }
+  function onTurnRequest(event) {
+    const ref = turnKey(event);
+    if (open.has(ref)) return [];
+    const request = readRecord(event, "request");
+    if (!request) return [];
+    const purpose = readString(event, "purpose") ?? "agent";
+    const compactionRef = compactionKey(event);
+    const parentRef = purpose !== "agent" && open.has(compactionRef) ? compactionRef : resolveParentRef(event);
+    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    const envelopeRef = resolveEnvelopeRef(event);
+    const envelope = envelopeRef ? envelopes.get(envelopeRef) : void 0;
+    let position;
+    if (purpose === "agent") {
+      if (!event.taskId && envelope && envelopeRef) {
+        position = {
+          turnId: event.turnId ?? "",
+          index: envelope.turnCount,
+          atEnvelopeScope: true,
+          envelopeRef
+        };
+        envelope.turnCount += 1;
+        envelope.maxIteration = position.index;
+      } else if (event.taskId) {
+        const taskRef = taskKey(event);
+        const index = taskTurnCounts.get(taskRef) ?? 0;
+        taskTurnCounts.set(taskRef, index + 1);
+        position = {
+          turnId: event.turnId ?? "",
+          index,
+          atEnvelopeScope: false,
+          ...envelopeRef ? { envelopeRef } : {}
+        };
+      }
+      if (position) turnPositions.set(ref, position);
+    }
+    if (envelope) {
+      if (!envelope.modelPinned && purpose === "agent") envelope.requestModel = request.requestedModel;
+      if (Array.isArray(request.input?.tools)) envelope.toolsReported = true;
+    }
+    return [
+      {
+        kind: "open",
+        ref,
+        name: request.requestedModel ? `${GEN_AI_OPERATION_CHAT} ${request.requestedModel}` : GEN_AI_OPERATION_CHAT,
+        spanKind: "client",
+        ...parentRef ? { parentRef } : {},
+        ...event.timestamp ? { startTime: event.timestamp } : {},
+        attributes: {
+          ...identifiers(event),
+          [GEN_AI.operationName]: GEN_AI_OPERATION_CHAT,
+          [FLUE.turnPurpose]: purpose,
+          ...request.providerName ? { [GEN_AI.providerName]: request.providerName } : {},
+          ...request.requestedModel ? { [GEN_AI.requestModel]: request.requestedModel } : {},
+          ...event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
+          ...event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
+          ...request.reasoningLevel ? { [GEN_AI.reasoningLevel]: request.reasoningLevel } : {},
+          ...typeof request.maxTokens === "number" ? { [GEN_AI.maxTokens]: request.maxTokens } : {},
+          ...typeof request.temperature === "number" ? { [GEN_AI.temperature]: request.temperature } : {},
+          ...request.serverAddress ? { [GEN_AI.serverAddress]: request.serverAddress } : {},
+          ...typeof request.serverPort === "number" ? { [GEN_AI.serverPort]: request.serverPort } : {},
+          ...request.contextCompacted ? { [GEN_AI.conversationCompacted]: true } : {},
+          ...positionAttributes(position)
+        }
+      }
+    ];
+  }
+  function onTurnEnd(event) {
+    const ref = turnKey(event);
+    if (!open.has(ref)) return [];
+    const response = readRecord(event, "response") ?? {};
+    const purpose = readString(event, "purpose") ?? "agent";
+    const isError = readBoolean(event, "isError") === true;
+    const envelopeRef = resolveEnvelopeRef(event);
+    const envelope = envelopeRef ? envelopes.get(envelopeRef) : void 0;
+    if (envelope) {
+      if (!envelope.modelPinned && purpose === "agent") {
+        envelope.responseModel = response.responseModel;
+        envelope.modelPinned = true;
+      }
+      foldUsage(envelope, response.usage);
+      if (purpose === "agent" && response.finishReason) {
+        envelope.lastFinishReason = response.finishReason;
+      }
+    }
+    const attributes = {
+      ...response.responseModel ? { [GEN_AI.responseModel]: response.responseModel } : {},
+      ...response.responseId ? { [GEN_AI.responseId]: response.responseId } : {},
+      ...response.finishReason ? { [GEN_AI.finishReasons]: [response.finishReason] } : {},
+      ...usageAttributes(response.usage)
+    };
+    const intents = [];
+    if (Object.keys(attributes).length > 0) intents.push({ kind: "update", ref, attributes });
+    intents.push(closeIntent(ref, event, isError, response.error ?? readErrorInfo(event)));
+    open.delete(ref);
+    return intents;
+  }
+  function onToolStart(event) {
+    const toolName = readString(event, "toolName");
+    const toolCallId = readString(event, "toolCallId");
+    if (!toolName || !toolCallId) return [];
+    const ref = toolKey(event);
+    if (open.has(ref)) return [];
+    const parentRef = resolveParentRef(event);
+    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    const position = turnPositions.get(turnKey(event));
+    if (isCallerShellCall(toolName, event)) {
+      return [
+        {
+          kind: "open",
+          ref,
+          name: "flue.operation shell",
+          spanKind: "internal",
+          // `session.shell()` is callable by the host outside any turn, and a
+          // `shell` operation is not intercepted, so this can be parentless.
+          requiresParent: true,
+          ...parentRef ? { parentRef } : {},
+          ...event.timestamp ? { startTime: event.timestamp } : {},
+          attributes: {
+            ...identifiers(event),
+            ...event.origin ? { [FLUE.toolOrigin]: event.origin } : {},
+            ...positionAttributes(position)
+          }
+        }
+      ];
+    }
+    const isDelegation = isTaskDelegationTool(toolName, event);
+    const toolType = resolveToolType(toolName, event);
+    return [
+      {
+        kind: "open",
+        ref,
+        name: `${GEN_AI_OPERATION_EXECUTE_TOOL} ${toolName}`,
+        spanKind: "internal",
+        ...parentRef ? { parentRef } : {},
+        ...event.timestamp ? { startTime: event.timestamp } : {},
+        attributes: {
+          ...identifiers(event),
+          [GEN_AI.operationName]: GEN_AI_OPERATION_EXECUTE_TOOL,
+          [GEN_AI.toolName]: toolName,
+          [GEN_AI.toolCallId]: toolCallId,
+          // The semconv `gen_ai.tool.type` domain is the transport-level one
+          // (`function` / `extension` / `datastore`); a sub-agent delegation is
+          // not a plain function call, so it is left unclaimed there while
+          // `runtype.tool.type` says what it actually is.
+          ...isDelegation ? {} : { [GEN_AI.toolType]: "function" },
+          ...toolType ? { [RUNTYPE.toolType]: toolType } : {},
+          ...event.origin ? { [FLUE.toolOrigin]: event.origin } : {},
+          ...event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
+          ...event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
+          ...positionAttributes(position)
+        }
+      }
+    ];
+  }
+  function onToolEnd(event) {
+    const ref = toolKey(event);
+    if (!open.has(ref)) return [];
+    const intents = sweepDescendants(ref, event.timestamp);
+    intents.push(
+      closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event))
+    );
+    open.delete(ref);
+    return intents;
+  }
+  function onSubmissionSettled(event) {
+    const outcome = readString(event, "outcome");
+    if (!outcome) return [];
+    const stopReason = mapSettlementOutcome(outcome);
+    if (!stopReason) return [];
+    const submissionId = readString(event, "submissionId");
+    if (!submissionId) return [];
+    const ref = envelopeBySubmission.get(submissionId);
+    const envelope = ref ? envelopes.get(ref) : void 0;
+    if (envelope) envelope.settlementStopReason = stopReason;
+    return [];
+  }
+  function envelopeAttributes(envelope, isError) {
+    const stopReason = isError ? "error" : envelope.settlementStopReason ?? mapFinishReason(envelope.lastFinishReason);
+    return {
+      ...envelope.requestModel ? { [GEN_AI.requestModel]: envelope.requestModel } : {},
+      ...envelope.responseModel ? { [GEN_AI.responseModel]: envelope.responseModel } : {},
+      ...envelope.sawUsage ? {
+        [GEN_AI.usageInputTokens]: envelope.inputTokens,
+        [GEN_AI.usageOutputTokens]: envelope.outputTokens,
+        [GEN_AI.usageCacheReadTokens]: envelope.cacheReadTokens,
+        [GEN_AI.usageCacheCreationTokens]: envelope.cacheCreationTokens
+      } : {},
+      ...stopReason ? { [RUNTYPE.stopReason]: stopReason } : {},
+      ...envelope.toolsReported ? { [RUNTYPE.toolsReported]: true } : {},
+      // The highest loop position reached. Ingest records `max + 1` as the run's
+      // iteration count, so the envelope alone reports it correctly even when
+      // the batch carrying the model turns flushed earlier.
+      ...envelope.maxIteration !== null ? { [RUNTYPE.iteration]: envelope.maxIteration } : {}
+    };
+  }
+  function resolveEnvelopeRef(event) {
+    if (event.taskId) {
+      const viaTask = envelopeByTaskScope.get(taskKey(event));
+      if (viaTask) return viaTask;
+    }
+    return envelopeByChain.get(chainKey(event));
+  }
+  function resolveParentRef(scope) {
+    if (scope.taskId) {
+      const ref = taskKey(scope);
+      if (open.has(ref)) return ref;
+    }
+    if (scope.toolCallId) {
+      const ref = toolKey(scope);
+      if (open.has(ref)) return ref;
+    }
+    if (scope.operationId) {
+      const ref = operationKey(scope);
+      if (open.has(ref)) return ref;
+    }
+    return void 0;
+  }
+  function sweepDescendants(parentRef, endTime) {
+    const doomed = [];
+    const frontier = [parentRef];
+    while (frontier.length > 0) {
+      const current = frontier.pop();
+      for (const record of open.values()) {
+        if (record.parentRef !== current) continue;
+        doomed.push(record.ref);
+        frontier.push(record.ref);
+      }
+    }
+    const intents = [];
+    for (const ref of doomed.reverse()) {
+      const record = open.get(ref);
+      if (!record) continue;
+      intents.push({
+        kind: "close",
+        ref,
+        ...endTime ? { endTime } : {},
+        error: { type: "interrupted" }
+      });
+      open.delete(ref);
+      if (record.isTask) taskTurnCounts.delete(ref);
+    }
+    return intents;
+  }
+  function drain(endTime) {
+    const intents = [];
+    for (const ref of [...open.keys()].reverse()) {
+      const envelope = envelopes.get(ref);
+      if (envelope) {
+        intents.push({ kind: "update", ref, attributes: envelopeAttributes(envelope, true) });
+      }
+      intents.push({
+        kind: "close",
+        ref,
+        ...endTime ? { endTime } : {},
+        error: { type: "interrupted" }
+      });
+    }
+    open.clear();
+    envelopes.clear();
+    envelopeByChain.clear();
+    envelopeBySubmission.clear();
+    envelopeByOperationId.clear();
+    envelopeByTaskScope.clear();
+    turnPositions.clear();
+    taskTurnCounts.clear();
+    return intents;
+  }
+  return { observe, drain, hasOpenSpan: (ref) => open.has(ref) };
+}
+function freshEnvelope() {
+  return {
+    turnCount: 0,
+    maxIteration: null,
+    modelPinned: false,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    sawUsage: false,
+    toolsReported: false
+  };
+}
+function foldUsage(envelope, usage) {
+  if (!usage) return;
+  const input = positiveNumber(usage.input);
+  const output = positiveNumber(usage.output);
+  const cacheRead = positiveNumber(usage.cacheRead);
+  const cacheWrite = positiveNumber(usage.cacheWrite);
+  if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0) return;
+  envelope.sawUsage = true;
+  envelope.inputTokens += input + cacheRead + cacheWrite;
+  envelope.outputTokens += output;
+  envelope.cacheReadTokens += cacheRead;
+  envelope.cacheCreationTokens += cacheWrite;
+}
+function usageAttributes(usage) {
+  if (!usage) return {};
+  const cacheRead = positiveNumber(usage.cacheRead);
+  const cacheWrite = positiveNumber(usage.cacheWrite);
+  return {
+    [GEN_AI.usageInputTokens]: positiveNumber(usage.input) + cacheRead + cacheWrite,
+    [GEN_AI.usageOutputTokens]: positiveNumber(usage.output),
+    [GEN_AI.usageCacheReadTokens]: cacheRead,
+    [GEN_AI.usageCacheCreationTokens]: cacheWrite,
+    ...typeof usage.totalTokens === "number" ? { [FLUE.usageTotalTokens]: usage.totalTokens } : {}
+  };
+}
+function positionAttributes(position) {
+  if (!position) return {};
+  return {
+    ...position.turnId ? { [RUNTYPE.turnId]: position.turnId } : {},
+    [RUNTYPE.turnIndex]: position.index,
+    // Only the root agent's loop has an ITERATION. A delegated sub-agent's
+    // turns would otherwise inflate the run's iteration count, which ingest
+    // computes as the highest position across every span in the trace.
+    ...position.atEnvelopeScope ? { [RUNTYPE.iteration]: position.index } : {}
+  };
+}
+function identifiers(event) {
+  return {
+    ...event.instanceId ? { [FLUE.instanceId]: event.instanceId } : {},
+    ...event.submissionId ? { [FLUE.submissionId]: event.submissionId } : {},
+    ...event.agentName ? { [FLUE.agentName]: event.agentName } : {},
+    ...event.harness ? { [FLUE.harnessName]: event.harness } : {},
+    ...event.session ? { [FLUE.sessionName]: event.session } : {},
+    ...event.parentSession ? { [FLUE.parentSessionName]: event.parentSession } : {},
+    ...event.operationId ? { [FLUE.operationId]: event.operationId } : {},
+    ...event.turnId ? { [FLUE.turnId]: event.turnId } : {},
+    ...event.taskId ? { [FLUE.taskId]: event.taskId } : {},
+    ...typeof event.eventIndex === "number" ? { [FLUE.eventIndex]: event.eventIndex } : {}
+  };
+}
+function closeIntent(ref, event, isError, errorInfo) {
+  return {
+    kind: "close",
+    ref,
+    ...event.timestamp ? { endTime: event.timestamp } : {},
+    ...isError ? {
+      error: {
+        type: errorInfo?.type ?? "_OTHER",
+        // The class NAME only. `errorInfo.message` and `.stack` are content
+        // and this release emits none: a provider message routinely quotes
+        // the prompt back, and a stack ships filesystem layout.
+        ...errorInfo?.name ? { exceptionType: errorInfo.name } : {}
+      }
+    } : {}
+  };
+}
+function readErrorInfo(event) {
+  const detail = event.errorInfo;
+  return detail !== null && typeof detail === "object" ? detail : void 0;
+}
+function readString(event, key) {
+  const value = event[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readBoolean(event, key) {
+  const value = event[key];
+  return typeof value === "boolean" ? value : void 0;
+}
+function readRecord(event, key) {
+  const value = event[key];
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function positiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function chainKey(value) {
+  return identityKey("chain", [value.instanceId, value.harness, value.conversationId, value.session]);
+}
+function operationKey(value) {
+  return identityKey("operation", [
+    value.instanceId,
+    value.harness,
+    value.conversationId,
+    value.session,
+    value.taskId,
+    value.operationId
+  ]);
+}
+function taskKey(value) {
+  return identityKey("task", [
+    value.instanceId,
+    value.harness,
+    value.conversationId,
+    value.session,
+    value.taskId
+  ]);
+}
+function compactionKey(value) {
+  return identityKey("compaction", [
+    value.instanceId,
+    value.harness,
+    value.conversationId,
+    value.session,
+    value.taskId,
+    value.operationId
+  ]);
+}
+function turnKey(value) {
+  return identityKey("turn", [
+    value.instanceId,
+    value.harness,
+    value.conversationId,
+    value.session,
+    value.taskId,
+    value.operationId,
+    value.turnId
+  ]);
+}
+function toolKey(value) {
+  return identityKey("tool", [
+    value.instanceId,
+    value.harness,
+    value.conversationId,
+    value.session,
+    value.taskId,
+    value.operationId,
+    value.turnId,
+    value.toolCallId
+  ]);
+}
+function identityKey(kind, fields) {
+  return JSON.stringify([kind, ...fields.map((value) => value ?? null)]);
+}
+
+// src/spans.ts
+var import_api = require("@opentelemetry/api");
+function createSpanDriver(tracer) {
+  const live = /* @__PURE__ */ new Map();
+  function apply(intents) {
+    for (const intent of intents) {
+      switch (intent.kind) {
+        case "open": {
+          if (live.has(intent.ref)) break;
+          const parent = intent.parentRef ? live.get(intent.parentRef) : void 0;
+          const active = import_api.context.active();
+          const parentContext = parent ? import_api.trace.setSpan(active, parent) : import_api.trace.getSpanContext(active) ? active : void 0;
+          if (parentContext === void 0 && intent.requiresParent) break;
+          const span = tracer.startSpan(
+            intent.name,
+            {
+              kind: intent.spanKind === "client" ? import_api.SpanKind.CLIENT : import_api.SpanKind.INTERNAL,
+              root: parentContext === void 0,
+              ...intent.startTime ? { startTime: toDate(intent.startTime) } : {},
+              attributes: intent.attributes
+            },
+            parentContext
+          );
+          live.set(intent.ref, span);
+          break;
+        }
+        case "update": {
+          live.get(intent.ref)?.setAttributes(intent.attributes);
+          break;
+        }
+        case "close": {
+          const span = live.get(intent.ref);
+          if (!span) break;
+          if (intent.error) {
+            span.setAttribute(GEN_AI.errorType, intent.error.type);
+            span.setStatus({ code: import_api.SpanStatusCode.ERROR });
+            if (intent.error.exceptionType) {
+              span.recordException({ name: intent.error.exceptionType });
+            }
+          }
+          span.end(intent.endTime ? toDate(intent.endTime) : void 0);
+          live.delete(intent.ref);
+          break;
+        }
+      }
+    }
+  }
+  return { apply, spanFor: (ref) => live.get(ref) };
+}
+function contextForOperation(span, carrier) {
+  if (span) return import_api.trace.setSpan(import_api.context.active(), span);
+  if (carrier) {
+    return import_api.propagation.extract(import_api.context.active(), carrier, {
+      keys: () => carrier.tracestate ? ["traceparent", "tracestate"] : ["traceparent"],
+      get: (value, key) => value[key]
+    });
+  }
+  return void 0;
+}
+function toDate(value) {
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+
+// src/index.ts
+var RUNTYPE_FLUE_INSTRUMENTATION_KEY = /* @__PURE__ */ Symbol.for(
+  "@runtypelabs/flue-otel"
+);
+function createRuntypeFlueInstrumentation(options = {}) {
+  const tracer = options.tracer ?? import_api2.trace.getTracer(ADAPTER_NAME);
+  const projection = createFlueProjection(options);
+  const driver = createSpanDriver(tracer);
+  let disposed = false;
+  const observe = (observation) => {
+    if (disposed) return;
+    try {
+      driver.apply(projection.observe(observation));
+    } catch {
+    }
+  };
+  const interceptor = (operation, executionContext, next) => {
+    if (disposed) return next();
+    const span = spanForOperation(operation, executionContext);
+    const active = contextForOperation(span, executionContext.traceCarrier);
+    if (!active) return next();
+    return import_api2.context.with(active, next);
+  };
+  function spanForOperation(operation, executionContext) {
+    switch (operation.type) {
+      case "agent":
+        return driver.spanFor(
+          operationKey({ ...executionContext, operationId: readIdField(operation, "operationId") })
+        );
+      case "model":
+        return driver.spanFor(
+          turnKey({ ...executionContext, turnId: readIdField(operation, "turnId") })
+        );
+      case "tool":
+        return driver.spanFor(
+          toolKey({ ...executionContext, toolCallId: readIdField(operation, "toolCallId") })
+        );
+      case "task":
+        return driver.spanFor(
+          taskKey({ ...executionContext, taskId: readIdField(operation, "taskId") })
+        );
+      default:
+        return void 0;
+    }
+  }
+  return {
+    key: RUNTYPE_FLUE_INSTRUMENTATION_KEY,
+    observe,
+    interceptor,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      try {
+        driver.apply(projection.drain((/* @__PURE__ */ new Date()).toISOString()));
+      } catch {
+      }
+    }
+  };
+}
+function readIdField(operation, key) {
+  const value = operation[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADAPTER_NAME,
+  ADAPTER_VERSION,
+  GEN_AI,
+  RUNTYPE,
+  RUNTYPE_FLUE_INSTRUMENTATION_KEY,
+  RUNTYPE_SCHEMA_VERSION,
+  RUNTYPE_STOP_REASONS,
+  RUNTYPE_TOOL_TYPES,
+  createRuntypeFlueInstrumentation,
+  runtypeFlueResourceAttributes
+});