@cloudbase/agent-observability 0.0.16 → 0.0.18

package/dist/chunk-AHSI4KTT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/attributes.ts","../src/core/tracerProvider.ts","../src/core/spanWrapper.ts","../src/core/trace-context.ts","../src/index.ts"],"sourcesContent":["import { OtelSpanAttributes, OpenInferenceSpanKind } from \"./constants\";\nimport { SemanticConventions } from \"@arizeai/openinference-semantic-conventions\";\nimport { ObservationAttributes, TraceAttributes, ObservationType, LLMMessage, Document, ToolCall } from \"../types\";\nimport { type Attributes } from \"@opentelemetry/api\";\n\n/**\n * Creates OpenTelemetry attributes from trace attributes.\n *\n * Converts user-friendly trace attributes into OpenTelemetry attribute format\n * using OpenInference semantic conventions where applicable.\n *\n * @param attributes - Trace attributes to convert\n * @returns OpenTelemetry attributes object\n *\n * @example\n * ```typescript\n * const otelAttributes = createTraceAttributes({\n *   name: 'user-workflow',\n *   userId: 'user-123',\n *   sessionId: 'session-456',\n *   tags: ['checkout', 'payment']\n * });\n * ```\n *\n * @public\n */\nexport function createTraceAttributes({\n  name,\n  userId,\n  sessionId,\n  version,\n  release,\n  input,\n  output,\n  metadata,\n  tags,\n  environment,\n  public: isPublic,\n}: TraceAttributes = {}): Attributes {\n  const attributes = {\n    [OtelSpanAttributes.TRACE_NAME]: name,\n    // Use OpenInference standard attributes for user and session\n    [OtelSpanAttributes.USER_ID]: userId,\n    [OtelSpanAttributes.SESSION_ID]: sessionId,\n    [OtelSpanAttributes.VERSION]: version,\n    [OtelSpanAttributes.RELEASE]: release,\n    [OtelSpanAttributes.TRACE_INPUT]: _serialize(input),\n    [OtelSpanAttributes.TRACE_OUTPUT]: _serialize(output),\n    [OtelSpanAttributes.TRACE_TAGS]: tags,\n    [OtelSpanAttributes.ENVIRONMENT]: environment,\n    [OtelSpanAttributes.TRACE_PUBLIC]: isPublic,\n    ..._flattenAndSerializeMetadata(metadata, OtelSpanAttributes.TRACE_METADATA),\n  };\n\n  return Object.fromEntries(\n    Object.entries(attributes).filter(([_, v]) => v != null),\n  );\n}\n\n/**\n * Creates OpenTelemetry attributes from observation attributes.\n *\n * Maps observation attributes to OpenInference semantic conventions:\n * - Uses `openinference.span.kind` for span type\n * - Uses `llm.*` for LLM-specific attributes\n * - Uses `tool.*` for tool-specific attributes\n * - Uses `observation.*` for non-standard attributes\n *\n * @param type - Observation type (llm, tool, chain, etc.)\n * @param attributes - Observation attributes to convert\n * @returns OpenTelemetry attributes object\n *\n * @public\n */\nexport function createObservationAttributes(\n  type: ObservationType,\n  attributes: ObservationAttributes,\n): Attributes {\n  const {\n    metadata,\n    input,\n    output,\n    level,\n    statusMessage,\n    version,\n    completionStartTime,\n    model,\n    modelParameters,\n    usageDetails,\n  } = attributes;\n\n  // Map observation type to OpenInference span kind\n  // Falls back to CHAIN for unknown types (CHAIN is the generic catch-all in OpenInference)\n  const spanKind = (OpenInferenceSpanKind as Record<string, string>)[type.toUpperCase()] || \"CHAIN\";\n\n  // Base attributes for all observation types\n  const otelAttributes: Attributes = {\n    [SemanticConventions.OPENINFERENCE_SPAN_KIND]: spanKind,\n    [OtelSpanAttributes.OBSERVATION_TYPE]: type,\n    [OtelSpanAttributes.OBSERVATION_LEVEL]: level,\n    [OtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,\n    [OtelSpanAttributes.VERSION]: version,\n    // Use OpenInference input.value convention\n    [SemanticConventions.INPUT_VALUE]: _serialize(input),\n    // Also set observation.input for compatibility\n    [OtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),\n    // Use OpenInference output.value convention\n    [SemanticConventions.OUTPUT_VALUE]: _serialize(output),\n    // Also set observation.output for compatibility\n    [OtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output),\n  };\n\n  // LLM-specific attributes\n  if (type === \"llm\") {\n    if (model) {\n      otelAttributes[SemanticConventions.LLM_MODEL_NAME] = model;\n    }\n    // Extract system and provider safely\n    const system = (attributes as Record<string, unknown>)?.system;\n    const provider = (attributes as Record<string, unknown>)?.provider;\n    const inputMessages = (attributes as Record<string, unknown>)?.inputMessages;\n    const outputMessages = (attributes as Record<string, unknown>)?.outputMessages;\n    const inputMimeType = (attributes as Record<string, unknown>)?.inputMimeType;\n    const outputMimeType = (attributes as Record<string, unknown>)?.outputMimeType;\n\n    if (system !== undefined) {\n      otelAttributes[SemanticConventions.LLM_SYSTEM] = String(system);\n    }\n    if (provider !== undefined) {\n      otelAttributes[SemanticConventions.LLM_PROVIDER] = String(provider);\n    }\n    if (modelParameters) {\n      otelAttributes[SemanticConventions.LLM_INVOCATION_PARAMETERS] =\n        _serialize(modelParameters);\n      // Also set llm.model_parameters for compatibility\n      otelAttributes[OtelSpanAttributes.LLM_MODEL_PARAMETERS] =\n        _serialize(modelParameters);\n    }\n    if (usageDetails) {\n      // Map to OpenInference llm.token_count.* attributes\n      if (typeof usageDetails === \"object\") {\n        const usage = usageDetails as Record<string, number>;\n        if (usage.promptTokens !== undefined) {\n          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_PROMPT] =\n            usage.promptTokens;\n        }\n        if (usage.completionTokens !== undefined) {\n          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_COMPLETION] =\n            usage.completionTokens;\n        }\n        if (usage.totalTokens !== undefined) {\n          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_TOTAL] =\n            usage.totalTokens;\n        }\n      }\n      // Also set llm.usage_details for compatibility\n      otelAttributes[OtelSpanAttributes.LLM_USAGE_DETAILS] =\n        _serialize(usageDetails);\n    }\n    if (completionStartTime) {\n      otelAttributes[OtelSpanAttributes.LLM_COMPLETION_START_TIME] =\n        _serialize(completionStartTime);\n    }\n    // Flatten LLM messages\n    if (inputMessages !== undefined && Array.isArray(inputMessages)) {\n      const messageAttrs = _flattenLLMMessages(inputMessages as LLMMessage[], \"llm.input_messages\");\n      Object.assign(otelAttributes, messageAttrs);\n    }\n    if (outputMessages !== undefined && Array.isArray(outputMessages)) {\n      const messageAttrs = _flattenLLMMessages(outputMessages as LLMMessage[], \"llm.output_messages\");\n      Object.assign(otelAttributes, messageAttrs);\n    }\n    // Add MIME types\n    if (inputMimeType !== undefined) {\n      otelAttributes[SemanticConventions.INPUT_MIME_TYPE] = String(inputMimeType);\n    }\n    if (outputMimeType !== undefined) {\n      otelAttributes[SemanticConventions.OUTPUT_MIME_TYPE] = String(outputMimeType);\n    }\n  }\n\n  // Embedding-specific attributes\n  if (type === \"embedding\") {\n    if (model) {\n      otelAttributes[SemanticConventions.EMBEDDING_MODEL_NAME] = model;\n    }\n    if (modelParameters) {\n      otelAttributes[SemanticConventions.LLM_INVOCATION_PARAMETERS] =\n        _serialize(modelParameters);\n    }\n  }\n\n  // Tool-specific attributes\n  if (type === \"tool\") {\n    const toolName = (attributes as Record<string, unknown>)?.toolName ?? (attributes as Record<string, unknown>)?.tool_name;\n    const toolDescription = (attributes as Record<string, unknown>)?.toolDescription;\n    const toolParameters = (attributes as Record<string, unknown>)?.toolParameters;\n    const toolCall = (attributes as Record<string, unknown>)?.toolCall;\n\n    if (toolName !== undefined) {\n      otelAttributes[SemanticConventions.TOOL_NAME] = String(toolName);\n    }\n    if (toolDescription !== undefined) {\n      otelAttributes[SemanticConventions.TOOL_DESCRIPTION] = String(toolDescription);\n    }\n    if (toolParameters !== undefined) {\n      otelAttributes[SemanticConventions.TOOL_PARAMETERS] = _serialize(toolParameters);\n    }\n    // Flatten tool call if present\n    if (toolCall !== undefined && typeof toolCall === \"object\") {\n      const toolCallAttrs = _flattenToolCall(toolCall as ToolCall);\n      Object.assign(otelAttributes, toolCallAttrs);\n    }\n  }\n\n  // Agent-specific attributes\n  if (type === \"agent\") {\n    const agentName = (attributes as Record<string, unknown>)?.agentName;\n    if (agentName !== undefined) {\n      otelAttributes[SemanticConventions.AGENT_NAME] = String(agentName);\n    }\n  }\n\n  // Retriever-specific attributes\n  if (type === \"retriever\") {\n    const documents = (attributes as Record<string, unknown>)?.documents;\n    const query = (attributes as Record<string, unknown>)?.query;\n\n    if (documents !== undefined && Array.isArray(documents)) {\n      const docAttrs = _flattenDocuments(documents as Document[]);\n      Object.assign(otelAttributes, docAttrs);\n    }\n    if (query !== undefined) {\n      otelAttributes[\"retriever.query\"] = String(query);\n    }\n  }\n\n  // Add metadata (use OpenInference metadata convention)\n  const metadataAttrs = _flattenAndSerializeMetadata(\n    metadata,\n    SemanticConventions.METADATA,\n  );\n  Object.assign(otelAttributes, metadataAttrs);\n\n  // Also add observation.metadata for compatibility\n  const obsetvabilityMetadataAttrs = _flattenAndSerializeMetadata(\n    metadata,\n    OtelSpanAttributes.OBSERVATION_METADATA\n  );\n  Object.assign(otelAttributes, obsetvabilityMetadataAttrs);\n\n  // Pass through any additional custom attributes (e.g., agui.thread_id, agui.run_id)\n  // Only pass through attributes that haven't been set yet to avoid overwriting internal ones\n  for (const [key, value] of Object.entries(attributes)) {\n    if (!(key in otelAttributes) && value !== undefined && value !== null) {\n      otelAttributes[key] = typeof value === 'string' ? value : _serialize(value);\n    }\n  }\n\n  // Filter out null/undefined values\n  return Object.fromEntries(\n    Object.entries(otelAttributes).filter(([_, v]) => v != null),\n  );\n}\n\n/**\n * Safely serializes an object to JSON string.\n *\n * @param obj - Object to serialize\n * @returns JSON string or undefined if null/undefined\n * @internal\n */\nfunction _serialize(obj: unknown): string | undefined {\n  try {\n    if (typeof obj === \"string\") return obj;\n    if (obj instanceof Date) return obj.toISOString();\n    return obj != null ? JSON.stringify(obj) : undefined;\n  } catch {\n    return \"<failed to serialize>\";\n  }\n}\n\n/**\n * Flattens and serializes metadata into OpenTelemetry attribute format.\n *\n * Converts nested metadata objects into dot-notation attribute keys.\n * For example, `{ database: { host: 'localhost' } }` becomes\n * `{ 'metadata.database.host': 'localhost' }` (or 'observation.metadata.database.host').\n *\n * @param metadata - Metadata object to flatten\n * @param prefix - Attribute prefix (e.g., 'metadata' or 'observation.metadata')\n * @returns Flattened metadata attributes\n * @internal\n */\nfunction _flattenAndSerializeMetadata(\n  metadata: unknown,\n  prefix: string,\n): Record<string, string> {\n  const metadataAttributes: Record<string, string> = {};\n\n  if (metadata === undefined || metadata === null) {\n    return metadataAttributes;\n  }\n\n  if (typeof metadata !== \"object\" || Array.isArray(metadata)) {\n    const serialized = _serialize(metadata);\n    if (serialized) {\n      metadataAttributes[prefix] = serialized;\n    }\n  } else {\n    for (const [key, value] of Object.entries(metadata)) {\n      const serialized = typeof value === \"string\" ? value : _serialize(value);\n      if (serialized) {\n        metadataAttributes[`${prefix}.${key}`] = serialized;\n      }\n    }\n  }\n\n  return metadataAttributes;\n}\n\n/**\n * Flattens LLM messages into OpenTelemetry attributes.\n *\n * Follows OpenInference convention:\n * - llm.input_messages.{i}.message.role\n * - llm.input_messages.{i}.message.content\n * - llm.input_messages.{i}.message.tool_calls\n *\n * @param messages - Array of LLM messages\n * @param prefix - Attribute prefix ('llm.input_messages' or 'llm.output_messages')\n * @returns Flattened message attributes\n * @internal\n */\nfunction _flattenLLMMessages(\n  messages: LLMMessage[] | undefined,\n  prefix: string,\n): Record<string, string> {\n  const attributes: Record<string, string> = {};\n\n  if (!messages || !Array.isArray(messages)) {\n    return attributes;\n  }\n\n  try {\n    messages.forEach((msg, index) => {\n      if (!msg || typeof msg !== \"object\") return;\n\n      const baseKey = `${prefix}.${index}.message`;\n\n      if (msg.role !== undefined) {\n        attributes[`${baseKey}.role`] = String(msg.role);\n      }\n      if (msg.content !== undefined) {\n        attributes[`${baseKey}.content`] = String(msg.content);\n      }\n      if (msg.toolCallId !== undefined) {\n        attributes[`${baseKey}.tool_call_id`] = String(msg.toolCallId);\n      }\n\n      // Flatten tool calls if present\n      if (msg.toolCalls && Array.isArray(msg.toolCalls)) {\n        msg.toolCalls.forEach((toolCall, tcIndex) => {\n          if (!toolCall || typeof toolCall !== \"object\") return;\n\n          const tcKey = `${baseKey}.tool_calls.${tcIndex}`;\n\n          if (toolCall.id !== undefined) {\n            attributes[`${tcKey}.id`] = String(toolCall.id);\n          }\n          if (toolCall.function !== undefined) {\n            if (toolCall.function.name !== undefined) {\n              attributes[`${tcKey}.function.name`] = String(toolCall.function.name);\n            }\n            if (toolCall.function.arguments !== undefined) {\n              attributes[`${tcKey}.function.arguments`] = String(toolCall.function.arguments);\n            }\n          }\n        });\n      }\n    });\n  } catch (e) {\n    // Silent fail - don't block business logic for observability\n  }\n\n  return attributes;\n}\n\n/**\n * Flattens documents into OpenTelemetry attributes.\n *\n * Follows OpenInference convention:\n * - retrieval.documents.{i}.document.id\n * - retrieval.documents.{i}.document.content\n * - retrieval.documents.{i}.document.score\n * - retrieval.documents.{i}.document.metadata\n *\n * @param documents - Array of documents\n * @returns Flattened document attributes\n * @internal\n */\nfunction _flattenDocuments(\n  documents: Document[] | undefined,\n): Record<string, string> {\n  const attributes: Record<string, string> = {};\n\n  if (!documents || !Array.isArray(documents)) {\n    return attributes;\n  }\n\n  try {\n    documents.forEach((doc, index) => {\n      if (!doc || typeof doc !== \"object\") return;\n\n      const baseKey = `retrieval.documents.${index}.document`;\n\n      if (doc.id !== undefined) {\n        attributes[`${baseKey}.id`] = String(doc.id);\n      }\n      if (doc.content !== undefined) {\n        attributes[`${baseKey}.content`] = String(doc.content);\n      }\n      if (doc.score !== undefined) {\n        attributes[`${baseKey}.score`] = String(doc.score);\n      }\n      if (doc.metadata !== undefined && typeof doc.metadata === \"object\") {\n        const metadataSerialized = _serialize(doc.metadata);\n        if (metadataSerialized) {\n          attributes[`${baseKey}.metadata`] = metadataSerialized;\n        }\n      }\n    });\n  } catch (e) {\n    // Silent fail - don't block business logic for observability\n  }\n\n  return attributes;\n}\n\n/**\n * Flattens tool call into OpenTelemetry attributes.\n *\n * Follows OpenInference convention:\n * - tool_call.id\n * - tool_call.function.name\n * - tool_call.function.arguments\n *\n * @param toolCall - Tool call object\n * @returns Flattened tool call attributes\n * @internal\n */\nfunction _flattenToolCall(\n  toolCall: ToolCall | undefined,\n): Record<string, string> {\n  const attributes: Record<string, string> = {};\n\n  if (!toolCall || typeof toolCall !== \"object\") {\n    return attributes;\n  }\n\n  try {\n    if (toolCall.id !== undefined) {\n      attributes[\"tool_call.id\"] = String(toolCall.id);\n    }\n    if (toolCall.function !== undefined) {\n      if (toolCall.function.name !== undefined) {\n        attributes[\"tool_call.function.name\"] = String(toolCall.function.name);\n      }\n      if (toolCall.function.arguments !== undefined) {\n        attributes[\"tool_call.function.arguments\"] = String(toolCall.function.arguments);\n      }\n    }\n  } catch (e) {\n    // Silent fail - don't block business logic for observability\n  }\n\n  return attributes;\n}\n","import { TracerProvider, trace, context } from \"@opentelemetry/api\";\nimport { OBSERVABILITY_SDK_NAME, OBSERVABILITY_SDK_VERSION } from \"./constants\";\n\nconst OBSERVABILITY_GLOBAL_SYMBOL = Symbol.for(\"observability\");\n\ntype ObservabilityGlobalState = {\n  isolatedTracerProvider: TracerProvider | null;\n};\n\nfunction createState(): ObservabilityGlobalState {\n  return {\n    isolatedTracerProvider: null,\n  };\n}\n\ninterface GlobalThis {\n  [OBSERVABILITY_GLOBAL_SYMBOL]?: ObservabilityGlobalState;\n}\n\n/**\n * Gets the global state for tracing observability.\n *\n * @returns The global state object\n * @internal\n */\nfunction getObservabilityGlobalState(): ObservabilityGlobalState {\n  const initialState = createState();\n\n  try {\n    const g = globalThis as typeof globalThis & GlobalThis;\n\n    if (typeof g !== \"object\" || g === null) {\n      console.warn(\n        \"[Observability] globalThis is not available, using fallback state\",\n      );\n      return initialState;\n    }\n\n    if (!g[OBSERVABILITY_GLOBAL_SYMBOL]) {\n      Object.defineProperty(g, OBSERVABILITY_GLOBAL_SYMBOL, {\n        value: initialState,\n        writable: false,\n        configurable: false,\n        enumerable: false,\n      });\n    }\n\n    return g[OBSERVABILITY_GLOBAL_SYMBOL]!;\n  } catch (err) {\n    console.error(\n      `[Observability] Failed to access global state: ${err instanceof Error ? err.message : String(err)}`,\n    );\n    return initialState;\n  }\n}\n\n/**\n * Sets an isolated TracerProvider for tracing tracing operations.\n *\n * This allows tracing to use its own TracerProvider instance, separate from\n * the global OpenTelemetry TracerProvider.\n *\n * Note: While this isolates span processing and export, it does NOT provide\n * complete trace isolation. OpenTelemetry context (trace IDs, parent spans)\n * is still shared between the global and isolated providers.\n *\n * @param provider - The TracerProvider instance to use, or null to clear\n *\n * @example\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';\n * import { setTracerProvider } from './observability';\n *\n * const provider = new NodeTracerProvider();\n * setTracerProvider(provider);\n * ```\n *\n * @public\n */\nexport function setTracerProvider(provider: TracerProvider | null) {\n  getObservabilityGlobalState().isolatedTracerProvider = provider;\n}\n\n/**\n * Gets the TracerProvider for tracing tracing operations.\n *\n * Returns the isolated TracerProvider if one has been set via setTracerProvider(),\n * otherwise falls back to the global OpenTelemetry TracerProvider.\n *\n * @returns The TracerProvider instance to use for tracing tracing\n *\n * @example\n * ```typescript\n * import { getTracerProvider } from './observability';\n *\n * const provider = getTracerProvider();\n * const tracer = provider.getTracer('my-tracer', '1.0.0');\n * ```\n *\n * @public\n */\nexport function getTracerProvider(): TracerProvider {\n  const { isolatedTracerProvider } = getObservabilityGlobalState();\n\n  if (isolatedTracerProvider) return isolatedTracerProvider;\n\n  return trace.getTracerProvider();\n}\n\n/**\n * Gets the OpenTelemetry tracer instance for tracing.\n *\n * Returns a tracer specifically configured for tracing with the correct\n * tracer name and version.\n *\n * @returns The tracing OpenTelemetry tracer instance\n *\n * @example\n * ```typescript\n * import { getTracer } from './observability';\n *\n * const tracer = getTracer();\n * const span = tracer.startSpan('my-operation');\n * ```\n *\n * @public\n */\nexport function getTracer() {\n  return getTracerProvider().getTracer(\n    OBSERVABILITY_SDK_NAME,\n    OBSERVABILITY_SDK_VERSION\n  );\n}\n","import { Span, TimeInput, SpanStatus, SpanStatusCode } from \"@opentelemetry/api\";\n\nimport { createObservationAttributes, createTraceAttributes } from \"./attributes\";\nimport { getTracer } from \"./tracerProvider\";\nimport {\n  BaseSpanAttributes,\n  LLMAttributes,\n  TraceAttributes,\n  ObservationType,\n} from \"../types\";\nimport type {\n  ToolAttributes,\n  AgentAttributes,\n  ChainAttributes,\n  RetrieverAttributes,\n  RerankerAttributes,\n  EvaluatorAttributes,\n  GuardrailAttributes,\n  EmbeddingAttributes,\n  ObservationAttributes,\n} from \"../types\";\n\n/**\n * Union type representing any observation wrapper.\n *\n * @public\n */\nexport type Observation =\n  | ObservationLLM\n  | ObservationEmbedding\n  | ObservationAgent\n  | ObservationTool\n  | ObservationChain\n  | ObservationRetriever\n  | ObservationReranker\n  | ObservationEvaluator\n  | ObservationGuardrail;\n\n/**\n * Parameters for creating an observation wrapper.\n *\n * @internal\n */\ntype ObservationParams = {\n  otelSpan: Span;\n  type: ObservationType;\n  attributes?: BaseSpanAttributes | LLMAttributes;\n};\n\n/**\n * Base class for all observation wrappers.\n *\n * Provides common functionality for all observation types including:\n * - OpenTelemetry span integration\n * - Unique identification (span ID, trace ID)\n * - Lifecycle management (update, end)\n * - Trace context management\n * - Child observation creation\n *\n * @internal\n */\nabstract class BaseObservation {\n  /** The underlying OpenTelemetry span */\n  public readonly otelSpan: Span;\n  /** The observation type */\n  public readonly type: ObservationType;\n  /** The span ID from the OpenTelemetry span context */\n  public id: string;\n  /** The trace ID from the OpenTelemetry span context */\n  public traceId: string;\n\n  constructor(params: ObservationParams) {\n    this.otelSpan = params.otelSpan;\n    this.id = params.otelSpan.spanContext().spanId;\n    this.traceId = params.otelSpan.spanContext().traceId;\n    this.type = params.type;\n\n    if (params.attributes) {\n      this.otelSpan.setAttributes(\n        createObservationAttributes(params.type, params.attributes),\n      );\n    }\n  }\n\n  /** Gets the OpenTelemetry tracer instance */\n  protected get tracer() {\n    return getTracer();\n  }\n\n  /**\n   * Ends the observation, marking it as complete.\n   *\n   * @param endTime - Optional end time, defaults to current time\n   */\n  public end(endTime?: TimeInput) {\n    this.otelSpan.end(endTime);\n  }\n\n  /**\n   * Sets the span status.\n   *\n   * @param status - The status to set on the span\n   */\n  public setStatus(status: SpanStatus) {\n    this.otelSpan.setStatus(status);\n  }\n\n  /**\n   * Sets the span status to ERROR.\n   *\n   * Convenience method for marking the span as failed.\n   *\n   * @param message - Error description message\n   */\n  public setErrorStatus(message: string) {\n    this.otelSpan.setStatus({\n      code: SpanStatusCode.ERROR,\n      message,\n    });\n  }\n\n  /**\n   * Updates the OTEL span attributes.\n   *\n   * @param attributes - Attributes to update\n   * @internal\n   */\n  updateOtelSpanAttributes(attributes: ObservationAttributes) {\n    this.otelSpan.setAttributes(\n      createObservationAttributes(this.type, attributes),\n    );\n  }\n\n  /**\n   * Updates the parent trace with new attributes.\n   *\n   * @param attributes - Trace attributes to set\n   * @returns This observation for method chaining\n   */\n  public updateTrace(attributes: TraceAttributes) {\n    this.otelSpan.setAttributes(createTraceAttributes(attributes));\n    return this;\n  }\n\n  /**\n   * Creates a new child observation within this observation's context.\n   *\n   * @param name - Name for the child observation\n   * @param attributes - Type-specific attributes\n   * @param options - Configuration including observation type\n   * @returns Child observation instance\n   */\n  public startObservation(\n    name: string,\n    attributes: LLMAttributes,\n    options: { asType: \"llm\" },\n  ): ObservationLLM;\n  public startObservation(\n    name: string,\n    attributes: EmbeddingAttributes,\n    options: { asType: \"embedding\" },\n  ): ObservationEmbedding;\n  public startObservation(\n    name: string,\n    attributes: AgentAttributes,\n    options: { asType: \"agent\" },\n  ): ObservationAgent;\n  public startObservation(\n    name: string,\n    attributes: ToolAttributes,\n    options: { asType: \"tool\" },\n  ): ObservationTool;\n  public startObservation(\n    name: string,\n    attributes: ChainAttributes,\n    options: { asType: \"chain\" },\n  ): ObservationChain;\n  public startObservation(\n    name: string,\n    attributes: RetrieverAttributes,\n    options: { asType: \"retriever\" },\n  ): ObservationRetriever;\n  public startObservation(\n    name: string,\n    attributes: RerankerAttributes,\n    options: { asType: \"reranker\" },\n  ): ObservationReranker;\n  public startObservation(\n    name: string,\n    attributes: EvaluatorAttributes,\n    options: { asType: \"evaluator\" },\n  ): ObservationEvaluator;\n  public startObservation(\n    name: string,\n    attributes: GuardrailAttributes,\n    options: { asType: \"guardrail\" },\n  ): ObservationGuardrail;\n  public startObservation(\n    name: string,\n    attributes?: BaseSpanAttributes,\n    options?: { asType?: \"chain\" },\n  ): ObservationChain;\n  public startObservation(\n    name: string,\n    attributes?:\n      | BaseSpanAttributes\n      | LLMAttributes\n      | ToolAttributes\n      | AgentAttributes\n      | ChainAttributes\n      | RetrieverAttributes\n      | RerankerAttributes\n      | EvaluatorAttributes\n      | GuardrailAttributes\n      | EmbeddingAttributes,\n    options?: { asType?: ObservationType },\n  ): Observation {\n    // Import here to avoid circular dependency\n    const { startObservation: startObs } = require(\"../index\");\n    const { asType = \"chain\" } = options || {};\n\n    return startObs(name, attributes, {\n      asType: asType as \"chain\",\n      parentSpanContext: this.otelSpan.spanContext(),\n    });\n  }\n}\n\n// Type-specific observation classes\n\ntype ObservationLLMParams = {\n  otelSpan: Span;\n  attributes?: LLMAttributes;\n};\n\n/**\n * LLM observation for tracking language model calls.\n *\n * @public\n */\nexport class ObservationLLM extends BaseObservation {\n  constructor(params: ObservationLLMParams) {\n    super({ ...params, type: \"llm\" });\n  }\n\n  public update(attributes: LLMAttributes): ObservationLLM {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n\ntype ObservationEmbeddingParams = {\n  otelSpan: Span;\n  attributes?: EmbeddingAttributes;\n};\n\n/**\n * Embedding observation for tracking embedding operations.\n *\n * @public\n */\nexport class ObservationEmbedding extends BaseObservation {\n  constructor(params: ObservationEmbeddingParams) {\n    super({ ...params, type: \"embedding\" });\n  }\n\n  public update(attributes: EmbeddingAttributes): ObservationEmbedding {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n\ntype ObservationAgentParams = {\n  otelSpan: Span;\n  attributes?: AgentAttributes;\n};\n\n/**\n * Agent observation for tracking AI agent workflows.\n *\n * @public\n */\nexport class ObservationAgent extends BaseObservation {\n  constructor(params: ObservationAgentParams) {\n    super({ ...params, type: \"agent\" });\n  }\n\n  public update(attributes: AgentAttributes): ObservationAgent {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n\ntype ObservationToolParams = {\n  otelSpan: Span;\n  attributes?: ToolAttributes;\n};\n\n/**\n * Tool observation for tracking tool calls.\n *\n * @public\n */\nexport class ObservationTool extends BaseObservation {\n  constructor(params: ObservationToolParams) {\n    super({ ...params, type: \"tool\" });\n  }\n\n  public update(attributes: ToolAttributes): ObservationTool {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n\ntype ObservationChainParams = {\n  otelSpan: Span;\n  attributes?: ChainAttributes;\n};\n\n/**\n * Chain observation for tracking multi-step workflows.\n *\n * @public\n */\nexport class ObservationChain extends BaseObservation {\n  constructor(params: ObservationChainParams) {\n    super({ ...params, type: \"chain\" });\n  }\n\n  public update(attributes: ChainAttributes): ObservationChain {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n\ntype ObservationRetrieverParams = {\n  otelSpan: Span;\n  attributes?: RetrieverAttributes;\n};\n\n/**\n * Retriever observation for tracking document retrieval.\n *\n * @public\n */\nexport class ObservationRetriever extends BaseObservation {\n  constructor(params: ObservationRetrieverParams) {\n    super({ ...params, type: \"retriever\" });\n  }\n\n  public update(attributes: RetrieverAttributes): ObservationRetriever {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n\ntype ObservationRerankerParams = {\n  otelSpan: Span;\n  attributes?: RerankerAttributes;\n};\n\n/**\n * Reranker observation for tracking reranking operations.\n *\n * @public\n */\nexport class ObservationReranker extends BaseObservation {\n  constructor(params: ObservationRerankerParams) {\n    super({ ...params, type: \"reranker\" });\n  }\n\n  public update(attributes: RerankerAttributes): ObservationReranker {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n\ntype ObservationEvaluatorParams = {\n  otelSpan: Span;\n  attributes?: EvaluatorAttributes;\n};\n\n/**\n * Evaluator observation for tracking evaluation operations.\n *\n * @public\n */\nexport class ObservationEvaluator extends BaseObservation {\n  constructor(params: ObservationEvaluatorParams) {\n    super({ ...params, type: \"evaluator\" });\n  }\n\n  public update(attributes: EvaluatorAttributes): ObservationEvaluator {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n\ntype ObservationGuardrailParams = {\n  otelSpan: Span;\n  attributes?: GuardrailAttributes;\n};\n\n/**\n * Guardrail observation for tracking safety checks.\n *\n * @public\n */\nexport class ObservationGuardrail extends BaseObservation {\n  constructor(params: ObservationGuardrailParams) {\n    super({ ...params, type: \"guardrail\" });\n  }\n\n  public update(attributes: GuardrailAttributes): ObservationGuardrail {\n    super.updateOtelSpanAttributes(attributes);\n    return this;\n  }\n}\n","/**\n * Trace context extraction and validation utilities.\n *\n * This module provides utilities for extracting and validating W3C-compatible\n * trace context from HTTP headers, supporting external trace inheritance.\n *\n * @packageDocumentation\n */\n\nimport { Link, SpanContext, TraceFlags } from \"@opentelemetry/api\";\n\n/**\n * Result of trace context validation.\n */\nexport interface TraceContextValidation {\n  traceId?: string;\n  parentSpanId?: string;\n  errors: string[];\n  isValid: boolean;\n  hasTraceId: boolean;\n  hasParentSpanId: boolean;\n}\n\n/**\n * Processed trace context result with all necessary data for span creation.\n *\n * This encapsulates the complete result of extracting, validating, and processing\n * external trace context from HTTP headers.\n */\nexport interface ProcessedTraceContext {\n  /** Validated trace ID (undefined if invalid or not provided) */\n  traceId?: string;\n  /** Validated parent span ID (undefined if invalid or not provided) */\n  parentSpanId?: string;\n  /** Whether external trace context was successfully inherited */\n  isInherited: boolean;\n  /** Whether parent span link was created */\n  hasParentLink: boolean;\n  /** Span attributes ready to merge into span attributes object */\n  spanAttributes: Record<string, any>;\n  /** Span links ready to pass to start_observation */\n  links: Link[];\n}\n\n/**\n * Validate W3C Trace Context trace-id format.\n *\n * Must be 32 hex characters (128-bit) and not all zeros.\n *\n * Performance: Uses parseInt() instead of regex for 45% faster validation\n * and better handling of edge cases (extremely long strings).\n *\n * @param traceId - The trace ID string to validate\n * @returns True if valid, false otherwise\n *\n * @example\n * ```typescript\n * validateTraceId('7EBd0D2dd5A198C3Cc66a51EeEcdd0F4') // true\n * validateTraceId('invalid') // false\n * validateTraceId('00000000000000000000000000000000') // false\n * ```\n *\n * @public\n */\nexport function validateTraceId(traceId: string): boolean {\n  if (!traceId || typeof traceId !== \"string\") {\n    return false;\n  }\n\n  // Length check (fast fail for wrong length)\n  if (traceId.length !== 32) {\n    return false;\n  }\n\n  // Try to parse as hex (validates format + rejects invalid chars)\n  // Split into two 16-char chunks to avoid precision loss with large numbers\n  const chunk1 = traceId.slice(0, 16);\n  const chunk2 = traceId.slice(16, 32);\n\n  const value1 = parseInt(chunk1, 16);\n  const value2 = parseInt(chunk2, 16);\n\n  // Check if parsing failed (NaN)\n  if (isNaN(value1) || isNaN(value2)) {\n    return false;\n  }\n\n  // Check not all zeros (invalid trace-id per W3C spec)\n  if (value1 === 0 && value2 === 0) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Validate W3C Trace Context span-id format.\n *\n * Must be 16 hex characters (64-bit) and not all zeros.\n *\n * Performance: Uses parseInt() instead of regex for 45% faster validation\n * and better handling of edge cases (extremely long strings).\n *\n * @param spanId - The span ID string to validate\n * @returns True if valid, false otherwise\n *\n * @example\n * ```typescript\n * validateSpanId('00f067aa0ba902b7') // true\n * validateSpanId('invalid') // false\n * validateSpanId('0000000000000000') // false\n * ```\n *\n * @public\n */\nexport function validateSpanId(spanId: string): boolean {\n  if (!spanId || typeof spanId !== \"string\") {\n    return false;\n  }\n\n  // Length check (fast fail for wrong length)\n  if (spanId.length !== 16) {\n    return false;\n  }\n\n  // Try to parse as hex (validates format + rejects invalid chars)\n  const value = parseInt(spanId, 16);\n\n  // Check if parsing failed (NaN)\n  if (isNaN(value)) {\n    return false;\n  }\n\n  // Check not all zeros (invalid span-id per W3C spec)\n  if (value === 0) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Validate and normalize external trace context.\n *\n * Supports four scenarios:\n * 1. Both missing → Valid (generate new trace)\n * 2. Only traceId → Valid (inherit trace, new root span)\n * 3. Both provided → Valid (inherit trace + parent link)\n * 4. Only parentSpanId → Invalid (parent without trace)\n *\n * @param traceId - External trace ID from x-trace-id header\n * @param parentSpanId - External parent span ID from x-parent-span-id header\n * @returns Validation result with normalized values and any errors\n *\n * @example\n * ```typescript\n * // Scenario 1: Generate new trace\n * const result = validateTraceContext(undefined, undefined);\n * result.isValid // true\n * result.hasTraceId // false\n *\n * // Scenario 2: Inherit trace only\n * const result = validateTraceContext('9bBab669fdD6eAEB3Ac0A522f5DeE0BF', undefined);\n * result.isValid // true\n * result.traceId // '9bbab669fdd6eaeb3ac0a522f5dee0bf'\n *\n * // Scenario 3: Inherit trace + parent\n * const result = validateTraceContext(\n *   '9bBab669fdD6eAEB3Ac0A522f5DeE0BF',\n *   '00f067aa0ba902b7'\n * );\n * result.isValid // true\n * result.hasParentSpanId // true\n *\n * // Scenario 4: Invalid - parent without trace\n * const result = validateTraceContext(undefined, '00f067aa0ba902b7');\n * result.isValid // false\n * result.errors.length > 0 // true\n * ```\n *\n * @public\n */\nexport function validateTraceContext(\n  traceId?: string,\n  parentSpanId?: string\n): TraceContextValidation {\n  const result: TraceContextValidation = {\n    errors: [],\n    isValid: false,\n    hasTraceId: false,\n    hasParentSpanId: false,\n  };\n\n  // Scenario 1: Both missing - valid (generate new trace)\n  if (!traceId && !parentSpanId) {\n    result.isValid = true;\n    return result;\n  }\n\n  // Scenario 4: Only parentSpanId provided - invalid\n  if (!traceId && parentSpanId) {\n    result.errors.push(\n      \"parentSpanId provided without traceId - \" +\n        \"traceId is required when inheriting parent span\"\n    );\n    return result;\n  }\n\n  // Scenario 2 & 3: traceId provided (with or without parentSpanId)\n  if (traceId) {\n    if (!validateTraceId(traceId)) {\n      result.errors.push(\n        `Invalid traceId format: '${traceId}' - ` +\n          `must be 32 hex characters and not all zeros`\n      );\n    } else {\n      // Normalize to lowercase for consistency\n      result.traceId = traceId.toLowerCase();\n      result.hasTraceId = true;\n    }\n  }\n\n  // Validate parentSpanId if provided\n  if (parentSpanId) {\n    if (!validateSpanId(parentSpanId)) {\n      result.errors.push(\n        `Invalid parentSpanId format: '${parentSpanId}' - ` +\n          `must be 16 hex characters and not all zeros`\n      );\n    } else {\n      // Normalize to lowercase for consistency\n      result.parentSpanId = parentSpanId.toLowerCase();\n      result.hasParentSpanId = true;\n    }\n  }\n\n  result.isValid = result.errors.length === 0;\n  return result;\n}\n\n/**\n * Create an OpenTelemetry Link to an external span.\n *\n * This creates a loose coupling to an external span, avoiding the\n * \"orphaned span\" problem when the parent span data is not available\n * in the current tracing backend.\n *\n * @param traceId - External trace ID (32 hex chars)\n * @param parentSpanId - External parent span ID (16 hex chars)\n * @param linkType - Semantic relationship type (default: \"follows_from\")\n * @param sourceSystem - Name of the external system (default: \"gateway\")\n * @returns OpenTelemetry Link object\n *\n * @example\n * ```typescript\n * const link = createSpanLinkFromContext(\n *   '9bBab669fdD6eAEB3Ac0A522f5DeE0BF',\n *   '00f067aa0ba902b7'\n * );\n * // Use link when creating span\n * const span = tracer.startSpan('my-operation', { links: [link] });\n * ```\n *\n * @public\n */\nexport function createSpanLinkFromContext(\n  traceId: string,\n  parentSpanId: string,\n  linkType: string = \"follows_from\",\n  sourceSystem: string = \"gateway\"\n): Link {\n  // Create SpanContext for external parent\n  // Note: OpenTelemetry expects traceId and spanId as hex strings\n  const externalContext: SpanContext = {\n    traceId: traceId,\n    spanId: parentSpanId,\n    traceFlags: TraceFlags.SAMPLED,\n  };\n\n  // Create link with metadata\n  const link: Link = {\n    context: externalContext,\n    attributes: {\n      \"link.type\": linkType,\n      \"link.source\": sourceSystem,\n      \"link.trace_id\": traceId,\n      \"link.span_id\": parentSpanId,\n    },\n  };\n\n  return link;\n}\n\n/**\n * Extract trace context from HTTP headers.\n *\n * Only supports custom x-trace-id and x-parent-span-id headers.\n * Does not support W3C traceparent header.\n *\n * @param headers - HTTP headers (case-insensitive)\n * @param traceIdHeader - Header name for trace ID (default: \"x-trace-id\")\n * @param parentSpanIdHeader - Header name for parent span ID (default: \"x-parent-span-id\")\n * @returns Tuple of [traceId, parentSpanId], both may be undefined\n *\n * @example\n * ```typescript\n * const headers = new Headers({\n *   'x-trace-id': '9bBab669fdD6eAEB3Ac0A522f5DeE0BF',\n *   'x-parent-span-id': '00f067aa0ba902b7'\n * });\n * const [traceId, parentSpanId] = extractTraceContextFromHeaders(headers);\n * ```\n *\n * @public\n */\nexport function extractTraceContextFromHeaders(\n  headers: Headers | Record<string, string>,\n  traceIdHeader: string = \"x-trace-id\",\n  parentSpanIdHeader: string = \"x-parent-span-id\"\n): [string | undefined, string | undefined] {\n  if (!headers) {\n    return [undefined, undefined];\n  }\n\n  let traceId: string | undefined;\n  let parentSpanId: string | undefined;\n\n  // Handle both Headers object and plain object\n  if (headers instanceof Headers) {\n    traceId = headers.get(traceIdHeader) || undefined;\n    parentSpanId = headers.get(parentSpanIdHeader) || undefined;\n  } else {\n    // Plain object - case-insensitive lookup\n    const headersLower: Record<string, string> = {};\n    for (const [key, value] of Object.entries(headers)) {\n      headersLower[key.toLowerCase()] = value;\n    }\n\n    traceId = headersLower[traceIdHeader.toLowerCase()];\n    parentSpanId = headersLower[parentSpanIdHeader.toLowerCase()];\n  }\n\n  return [traceId, parentSpanId];\n}\n\n/**\n * Extract, validate, and process trace context from HTTP headers.\n *\n * This is a high-level convenience method that combines extraction, validation,\n * link creation, and attribute preparation into a single call. It handles all\n * error cases and returns a ready-to-use ProcessedTraceContext object.\n *\n * @param headers - HTTP headers (case-insensitive)\n * @param logger - Optional logger for validation errors\n * @param linkType - Semantic relationship type for SpanLink (default: \"follows_from\")\n * @param sourceSystem - Name of the external system (default: \"gateway\")\n * @returns ProcessedTraceContext with all processed data ready for span creation\n *\n * @example\n * ```typescript\n * // Basic usage\n * const result = processTraceContextFromHeaders(request.headers, logger);\n * if (result.isInherited) {\n *   Object.assign(spanAttributes, result.spanAttributes);\n * }\n * const serverSpan = startObservation(\n *   \"AG-UI.Server\",\n *   spanAttributes,\n *   { links: result.links.length > 0 ? result.links : undefined }\n * );\n *\n * // Scenario 1: No headers\n * const result = processTraceContextFromHeaders(new Headers());\n * result.isInherited // false\n * result.links // []\n *\n * // Scenario 2: Only trace_id\n * const headers = new Headers({ 'x-trace-id': '9bBab669fdD6eAEB3Ac0A522f5DeE0BF' });\n * const result = processTraceContextFromHeaders(headers);\n * result.isInherited // true\n * result.hasParentLink // false\n * result.spanAttributes['trace.external_trace_id'] // '7ebd0d2dd5a198c3cc66a51eeecdd0f4'\n *\n * // Scenario 3: Both headers\n * const headers = new Headers({\n *   'x-trace-id': '9bBab669fdD6eAEB3Ac0A522f5DeE0BF',\n *   'x-parent-span-id': '00f067aa0ba902b7'\n * });\n * const result = processTraceContextFromHeaders(headers);\n * result.isInherited // true\n * result.hasParentLink // true\n * result.links.length // 1\n *\n * // Scenario 4: Invalid (only parent_span_id)\n * const headers = new Headers({ 'x-parent-span-id': '00f067aa0ba902b7' });\n * const result = processTraceContextFromHeaders(headers);\n * result.isInherited // false\n * result.links // []\n * ```\n *\n * @public\n */\nexport function processTraceContextFromHeaders(\n  headers: Headers | Record<string, string>,\n  logger?: { warn?: (msg: string) => void },\n  linkType: string = \"follows_from\",\n  sourceSystem: string = \"gateway\"\n): ProcessedTraceContext {\n  // Step 1: Extract trace context from headers\n  const [traceId, parentSpanId] = extractTraceContextFromHeaders(headers);\n\n  // Step 2: Validate extracted values\n  const validation = validateTraceContext(traceId, parentSpanId);\n\n  // Step 3: Handle validation errors\n  if (!validation.isValid) {\n    // Log all validation errors\n    if (logger && logger.warn) {\n      validation.errors.forEach((error) => {\n        logger.warn!(`Trace context validation failed: ${error}`);\n      });\n    }\n\n    // Return empty result for invalid context\n    return {\n      traceId: undefined,\n      parentSpanId: undefined,\n      isInherited: false,\n      hasParentLink: false,\n      spanAttributes: {},\n      links: [],\n    };\n  }\n\n  // Step 4: Process valid trace context\n  const normalizedTraceId = validation.traceId;\n  const normalizedParentSpanId = validation.parentSpanId;\n\n  // Prepare span attributes\n  const attributes: Record<string, any> = {};\n  const links: Link[] = [];\n\n  // Add trace inheritance markers\n  if (normalizedTraceId) {\n    attributes[\"trace.inherited\"] = true;\n    attributes[\"trace.external_trace_id\"] = normalizedTraceId;\n  }\n\n  // Create link to external parent if provided\n  if (normalizedTraceId && normalizedParentSpanId) {\n    const link = createSpanLinkFromContext(\n      normalizedTraceId,\n      normalizedParentSpanId,\n      linkType,\n      sourceSystem\n    );\n    links.push(link);\n    attributes[\"trace.external_parent_span_id\"] = normalizedParentSpanId;\n  }\n\n  return {\n    traceId: normalizedTraceId,\n    parentSpanId: normalizedParentSpanId,\n    isInherited: !!normalizedTraceId,\n    hasParentLink: !!normalizedParentSpanId,\n    spanAttributes: attributes,\n    links,\n  };\n}\n","/**\n * Observability - OpenTelemetry-based tracing with OpenInference semantic conventions\n *\n * @packageDocumentation\n */\n\nimport { trace, context, TimeInput, SpanStatusCode, Span, SpanContext, Link } from \"@opentelemetry/api\";\n\nimport {\n  createObservationAttributes,\n  createTraceAttributes,\n} from \"./core/attributes\";\nimport {\n  ObservationLLM,\n  ObservationEmbedding,\n  ObservationAgent,\n  ObservationTool,\n  ObservationChain,\n  ObservationRetriever,\n  ObservationReranker,\n  ObservationEvaluator,\n  ObservationGuardrail,\n  type Observation,\n} from \"./core/spanWrapper\";\nimport { getTracer } from \"./core/tracerProvider\";\nimport {\n  ObservationType,\n  ObservationLevel,\n  BaseSpanAttributes,\n  LLMAttributes,\n  ToolAttributes,\n  AgentAttributes,\n  ChainAttributes,\n  RetrieverAttributes,\n  RerankerAttributes,\n  EvaluatorAttributes,\n  GuardrailAttributes,\n  EmbeddingAttributes,\n  ObservationAttributes,\n  TraceAttributes,\n  LLMMessage,\n  ToolCall,\n  Document,\n} from \"./types\";\n\n// Export types\nexport type {\n  ObservationType,\n  ObservationLevel,\n  BaseSpanAttributes,\n  LLMAttributes,\n  ToolAttributes,\n  AgentAttributes,\n  ChainAttributes,\n  RetrieverAttributes,\n  RerankerAttributes,\n  EvaluatorAttributes,\n  GuardrailAttributes,\n  EmbeddingAttributes,\n  ObservationAttributes,\n  TraceAttributes,\n  LLMMessage,\n  ToolCall,\n  Document,\n};\n\n// Export observation classes\nexport {\n  ObservationLLM,\n  ObservationEmbedding,\n  ObservationAgent,\n  ObservationTool,\n  ObservationChain,\n  ObservationRetriever,\n  ObservationReranker,\n  ObservationEvaluator,\n  ObservationGuardrail,\n};\n\n// Export observation union type\nexport type { Observation };\n\n// Export core functions\nexport {\n  createTraceAttributes,\n  createObservationAttributes,\n} from \"./core/attributes\";\nexport {\n  setTracerProvider,\n  getTracerProvider,\n  getTracer,\n} from \"./core/tracerProvider\";\n\n// Export trace context utilities\nexport {\n  validateTraceId,\n  validateSpanId,\n  validateTraceContext,\n  createSpanLinkFromContext,\n  extractTraceContextFromHeaders,\n  processTraceContextFromHeaders,\n  type TraceContextValidation,\n  type ProcessedTraceContext,\n} from \"./core/trace-context\";\n\n/**\n * Options for starting observations (spans).\n *\n * @public\n */\nexport type StartObservationOptions = {\n  /** Custom start time for the observation */\n  startTime?: Date;\n  /** Parent span context to attach this observation to */\n  parentSpanContext?: SpanContext;\n  /** Optional links to external or related spans */\n  links?: Link[];\n};\n\n/**\n * Options for startObservation function.\n *\n * @public\n */\nexport type StartObservationOpts = StartObservationOptions & {\n  /** Type of observation to create. Defaults to 'chain' */\n  asType?: ObservationType;\n};\n\n/**\n * Creates an OpenTelemetry span with the tracer.\n *\n * @param params - Parameters for span creation\n * @returns The created OpenTelemetry span\n * @internal\n */\nfunction createOtelSpan(params: {\n  name: string;\n  startTime?: TimeInput;\n  parentSpanContext?: SpanContext;\n  links?: Link[];\n}): Span {\n  return getTracer().startSpan(\n    params.name,\n    {\n      startTime: params.startTime,\n      links: params.links || [],\n    },\n    createParentContext(params.parentSpanContext),\n  );\n}\n\n/**\n * Creates a parent context from a span context.\n *\n * @param parentSpanContext - The span context to use as parent\n * @returns The created context or undefined if no parent provided\n * @internal\n */\nfunction createParentContext(\n  parentSpanContext?: SpanContext,\n): ReturnType<typeof trace.setSpanContext> | undefined {\n  if (!parentSpanContext) return;\n  return trace.setSpanContext(context.active(), parentSpanContext);\n}\n\n// Function overloads for proper type inference\n// Generic overload for dynamic asType (returns Observation union)\nexport function startObservation(\n  name: string,\n  attributes?: BaseSpanAttributes,\n  options?: StartObservationOpts & { asType?: ObservationType },\n): Observation;\n\n// Type-specific overloads for precise type inference\nexport function startObservation(\n  name: string,\n  attributes: LLMAttributes,\n  options: StartObservationOpts & { asType: \"llm\" },\n): ObservationLLM;\nexport function startObservation(\n  name: string,\n  attributes: EmbeddingAttributes,\n  options: StartObservationOpts & { asType: \"embedding\" },\n): ObservationEmbedding;\nexport function startObservation(\n  name: string,\n  attributes: AgentAttributes,\n  options: StartObservationOpts & { asType: \"agent\" },\n): ObservationAgent;\nexport function startObservation(\n  name: string,\n  attributes: ToolAttributes,\n  options: StartObservationOpts & { asType: \"tool\" },\n): ObservationTool;\nexport function startObservation(\n  name: string,\n  attributes: ChainAttributes,\n  options: StartObservationOpts & { asType: \"chain\" },\n): ObservationChain;\nexport function startObservation(\n  name: string,\n  attributes: RetrieverAttributes,\n  options: StartObservationOpts & { asType: \"retriever\" },\n): ObservationRetriever;\nexport function startObservation(\n  name: string,\n  attributes: RerankerAttributes,\n  options: StartObservationOpts & { asType: \"reranker\" },\n): ObservationReranker;\nexport function startObservation(\n  name: string,\n  attributes: EvaluatorAttributes,\n  options: StartObservationOpts & { asType: \"evaluator\" },\n): ObservationEvaluator;\nexport function startObservation(\n  name: string,\n  attributes: GuardrailAttributes,\n  options: StartObservationOpts & { asType: \"guardrail\" },\n): ObservationGuardrail;\nexport function startObservation(\n  name: string,\n  attributes?: BaseSpanAttributes,\n  options?: StartObservationOpts & { asType?: \"chain\" },\n): ObservationChain;\n\n/**\n * Creates and starts a new observation.\n *\n * Supports multiple observation types with full TypeScript type safety:\n * - **chain**: Multi-step workflows (default for generic operations)\n * - **llm**: LLM calls and AI model interactions\n * - **embedding**: Text embedding and vector operations\n * - **agent**: AI agent workflows\n * - **tool**: Individual tool calls\n * - **retriever**: Document retrieval\n * - **reranker**: Result reranking\n * - **evaluator**: Quality assessment\n * - **guardrail**: Safety checks\n *\n * @param name - Descriptive name for the observation\n * @param attributes - Type-specific attributes\n * @param options - Configuration options\n * @returns Strongly-typed observation object\n *\n * @example\n * ```typescript\n * import { startObservation } from './observability';\n *\n * // LLM observation\n * const llm = startObservation('openai-gpt-4', {\n *   input: [{ role: 'user', content: 'Hello' }],\n *   model: 'gpt-4',\n *   modelParameters: { temperature: 0.7 }\n * }, { asType: 'llm' });\n *\n * // Tool observation\n * const tool = startObservation('weather-api', {\n *   input: { location: 'SF' }\n * }, { asType: 'tool' });\n *\n * // Chain observation\n * const chain = startObservation('rag-pipeline', {\n *   input: { question: 'What is AI?' }\n * }, { asType: 'chain' });\n * ```\n *\n * @public\n */\nexport function startObservation(\n  name: string,\n  attributes?:\n    | BaseSpanAttributes\n    | LLMAttributes\n    | EmbeddingAttributes\n    | AgentAttributes\n    | ToolAttributes\n    | ChainAttributes\n    | RetrieverAttributes\n    | RerankerAttributes\n    | EvaluatorAttributes\n    | GuardrailAttributes,\n  options?: StartObservationOpts,\n): Observation {\n  const { asType = \"chain\", ...observationOptions } = options || {};\n\n  const otelSpan = createOtelSpan({\n    name,\n    ...observationOptions,\n  });\n\n  switch (asType) {\n    case \"llm\":\n      return new ObservationLLM({\n        otelSpan,\n        attributes: attributes as LLMAttributes,\n      });\n\n    case \"embedding\":\n      return new ObservationEmbedding({\n        otelSpan,\n        attributes: attributes as EmbeddingAttributes,\n      });\n\n    case \"agent\":\n      return new ObservationAgent({\n        otelSpan,\n        attributes: attributes as AgentAttributes,\n      });\n\n    case \"tool\":\n      return new ObservationTool({\n        otelSpan,\n        attributes: attributes as ToolAttributes,\n      });\n\n    case \"chain\":\n      return new ObservationChain({\n        otelSpan,\n        attributes: attributes as ChainAttributes,\n      });\n\n    case \"retriever\":\n      return new ObservationRetriever({\n        otelSpan,\n        attributes: attributes as RetrieverAttributes,\n      });\n\n    case \"reranker\":\n      return new ObservationReranker({\n        otelSpan,\n        attributes: attributes as RerankerAttributes,\n      });\n\n    case \"evaluator\":\n      return new ObservationEvaluator({\n        otelSpan,\n        attributes: attributes as EvaluatorAttributes,\n      });\n\n    case \"guardrail\":\n      return new ObservationGuardrail({\n        otelSpan,\n        attributes: attributes as GuardrailAttributes,\n      });\n\n    default:\n      return new ObservationChain({\n        otelSpan,\n        attributes: attributes as BaseSpanAttributes,\n      });\n  }\n}\n\n/**\n * Updates the currently active trace with new attributes.\n *\n * @param attributes - Trace attributes to set\n *\n * @example\n * ```typescript\n * import { updateActiveTrace } from './observability';\n *\n * updateActiveTrace({\n *   name: 'user-workflow',\n *   userId: 'user-123',\n *   tags: ['production']\n * });\n * ```\n *\n * @public\n */\nexport function updateActiveTrace(attributes: TraceAttributes) {\n  const span = trace.getActiveSpan();\n\n  if (!span) {\n    console.warn(\n      \"[Observability] No active OTEL span in context. Skipping trace update.\",\n    );\n    return;\n  }\n\n  span.setAttributes(createTraceAttributes(attributes));\n}\n\n/**\n * Gets the current active trace ID.\n *\n * @returns The trace ID of the currently active span, or undefined\n *\n * @public\n */\nexport function getActiveTraceId(): string | undefined {\n  return trace.getActiveSpan()?.spanContext().traceId;\n}\n\n/**\n * Gets the current active observation ID.\n *\n * @returns The span ID of the currently active span, or undefined\n *\n * @public\n */\nexport function getActiveSpanId(): string | undefined {\n  return trace.getActiveSpan()?.spanContext().spanId;\n}\n\n// ============================================================================\n// Active Observation Functions\n// ============================================================================\n\n/**\n * Options for startActiveObservation.\n *\n * @public\n */\nexport type StartActiveObservationOpts = StartObservationOpts & {\n  /** Whether to automatically end the observation when the function exits. Default: true */\n  endOnExit?: boolean;\n};\n\n/**\n * Wraps a Promise to automatically end the span when it resolves/rejects.\n *\n * @param promise - The promise to wrap\n * @param span - The OpenTelemetry span\n * @param endOnExit - Whether to end the span on exit\n * @returns The wrapped promise\n * @internal\n */\nfunction wrapPromise<T>(\n  promise: Promise<T>,\n  span: Span,\n  endOnExit: boolean | undefined,\n): Promise<T> {\n  return promise.then(\n    (value) => {\n      if (endOnExit !== false) {\n        span.end();\n      }\n      return value;\n    },\n    (err: unknown) => {\n      span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: err instanceof Error ? err.message : \"Unknown error\",\n      });\n      if (endOnExit !== false) {\n        span.end();\n      }\n      throw err;\n    },\n  );\n}\n\n// Function overloads for startActiveObservation\nexport function startActiveObservation<\n  F extends (observation: ObservationLLM) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\nexport function startActiveObservation<\n  F extends (observation: ObservationEmbedding) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\nexport function startActiveObservation<\n  F extends (observation: ObservationAgent) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\nexport function startActiveObservation<\n  F extends (observation: ObservationTool) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\nexport function startActiveObservation<\n  F extends (observation: ObservationChain) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\nexport function startActiveObservation<\n  F extends (observation: ObservationRetriever) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\nexport function startActiveObservation<\n  F extends (observation: ObservationReranker) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\nexport function startActiveObservation<\n  F extends (observation: ObservationEvaluator) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\nexport function startActiveObservation<\n  F extends (observation: ObservationGuardrail) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F>;\n\n/**\n * Creates an observation with automatic lifecycle management.\n *\n * This function creates an observation and executes a function with that observation\n * as a parameter. The observation is automatically ended when the function completes\n * (unless `endOnExit` is set to `false`).\n *\n * Supports both synchronous and asynchronous functions, with automatic error handling.\n *\n * @param name - Descriptive name for the observation\n * @param fn - Function to execute with the observation\n * @param options - Configuration options\n * @returns The result of the function\n *\n * @example\n * ```typescript\n * import { startActiveObservation } from './observability';\n *\n * // Synchronous function\n * const result = startActiveObservation('data-processing', (chain) => {\n *   chain.update({ input: { data: [1, 2, 3] } });\n *   const processed = data.map(x => x * 2);\n *   chain.update({ output: { result: processed } });\n *   return processed;\n * }, { asType: 'chain' });\n *\n * // Asynchronous function\n * const embeddings = await startActiveObservation(\n *   'text-embeddings',\n *   async (embedding) => {\n *     embedding.update({\n *       input: { texts: ['Hello', 'World'] },\n *       model: 'text-embedding-ada-002'\n *     });\n *\n *     const vectors = await generateEmbeddings(texts);\n *\n *     embedding.update({ output: { embeddings: vectors } });\n *     return vectors;\n *   },\n *   { asType: 'embedding' }\n * );\n *\n * // Disable automatic ending (for long-running operations)\n * startActiveObservation(\n *   'background-task',\n *   (chain) => {\n *     chain.update({ input: { taskId: '123' } });\n *     startBackgroundProcess(chain);\n *     return 'started';\n *   },\n *   { asType: 'chain', endOnExit: false }\n * );\n * ```\n *\n * @see {@link startObservation} for manual observation lifecycle management\n * @see {@link observe} for decorator-style function wrapping\n *\n * @public\n */\nexport function startActiveObservation<\n  F extends (observation: Observation) => unknown,\n>(name: string, fn: F, options?: StartActiveObservationOpts): ReturnType<F> {\n  const { asType = \"chain\", endOnExit, ...observationOptions } = options || {};\n\n  return getTracer().startActiveSpan(\n    name,\n    { startTime: observationOptions?.startTime },\n    createParentContext(observationOptions?.parentSpanContext) ??\n      context.active(),\n    (span) => {\n      try {\n        let observation: Observation;\n\n        switch (asType) {\n          case \"llm\":\n            observation = new ObservationLLM({ otelSpan: span });\n            break;\n          case \"embedding\":\n            observation = new ObservationEmbedding({ otelSpan: span });\n            break;\n          case \"agent\":\n            observation = new ObservationAgent({ otelSpan: span });\n            break;\n          case \"tool\":\n            observation = new ObservationTool({ otelSpan: span });\n            break;\n          case \"retriever\":\n            observation = new ObservationRetriever({ otelSpan: span });\n            break;\n          case \"reranker\":\n            observation = new ObservationReranker({ otelSpan: span });\n            break;\n          case \"evaluator\":\n            observation = new ObservationEvaluator({ otelSpan: span });\n            break;\n          case \"guardrail\":\n            observation = new ObservationGuardrail({ otelSpan: span });\n            break;\n          case \"chain\":\n          default:\n            observation = new ObservationChain({ otelSpan: span });\n        }\n\n        const result = fn(observation as Parameters<F>[0]);\n\n        if (result instanceof Promise) {\n          return wrapPromise(\n            result,\n            span,\n            endOnExit,\n          ) as ReturnType<F>;\n        } else {\n          if (endOnExit !== false) {\n            span.end();\n          }\n          return result as ReturnType<F>;\n        }\n      } catch (err) {\n        span.setStatus({\n          code: SpanStatusCode.ERROR,\n          message: err instanceof Error ? err.message : \"Unknown error\",\n        });\n        if (endOnExit !== false) {\n          span.end();\n        }\n        throw err;\n      }\n    },\n  );\n}\n\n/**\n * Updates the currently active observation with new attributes.\n *\n * @param attributes - Observation attributes to set\n *\n * @example\n * ```typescript\n * import { updateActiveObservation } from './observability';\n *\n * // Within an active observation context\n * updateActiveObservation({\n *   metadata: { stage: 'processing' }\n * });\n * ```\n *\n * @public\n */\nexport function updateActiveObservation(\n  attributes: BaseSpanAttributes,\n): void {\n  const span = trace.getActiveSpan();\n\n  if (!span) {\n    console.warn(\n      \"[Observability] No active OTEL span in context. Skipping observation update.\",\n    );\n    return;\n  }\n\n  span.setAttributes(createObservationAttributes(\"chain\", attributes));\n}\n\n// ============================================================================\n// Decorator Function\n// ============================================================================\n\n/**\n * Options for the observe decorator.\n *\n * @public\n */\nexport type ObserveOptions = Omit<StartObservationOpts, \"name\"> & {\n  /** Whether to capture function arguments as input. Default: true */\n  captureInput?: boolean;\n  /** Whether to capture return value as output. Default: true */\n  captureOutput?: boolean;\n};\n\n/**\n * Captures function arguments for observability input.\n *\n * @param args - Function arguments to capture\n * @returns Serialized arguments\n * @internal\n */\nfunction _captureArguments(args: unknown[]): Record<string, unknown> {\n  if (args.length === 0) return {};\n  if (args.length === 1) return { arg: args[0] };\n  return { args };\n}\n\n/**\n * Decorator function to add observability to any function.\n *\n * Wraps a function with automatic observation creation, input/output capture,\n * and lifecycle management. The observation is automatically ended when the\n * function completes.\n *\n * @param fn - Function to wrap\n * @param options - Configuration options\n * @returns Wrapped function with observability\n *\n * @example\n * ```typescript\n * import { observe } from './observability';\n *\n * // Wrap an existing function\n * const fetchData = observe(async (url: string) => {\n *   const response = await fetch(url);\n *   return response.json();\n * }, { asType: 'tool' });\n *\n * // Wrap with custom name\n * const processPayment = observe(\n *   async (amount: number, currency: string) => {\n *     return await paymentGateway.charge(amount, currency);\n *   },\n *   { name: 'payment-gateway-call', asType: 'tool' }\n * );\n *\n * // Class method decoration\n * class UserService {\n *   @observe({ asType: 'chain' })\n *   async getUser(id: string) {\n *     return await db.users.find(id);\n *   }\n * }\n * ```\n *\n * @public\n */\nexport function observe<T extends (...args: any[]) => any>(\n  fn: T,\n  options: ObserveOptions = {},\n): T {\n  const {\n    asType = \"chain\",\n    captureInput = true,\n    captureOutput = true,\n    ...observationOptions\n  } = options;\n\n  const wrappedFunction = function (\n    this: any,\n    ...args: Parameters<T>\n  ): ReturnType<T> {\n    const name = fn.name || \"anonymous-function\";\n\n    // Prepare input data\n    const inputData = captureInput ? _captureArguments(args) : undefined;\n\n    // Create the observation\n    const observation = startObservation(\n      name,\n      inputData ? { input: inputData } : {},\n      {\n        ...observationOptions,\n        asType: asType as \"chain\",\n      },\n    );\n\n    // Set the observation span as active in the context\n    const activeContext = trace.setSpan(context.active(), observation.otelSpan);\n\n    // Execute the function within the observation context\n    const result = context.with(activeContext, () => fn.apply(this, args));\n\n    // Handle promises\n    if (result instanceof Promise) {\n      return result.then(\n        (value) => {\n          if (captureOutput) {\n            observation.update({ output: value });\n          }\n          observation.end();\n          return value;\n        },\n        (err: unknown) => {\n          observation.update({\n            level: \"ERROR\",\n            statusMessage: err instanceof Error ? err.message : \"Unknown error\",\n          });\n          observation.end();\n          throw err;\n        },\n      ) as ReturnType<T>;\n    }\n\n    // Handle synchronous functions\n    if (captureOutput) {\n      observation.update({ output: result });\n    }\n    observation.end();\n\n    return result as ReturnType<T>;\n  };\n\n  // Preserve function properties\n  Object.defineProperty(wrappedFunction, \"name\", { value: fn.name });\n  Object.defineProperty(wrappedFunction, \"length\", { value: fn.length });\n\n  return wrappedFunction as T;\n}\n"],"mappings":"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","names":["trace","context","SpanStatusCode"]}