@cloudbase/agent-observability 0.0.16 → 0.0.18

package/dist/index.js

@@ -21,39 +21,41 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/core/constants.ts
-var import_openinference_semantic_conventions, OtelSpanAttributes;
+var import_openinference_semantic_conventions, OBSERVABILITY_SDK_NAME, OBSERVABILITY_SDK_VERSION, OtelSpanAttributes;
 var init_constants = __esm({
   "src/core/constants.ts"() {
     "use strict";
     import_openinference_semantic_conventions = require("@arizeai/openinference-semantic-conventions");
+    OBSERVABILITY_SDK_NAME = "observability";
+    OBSERVABILITY_SDK_VERSION = "0.1.0";
     OtelSpanAttributes = {
       // OpenInference - re-export all standard conventions
       ...import_openinference_semantic_conventions.SemanticConventions,
-      // AG-Kit Trace attributes (non-standard)
+      // 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 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-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-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)
+      // General (non-standard)
       ENVIRONMENT: "environment",
       RELEASE: "release",
       VERSION: "version"
@@ -106,25 +108,38 @@ function createObservationAttributes(type, attributes) {
     modelParameters,
     usageDetails
   } = attributes;
+  const spanKind = import_openinference_semantic_conventions.OpenInferenceSpanKind[type.toUpperCase()] || "CHAIN";
   const otelAttributes = {
-    [import_openinference_semantic_conventions2.SemanticConventions.OPENINFERENCE_SPAN_KIND]: type.toUpperCase(),
+    [import_openinference_semantic_conventions2.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
     [import_openinference_semantic_conventions2.SemanticConventions.INPUT_VALUE]: _serialize(input),
-    // Also set legacy agkit.observation.input for compatibility
+    // Also set observation.input for compatibility
     [OtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
     // Use OpenInference output.value convention
     [import_openinference_semantic_conventions2.SemanticConventions.OUTPUT_VALUE]: _serialize(output),
-    // Also set legacy agkit.observation.output for compatibility
+    // Also set observation.output for compatibility
     [OtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output)
   };
   if (type === "llm") {
     if (model) {
       otelAttributes[import_openinference_semantic_conventions2.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[import_openinference_semantic_conventions2.SemanticConventions.LLM_SYSTEM] = String(system);
+    }
+    if (provider !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.LLM_PROVIDER] = String(provider);
+    }
     if (modelParameters) {
       otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
       otelAttributes[OtelSpanAttributes.LLM_MODEL_PARAMETERS] = _serialize(modelParameters);
@@ -147,6 +162,20 @@ 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[import_openinference_semantic_conventions2.SemanticConventions.INPUT_MIME_TYPE] = String(inputMimeType);
+    }
+    if (outputMimeType !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.OUTPUT_MIME_TYPE] = String(outputMimeType);
+    }
   }
   if (type === "embedding") {
     if (model) {
@@ -156,6 +185,42 @@ function createObservationAttributes(type, attributes) {
       otelAttributes[import_openinference_semantic_conventions2.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[import_openinference_semantic_conventions2.SemanticConventions.TOOL_NAME] = String(toolName);
+    }
+    if (toolDescription !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.TOOL_DESCRIPTION] = String(toolDescription);
+    }
+    if (toolParameters !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.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[import_openinference_semantic_conventions2.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,
     import_openinference_semantic_conventions2.SemanticConventions.METADATA
@@ -166,6 +231,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)
   );
@@ -199,6 +269,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 import_openinference_semantic_conventions2;
 var init_attributes = __esm({
   "src/core/attributes.ts"() {
@@ -254,22 +414,22 @@ function getTracer() {
     OBSERVABILITY_SDK_VERSION
   );
 }
-var import_api, OBSERVABILITY_GLOBAL_SYMBOL, OBSERVABILITY_SDK_NAME, OBSERVABILITY_SDK_VERSION;
+var import_api, OBSERVABILITY_GLOBAL_SYMBOL;
 var init_tracerProvider = __esm({
   "src/core/tracerProvider.ts"() {
     "use strict";
     import_api = require("@opentelemetry/api");
+    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;
+var import_api2, BaseObservation, ObservationLLM, ObservationEmbedding, ObservationAgent, ObservationTool, ObservationChain, ObservationRetriever, ObservationReranker, ObservationEvaluator, ObservationGuardrail;
 var init_spanWrapper = __esm({
   "src/core/spanWrapper.ts"() {
     "use strict";
+    import_api2 = require("@opentelemetry/api");
     init_attributes();
     init_tracerProvider();
     BaseObservation = class {
@@ -292,7 +452,7 @@ var init_spanWrapper = __esm({
           );
         }
       }
-      /** Gets the AG-Kit OpenTelemetry tracer instance */
+      /** Gets the OpenTelemetry tracer instance */
       get tracer() {
         return getTracer();
       }
@@ -304,6 +464,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: import_api2.SpanStatusCode.ERROR,
+          message
+        });
+      }
       /**
        * Updates the OTEL span attributes.
        *
@@ -327,22 +508,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" });
@@ -427,6 +599,171 @@ var init_spanWrapper = __esm({
   }
 });
 
+// src/core/trace-context.ts
+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: import_api3.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 import_api3;
+var init_trace_context = __esm({
+  "src/core/trace-context.ts"() {
+    "use strict";
+    import_api3 = require("@opentelemetry/api");
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -438,35 +775,43 @@ __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
 });
 module.exports = __toCommonJS(src_exports);
 function createOtelSpan(params) {
   return getTracer().startSpan(
     params.name,
-    { startTime: params.startTime },
+    {
+      startTime: params.startTime,
+      links: params.links || []
+    },
     createParentContext(params.parentSpanContext)
   );
 }
 function createParentContext(parentSpanContext) {
   if (!parentSpanContext) return;
-  return import_api2.trace.setSpanContext(import_api2.context.active(), parentSpanContext);
+  return import_api4.trace.setSpanContext(import_api4.context.active(), parentSpanContext);
 }
 function startObservation(name, attributes, options) {
-  const { asType = "span", ...observationOptions } = options || {};
+  const { asType = "chain", ...observationOptions } = options || {};
   const otelSpan = createOtelSpan({
     name,
     ...observationOptions
@@ -517,16 +862,15 @@ function startObservation(name, attributes, options) {
         otelSpan,
         attributes
       });
-    case "span":
     default:
-      return new ObservationSpan({
+      return new ObservationChain({
         otelSpan,
         attributes
       });
   }
 }
 function updateActiveTrace(attributes) {
-  const span = import_api2.trace.getActiveSpan();
+  const span = import_api4.trace.getActiveSpan();
   if (!span) {
     console.warn(
       "[Observability] No active OTEL span in context. Skipping trace update."
@@ -536,10 +880,10 @@ function updateActiveTrace(attributes) {
   span.setAttributes(createTraceAttributes(attributes));
 }
 function getActiveTraceId() {
-  return import_api2.trace.getActiveSpan()?.spanContext().traceId;
+  return import_api4.trace.getActiveSpan()?.spanContext().traceId;
 }
 function getActiveSpanId() {
-  return import_api2.trace.getActiveSpan()?.spanContext().spanId;
+  return import_api4.trace.getActiveSpan()?.spanContext().spanId;
 }
 function wrapPromise(promise, span, endOnExit) {
   return promise.then(
@@ -551,7 +895,7 @@ function wrapPromise(promise, span, endOnExit) {
     },
     (err) => {
       span.setStatus({
-        code: import_api2.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: err instanceof Error ? err.message : "Unknown error"
       });
       if (endOnExit !== false) {
@@ -562,11 +906,11 @@ 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 },
-    createParentContext(observationOptions?.parentSpanContext) ?? import_api2.context.active(),
+    createParentContext(observationOptions?.parentSpanContext) ?? import_api4.context.active(),
     (span) => {
       try {
         let observation;
@@ -583,9 +927,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;
@@ -598,9 +939,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) {
@@ -617,7 +958,7 @@ function startActiveObservation(name, fn, options) {
         }
       } catch (err) {
         span.setStatus({
-          code: import_api2.SpanStatusCode.ERROR,
+          code: import_api4.SpanStatusCode.ERROR,
           message: err instanceof Error ? err.message : "Unknown error"
         });
         if (endOnExit !== false) {
@@ -629,14 +970,14 @@ function startActiveObservation(name, fn, options) {
   );
 }
 function updateActiveObservation(attributes) {
-  const span = import_api2.trace.getActiveSpan();
+  const span = import_api4.trace.getActiveSpan();
   if (!span) {
     console.warn(
       "[Observability] No active OTEL span in context. Skipping observation update."
     );
     return;
   }
-  span.setAttributes(createObservationAttributes("span", attributes));
+  span.setAttributes(createObservationAttributes("chain", attributes));
 }
 function _captureArguments(args) {
   if (args.length === 0) return {};
@@ -645,7 +986,7 @@ function _captureArguments(args) {
 }
 function observe(fn, options = {}) {
   const {
-    asType = "span",
+    asType = "chain",
     captureInput = true,
     captureOutput = true,
     ...observationOptions
@@ -661,8 +1002,8 @@ function observe(fn, options = {}) {
         asType
       }
     );
-    const activeContext = import_api2.trace.setSpan(import_api2.context.active(), observation.otelSpan);
-    const result = import_api2.context.with(activeContext, () => fn.apply(this, args));
+    const activeContext = import_api4.trace.setSpan(import_api4.context.active(), observation.otelSpan);
+    const result = import_api4.context.with(activeContext, () => fn.apply(this, args));
     if (result instanceof Promise) {
       return result.then(
         (value) => {
@@ -692,15 +1033,16 @@ function observe(fn, options = {}) {
   Object.defineProperty(wrappedFunction, "length", { value: fn.length });
   return wrappedFunction;
 }
-var import_api2;
+var import_api4;
 var init_src = __esm({
   "src/index.ts"() {
-    import_api2 = require("@opentelemetry/api");
+    import_api4 = require("@opentelemetry/api");
     init_attributes();
     init_spanWrapper();
     init_tracerProvider();
     init_attributes();
     init_tracerProvider();
+    init_trace_context();
   }
 });
 init_src();
@@ -714,19 +1056,24 @@ init_src();
   ObservationLLM,
   ObservationReranker,
   ObservationRetriever,
-  ObservationSpan,
   ObservationTool,
   createObservationAttributes,
+  createSpanLinkFromContext,
   createTraceAttributes,
+  extractTraceContextFromHeaders,
   getActiveSpanId,
   getActiveTraceId,
   getTracer,
   getTracerProvider,
   observe,
+  processTraceContextFromHeaders,
   setTracerProvider,
   startActiveObservation,
   startObservation,
   updateActiveObservation,
-  updateActiveTrace
+  updateActiveTrace,
+  validateSpanId,
+  validateTraceContext,
+  validateTraceId
 });
 //# sourceMappingURL=index.js.map