@cloudbase/agent-observability 0.0.16 → 0.0.18

package/dist/{chunk-ZGEMAYS4.mjs → chunk-AHSI4KTT.mjs}

@@ -1,55 +1,18 @@
+import {
+  OBSERVABILITY_SDK_NAME,
+  OBSERVABILITY_SDK_VERSION,
+  OpenInferenceSpanKind,
+  OtelSpanAttributes,
+  init_constants
+} from "./chunk-5EXUNUGP.mjs";
 import {
   __esm,
   __export,
   __toCommonJS
 } from "./chunk-NFEGQTCC.mjs";
 
-// src/core/constants.ts
-import {
-  SemanticConventions,
-  OpenInferenceSpanKind
-} from "@arizeai/openinference-semantic-conventions";
-var OtelSpanAttributes;
-var init_constants = __esm({
-  "src/core/constants.ts"() {
-    "use strict";
-    OtelSpanAttributes = {
-      // OpenInference - re-export all standard conventions
-      ...SemanticConventions,
-      // AG-Kit Trace attributes (non-standard)
-      TRACE_NAME: "trace.name",
-      TRACE_TAGS: "trace.tags",
-      TRACE_PUBLIC: "trace.public",
-      TRACE_METADATA: "trace.metadata",
-      TRACE_INPUT: "trace.input",
-      TRACE_OUTPUT: "trace.output",
-      // AG-Kit Observation attributes (non-standard)
-      OBSERVATION_TYPE: "observation.type",
-      OBSERVATION_LEVEL: "observation.level",
-      OBSERVATION_STATUS_MESSAGE: "observation.status_message",
-      OBSERVATION_INPUT: "observation.input",
-      OBSERVATION_OUTPUT: "observation.output",
-      OBSERVATION_METADATA: "observation.metadata",
-      // AG-Kit LLM-specific (non-standard)
-      LLM_COMPLETION_START_TIME: "llm.completion_start_time",
-      LLM_MODEL_PARAMETERS: "llm.model_parameters",
-      LLM_USAGE_DETAILS: "llm.usage_details",
-      LLM_COST_DETAILS: "llm.cost_details",
-      // AG-Kit Retriever-specific (non-standard)
-      RETRIEVER_NAME: "retriever.name",
-      RETRIEVER_QUERY: "retriever.query",
-      RETRIEVER_INDEX_ID: "retriever.index_id",
-      RETRIEVER_TOP_K: "retriever.top_k",
-      // AG-Kit General (non-standard)
-      ENVIRONMENT: "environment",
-      RELEASE: "release",
-      VERSION: "version"
-    };
-  }
-});
-
 // src/core/attributes.ts
-import { SemanticConventions as SemanticConventions2 } from "@arizeai/openinference-semantic-conventions";
+import { SemanticConventions } from "@arizeai/openinference-semantic-conventions";
 function createTraceAttributes({
   name,
   userId,
@@ -94,40 +57,53 @@ function createObservationAttributes(type, attributes) {
     modelParameters,
     usageDetails
   } = attributes;
+  const spanKind = OpenInferenceSpanKind[type.toUpperCase()] || "CHAIN";
   const otelAttributes = {
-    [SemanticConventions2.OPENINFERENCE_SPAN_KIND]: type.toUpperCase(),
+    [SemanticConventions.OPENINFERENCE_SPAN_KIND]: spanKind,
     [OtelSpanAttributes.OBSERVATION_TYPE]: type,
     [OtelSpanAttributes.OBSERVATION_LEVEL]: level,
     [OtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
     [OtelSpanAttributes.VERSION]: version,
     // Use OpenInference input.value convention
-    [SemanticConventions2.INPUT_VALUE]: _serialize(input),
-    // Also set legacy agkit.observation.input for compatibility
+    [SemanticConventions.INPUT_VALUE]: _serialize(input),
+    // Also set observation.input for compatibility
     [OtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
     // Use OpenInference output.value convention
-    [SemanticConventions2.OUTPUT_VALUE]: _serialize(output),
-    // Also set legacy agkit.observation.output for compatibility
+    [SemanticConventions.OUTPUT_VALUE]: _serialize(output),
+    // Also set observation.output for compatibility
     [OtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output)
   };
   if (type === "llm") {
     if (model) {
-      otelAttributes[SemanticConventions2.LLM_MODEL_NAME] = model;
+      otelAttributes[SemanticConventions.LLM_MODEL_NAME] = model;
+    }
+    const system = attributes?.system;
+    const provider = attributes?.provider;
+    const inputMessages = attributes?.inputMessages;
+    const outputMessages = attributes?.outputMessages;
+    const inputMimeType = attributes?.inputMimeType;
+    const outputMimeType = attributes?.outputMimeType;
+    if (system !== void 0) {
+      otelAttributes[SemanticConventions.LLM_SYSTEM] = String(system);
+    }
+    if (provider !== void 0) {
+      otelAttributes[SemanticConventions.LLM_PROVIDER] = String(provider);
     }
     if (modelParameters) {
-      otelAttributes[SemanticConventions2.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
+      otelAttributes[SemanticConventions.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
       otelAttributes[OtelSpanAttributes.LLM_MODEL_PARAMETERS] = _serialize(modelParameters);
     }
     if (usageDetails) {
       if (typeof usageDetails === "object") {
         const usage = usageDetails;
         if (usage.promptTokens !== void 0) {
-          otelAttributes[SemanticConventions2.LLM_TOKEN_COUNT_PROMPT] = usage.promptTokens;
+          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_PROMPT] = usage.promptTokens;
         }
         if (usage.completionTokens !== void 0) {
-          otelAttributes[SemanticConventions2.LLM_TOKEN_COUNT_COMPLETION] = usage.completionTokens;
+          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_COMPLETION] = usage.completionTokens;
         }
         if (usage.totalTokens !== void 0) {
-          otelAttributes[SemanticConventions2.LLM_TOKEN_COUNT_TOTAL] = usage.totalTokens;
+          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_TOTAL] = usage.totalTokens;
         }
       }
       otelAttributes[OtelSpanAttributes.LLM_USAGE_DETAILS] = _serialize(usageDetails);
@@ -135,18 +111,68 @@ function createObservationAttributes(type, attributes) {
     if (completionStartTime) {
       otelAttributes[OtelSpanAttributes.LLM_COMPLETION_START_TIME] = _serialize(completionStartTime);
     }
+    if (inputMessages !== void 0 && Array.isArray(inputMessages)) {
+      const messageAttrs = _flattenLLMMessages(inputMessages, "llm.input_messages");
+      Object.assign(otelAttributes, messageAttrs);
+    }
+    if (outputMessages !== void 0 && Array.isArray(outputMessages)) {
+      const messageAttrs = _flattenLLMMessages(outputMessages, "llm.output_messages");
+      Object.assign(otelAttributes, messageAttrs);
+    }
+    if (inputMimeType !== void 0) {
+      otelAttributes[SemanticConventions.INPUT_MIME_TYPE] = String(inputMimeType);
+    }
+    if (outputMimeType !== void 0) {
+      otelAttributes[SemanticConventions.OUTPUT_MIME_TYPE] = String(outputMimeType);
+    }
   }
   if (type === "embedding") {
     if (model) {
-      otelAttributes[SemanticConventions2.EMBEDDING_MODEL_NAME] = model;
+      otelAttributes[SemanticConventions.EMBEDDING_MODEL_NAME] = model;
     }
     if (modelParameters) {
-      otelAttributes[SemanticConventions2.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
+      otelAttributes[SemanticConventions.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
+    }
+  }
+  if (type === "tool") {
+    const toolName = attributes?.toolName ?? attributes?.tool_name;
+    const toolDescription = attributes?.toolDescription;
+    const toolParameters = attributes?.toolParameters;
+    const toolCall = attributes?.toolCall;
+    if (toolName !== void 0) {
+      otelAttributes[SemanticConventions.TOOL_NAME] = String(toolName);
+    }
+    if (toolDescription !== void 0) {
+      otelAttributes[SemanticConventions.TOOL_DESCRIPTION] = String(toolDescription);
+    }
+    if (toolParameters !== void 0) {
+      otelAttributes[SemanticConventions.TOOL_PARAMETERS] = _serialize(toolParameters);
+    }
+    if (toolCall !== void 0 && typeof toolCall === "object") {
+      const toolCallAttrs = _flattenToolCall(toolCall);
+      Object.assign(otelAttributes, toolCallAttrs);
+    }
+  }
+  if (type === "agent") {
+    const agentName = attributes?.agentName;
+    if (agentName !== void 0) {
+      otelAttributes[SemanticConventions.AGENT_NAME] = String(agentName);
+    }
+  }
+  if (type === "retriever") {
+    const documents = attributes?.documents;
+    const query = attributes?.query;
+    if (documents !== void 0 && Array.isArray(documents)) {
+      const docAttrs = _flattenDocuments(documents);
+      Object.assign(otelAttributes, docAttrs);
+    }
+    if (query !== void 0) {
+      otelAttributes["retriever.query"] = String(query);
     }
   }
   const metadataAttrs = _flattenAndSerializeMetadata(
     metadata,
-    SemanticConventions2.METADATA
+    SemanticConventions.METADATA
   );
   Object.assign(otelAttributes, metadataAttrs);
   const obsetvabilityMetadataAttrs = _flattenAndSerializeMetadata(
@@ -154,6 +180,11 @@ function createObservationAttributes(type, attributes) {
     OtelSpanAttributes.OBSERVATION_METADATA
   );
   Object.assign(otelAttributes, obsetvabilityMetadataAttrs);
+  for (const [key, value] of Object.entries(attributes)) {
+    if (!(key in otelAttributes) && value !== void 0 && value !== null) {
+      otelAttributes[key] = typeof value === "string" ? value : _serialize(value);
+    }
+  }
   return Object.fromEntries(
     Object.entries(otelAttributes).filter(([_, v]) => v != null)
   );
@@ -187,6 +218,96 @@ function _flattenAndSerializeMetadata(metadata, prefix) {
   }
   return metadataAttributes;
 }
+function _flattenLLMMessages(messages, prefix) {
+  const attributes = {};
+  if (!messages || !Array.isArray(messages)) {
+    return attributes;
+  }
+  try {
+    messages.forEach((msg, index) => {
+      if (!msg || typeof msg !== "object") return;
+      const baseKey = `${prefix}.${index}.message`;
+      if (msg.role !== void 0) {
+        attributes[`${baseKey}.role`] = String(msg.role);
+      }
+      if (msg.content !== void 0) {
+        attributes[`${baseKey}.content`] = String(msg.content);
+      }
+      if (msg.toolCallId !== void 0) {
+        attributes[`${baseKey}.tool_call_id`] = String(msg.toolCallId);
+      }
+      if (msg.toolCalls && Array.isArray(msg.toolCalls)) {
+        msg.toolCalls.forEach((toolCall, tcIndex) => {
+          if (!toolCall || typeof toolCall !== "object") return;
+          const tcKey = `${baseKey}.tool_calls.${tcIndex}`;
+          if (toolCall.id !== void 0) {
+            attributes[`${tcKey}.id`] = String(toolCall.id);
+          }
+          if (toolCall.function !== void 0) {
+            if (toolCall.function.name !== void 0) {
+              attributes[`${tcKey}.function.name`] = String(toolCall.function.name);
+            }
+            if (toolCall.function.arguments !== void 0) {
+              attributes[`${tcKey}.function.arguments`] = String(toolCall.function.arguments);
+            }
+          }
+        });
+      }
+    });
+  } catch (e) {
+  }
+  return attributes;
+}
+function _flattenDocuments(documents) {
+  const attributes = {};
+  if (!documents || !Array.isArray(documents)) {
+    return attributes;
+  }
+  try {
+    documents.forEach((doc, index) => {
+      if (!doc || typeof doc !== "object") return;
+      const baseKey = `retrieval.documents.${index}.document`;
+      if (doc.id !== void 0) {
+        attributes[`${baseKey}.id`] = String(doc.id);
+      }
+      if (doc.content !== void 0) {
+        attributes[`${baseKey}.content`] = String(doc.content);
+      }
+      if (doc.score !== void 0) {
+        attributes[`${baseKey}.score`] = String(doc.score);
+      }
+      if (doc.metadata !== void 0 && typeof doc.metadata === "object") {
+        const metadataSerialized = _serialize(doc.metadata);
+        if (metadataSerialized) {
+          attributes[`${baseKey}.metadata`] = metadataSerialized;
+        }
+      }
+    });
+  } catch (e) {
+  }
+  return attributes;
+}
+function _flattenToolCall(toolCall) {
+  const attributes = {};
+  if (!toolCall || typeof toolCall !== "object") {
+    return attributes;
+  }
+  try {
+    if (toolCall.id !== void 0) {
+      attributes["tool_call.id"] = String(toolCall.id);
+    }
+    if (toolCall.function !== void 0) {
+      if (toolCall.function.name !== void 0) {
+        attributes["tool_call.function.name"] = String(toolCall.function.name);
+      }
+      if (toolCall.function.arguments !== void 0) {
+        attributes["tool_call.function.arguments"] = String(toolCall.function.arguments);
+      }
+    }
+  } catch (e) {
+  }
+  return attributes;
+}
 var init_attributes = __esm({
   "src/core/attributes.ts"() {
     "use strict";
@@ -241,18 +362,18 @@ function getTracer() {
     OBSERVABILITY_SDK_VERSION
   );
 }
-var OBSERVABILITY_GLOBAL_SYMBOL, OBSERVABILITY_SDK_NAME, OBSERVABILITY_SDK_VERSION;
+var OBSERVABILITY_GLOBAL_SYMBOL;
 var init_tracerProvider = __esm({
   "src/core/tracerProvider.ts"() {
     "use strict";
+    init_constants();
     OBSERVABILITY_GLOBAL_SYMBOL = /* @__PURE__ */ Symbol.for("observability");
-    OBSERVABILITY_SDK_NAME = "ag-kit-observability";
-    OBSERVABILITY_SDK_VERSION = "0.1.0";
   }
 });
 
 // src/core/spanWrapper.ts
-var BaseObservation, ObservationSpan, ObservationLLM, ObservationEmbedding, ObservationAgent, ObservationTool, ObservationChain, ObservationRetriever, ObservationReranker, ObservationEvaluator, ObservationGuardrail;
+import { SpanStatusCode } from "@opentelemetry/api";
+var BaseObservation, ObservationLLM, ObservationEmbedding, ObservationAgent, ObservationTool, ObservationChain, ObservationRetriever, ObservationReranker, ObservationEvaluator, ObservationGuardrail;
 var init_spanWrapper = __esm({
   "src/core/spanWrapper.ts"() {
     "use strict";
@@ -278,7 +399,7 @@ var init_spanWrapper = __esm({
           );
         }
       }
-      /** Gets the AG-Kit OpenTelemetry tracer instance */
+      /** Gets the OpenTelemetry tracer instance */
       get tracer() {
         return getTracer();
       }
@@ -290,6 +411,27 @@ var init_spanWrapper = __esm({
       end(endTime) {
         this.otelSpan.end(endTime);
       }
+      /**
+       * Sets the span status.
+       *
+       * @param status - The status to set on the span
+       */
+      setStatus(status) {
+        this.otelSpan.setStatus(status);
+      }
+      /**
+       * Sets the span status to ERROR.
+       *
+       * Convenience method for marking the span as failed.
+       *
+       * @param message - Error description message
+       */
+      setErrorStatus(message) {
+        this.otelSpan.setStatus({
+          code: SpanStatusCode.ERROR,
+          message
+        });
+      }
       /**
        * Updates the OTEL span attributes.
        *
@@ -313,22 +455,13 @@ var init_spanWrapper = __esm({
       }
       startObservation(name, attributes, options) {
         const { startObservation: startObs } = (init_src(), __toCommonJS(src_exports));
-        const { asType = "span" } = options || {};
+        const { asType = "chain" } = options || {};
         return startObs(name, attributes, {
           asType,
           parentSpanContext: this.otelSpan.spanContext()
         });
       }
     };
-    ObservationSpan = class extends BaseObservation {
-      constructor(params) {
-        super({ ...params, type: "span" });
-      }
-      update(attributes) {
-        super.updateOtelSpanAttributes(attributes);
-        return this;
-      }
-    };
     ObservationLLM = class extends BaseObservation {
       constructor(params) {
         super({ ...params, type: "llm" });
@@ -413,6 +546,170 @@ var init_spanWrapper = __esm({
   }
 });
 
+// src/core/trace-context.ts
+import { TraceFlags } from "@opentelemetry/api";
+function validateTraceId(traceId) {
+  if (!traceId || typeof traceId !== "string") {
+    return false;
+  }
+  if (traceId.length !== 32) {
+    return false;
+  }
+  const chunk1 = traceId.slice(0, 16);
+  const chunk2 = traceId.slice(16, 32);
+  const value1 = parseInt(chunk1, 16);
+  const value2 = parseInt(chunk2, 16);
+  if (isNaN(value1) || isNaN(value2)) {
+    return false;
+  }
+  if (value1 === 0 && value2 === 0) {
+    return false;
+  }
+  return true;
+}
+function validateSpanId(spanId) {
+  if (!spanId || typeof spanId !== "string") {
+    return false;
+  }
+  if (spanId.length !== 16) {
+    return false;
+  }
+  const value = parseInt(spanId, 16);
+  if (isNaN(value)) {
+    return false;
+  }
+  if (value === 0) {
+    return false;
+  }
+  return true;
+}
+function validateTraceContext(traceId, parentSpanId) {
+  const result = {
+    errors: [],
+    isValid: false,
+    hasTraceId: false,
+    hasParentSpanId: false
+  };
+  if (!traceId && !parentSpanId) {
+    result.isValid = true;
+    return result;
+  }
+  if (!traceId && parentSpanId) {
+    result.errors.push(
+      "parentSpanId provided without traceId - traceId is required when inheriting parent span"
+    );
+    return result;
+  }
+  if (traceId) {
+    if (!validateTraceId(traceId)) {
+      result.errors.push(
+        `Invalid traceId format: '${traceId}' - must be 32 hex characters and not all zeros`
+      );
+    } else {
+      result.traceId = traceId.toLowerCase();
+      result.hasTraceId = true;
+    }
+  }
+  if (parentSpanId) {
+    if (!validateSpanId(parentSpanId)) {
+      result.errors.push(
+        `Invalid parentSpanId format: '${parentSpanId}' - must be 16 hex characters and not all zeros`
+      );
+    } else {
+      result.parentSpanId = parentSpanId.toLowerCase();
+      result.hasParentSpanId = true;
+    }
+  }
+  result.isValid = result.errors.length === 0;
+  return result;
+}
+function createSpanLinkFromContext(traceId, parentSpanId, linkType = "follows_from", sourceSystem = "gateway") {
+  const externalContext = {
+    traceId,
+    spanId: parentSpanId,
+    traceFlags: TraceFlags.SAMPLED
+  };
+  const link = {
+    context: externalContext,
+    attributes: {
+      "link.type": linkType,
+      "link.source": sourceSystem,
+      "link.trace_id": traceId,
+      "link.span_id": parentSpanId
+    }
+  };
+  return link;
+}
+function extractTraceContextFromHeaders(headers, traceIdHeader = "x-trace-id", parentSpanIdHeader = "x-parent-span-id") {
+  if (!headers) {
+    return [void 0, void 0];
+  }
+  let traceId;
+  let parentSpanId;
+  if (headers instanceof Headers) {
+    traceId = headers.get(traceIdHeader) || void 0;
+    parentSpanId = headers.get(parentSpanIdHeader) || void 0;
+  } else {
+    const headersLower = {};
+    for (const [key, value] of Object.entries(headers)) {
+      headersLower[key.toLowerCase()] = value;
+    }
+    traceId = headersLower[traceIdHeader.toLowerCase()];
+    parentSpanId = headersLower[parentSpanIdHeader.toLowerCase()];
+  }
+  return [traceId, parentSpanId];
+}
+function processTraceContextFromHeaders(headers, logger, linkType = "follows_from", sourceSystem = "gateway") {
+  const [traceId, parentSpanId] = extractTraceContextFromHeaders(headers);
+  const validation = validateTraceContext(traceId, parentSpanId);
+  if (!validation.isValid) {
+    if (logger && logger.warn) {
+      validation.errors.forEach((error) => {
+        logger.warn(`Trace context validation failed: ${error}`);
+      });
+    }
+    return {
+      traceId: void 0,
+      parentSpanId: void 0,
+      isInherited: false,
+      hasParentLink: false,
+      spanAttributes: {},
+      links: []
+    };
+  }
+  const normalizedTraceId = validation.traceId;
+  const normalizedParentSpanId = validation.parentSpanId;
+  const attributes = {};
+  const links = [];
+  if (normalizedTraceId) {
+    attributes["trace.inherited"] = true;
+    attributes["trace.external_trace_id"] = normalizedTraceId;
+  }
+  if (normalizedTraceId && normalizedParentSpanId) {
+    const link = createSpanLinkFromContext(
+      normalizedTraceId,
+      normalizedParentSpanId,
+      linkType,
+      sourceSystem
+    );
+    links.push(link);
+    attributes["trace.external_parent_span_id"] = normalizedParentSpanId;
+  }
+  return {
+    traceId: normalizedTraceId,
+    parentSpanId: normalizedParentSpanId,
+    isInherited: !!normalizedTraceId,
+    hasParentLink: !!normalizedParentSpanId,
+    spanAttributes: attributes,
+    links
+  };
+}
+var init_trace_context = __esm({
+  "src/core/trace-context.ts"() {
+    "use strict";
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -424,26 +721,34 @@ __export(src_exports, {
   ObservationLLM: () => ObservationLLM,
   ObservationReranker: () => ObservationReranker,
   ObservationRetriever: () => ObservationRetriever,
-  ObservationSpan: () => ObservationSpan,
   ObservationTool: () => ObservationTool,
   createObservationAttributes: () => createObservationAttributes,
+  createSpanLinkFromContext: () => createSpanLinkFromContext,
   createTraceAttributes: () => createTraceAttributes,
+  extractTraceContextFromHeaders: () => extractTraceContextFromHeaders,
   getActiveSpanId: () => getActiveSpanId,
   getActiveTraceId: () => getActiveTraceId,
   getTracer: () => getTracer,
   getTracerProvider: () => getTracerProvider,
   observe: () => observe,
+  processTraceContextFromHeaders: () => processTraceContextFromHeaders,
   setTracerProvider: () => setTracerProvider,
   startActiveObservation: () => startActiveObservation,
   startObservation: () => startObservation,
   updateActiveObservation: () => updateActiveObservation,
-  updateActiveTrace: () => updateActiveTrace
+  updateActiveTrace: () => updateActiveTrace,
+  validateSpanId: () => validateSpanId,
+  validateTraceContext: () => validateTraceContext,
+  validateTraceId: () => validateTraceId
 });
-import { trace as trace2, context as context2, SpanStatusCode } from "@opentelemetry/api";
+import { trace as trace2, context as context2, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
 function createOtelSpan(params) {
   return getTracer().startSpan(
     params.name,
-    { startTime: params.startTime },
+    {
+      startTime: params.startTime,
+      links: params.links || []
+    },
     createParentContext(params.parentSpanContext)
   );
 }
@@ -452,7 +757,7 @@ function createParentContext(parentSpanContext) {
   return trace2.setSpanContext(context2.active(), parentSpanContext);
 }
 function startObservation(name, attributes, options) {
-  const { asType = "span", ...observationOptions } = options || {};
+  const { asType = "chain", ...observationOptions } = options || {};
   const otelSpan = createOtelSpan({
     name,
     ...observationOptions
@@ -503,9 +808,8 @@ function startObservation(name, attributes, options) {
         otelSpan,
         attributes
       });
-    case "span":
     default:
-      return new ObservationSpan({
+      return new ObservationChain({
         otelSpan,
         attributes
       });
@@ -537,7 +841,7 @@ function wrapPromise(promise, span, endOnExit) {
     },
     (err) => {
       span.setStatus({
-        code: SpanStatusCode.ERROR,
+        code: SpanStatusCode2.ERROR,
         message: err instanceof Error ? err.message : "Unknown error"
       });
       if (endOnExit !== false) {
@@ -548,7 +852,7 @@ function wrapPromise(promise, span, endOnExit) {
   );
 }
 function startActiveObservation(name, fn, options) {
-  const { asType = "span", endOnExit, ...observationOptions } = options || {};
+  const { asType = "chain", endOnExit, ...observationOptions } = options || {};
   return getTracer().startActiveSpan(
     name,
     { startTime: observationOptions?.startTime },
@@ -569,9 +873,6 @@ function startActiveObservation(name, fn, options) {
           case "tool":
             observation = new ObservationTool({ otelSpan: span });
             break;
-          case "chain":
-            observation = new ObservationChain({ otelSpan: span });
-            break;
           case "retriever":
             observation = new ObservationRetriever({ otelSpan: span });
             break;
@@ -584,9 +885,9 @@ function startActiveObservation(name, fn, options) {
           case "guardrail":
             observation = new ObservationGuardrail({ otelSpan: span });
             break;
-          case "span":
+          case "chain":
           default:
-            observation = new ObservationSpan({ otelSpan: span });
+            observation = new ObservationChain({ otelSpan: span });
         }
         const result = fn(observation);
         if (result instanceof Promise) {
@@ -603,7 +904,7 @@ function startActiveObservation(name, fn, options) {
         }
       } catch (err) {
         span.setStatus({
-          code: SpanStatusCode.ERROR,
+          code: SpanStatusCode2.ERROR,
           message: err instanceof Error ? err.message : "Unknown error"
         });
         if (endOnExit !== false) {
@@ -622,7 +923,7 @@ function updateActiveObservation(attributes) {
     );
     return;
   }
-  span.setAttributes(createObservationAttributes("span", attributes));
+  span.setAttributes(createObservationAttributes("chain", attributes));
 }
 function _captureArguments(args) {
   if (args.length === 0) return {};
@@ -631,7 +932,7 @@ function _captureArguments(args) {
 }
 function observe(fn, options = {}) {
   const {
-    asType = "span",
+    asType = "chain",
     captureInput = true,
     captureOutput = true,
     ...observationOptions
@@ -685,6 +986,7 @@ var init_src = __esm({
     init_tracerProvider();
     init_attributes();
     init_tracerProvider();
+    init_trace_context();
   }
 });
 
@@ -694,7 +996,6 @@ export {
   setTracerProvider,
   getTracerProvider,
   getTracer,
-  ObservationSpan,
   ObservationLLM,
   ObservationEmbedding,
   ObservationAgent,
@@ -704,6 +1005,12 @@ export {
   ObservationReranker,
   ObservationEvaluator,
   ObservationGuardrail,
+  validateTraceId,
+  validateSpanId,
+  validateTraceContext,
+  createSpanLinkFromContext,
+  extractTraceContextFromHeaders,
+  processTraceContextFromHeaders,
   startObservation,
   updateActiveTrace,
   getActiveTraceId,
@@ -713,4 +1020,4 @@ export {
   observe,
   init_src
 };
-//# sourceMappingURL=chunk-ZGEMAYS4.mjs.map
+//# sourceMappingURL=chunk-AHSI4KTT.mjs.map