@elasticdash/tracing 0.0.7 → 0.0.8

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as _opentelemetry_api from '@opentelemetry/api';
 import { Span, TimeInput, Attributes, TracerProvider, SpanContext } from '@opentelemetry/api';
 import { OpenAiUsage } from '@elasticdash/core';
-export { LangfuseOtelSpanAttributes, PropagateAttributesParams, propagateAttributes } from '@elasticdash/core';
+export { ElasticDashOtelSpanAttributes, PropagateAttributesParams, propagateAttributes } from '@elasticdash/core';
 
 /**
  * Types of observations that can be created in ElasticDash.
@@ -12,7 +12,7 @@ export { LangfuseOtelSpanAttributes, PropagateAttributesParams, propagateAttribu
  *
  * @public
  */
-type LangfuseObservationType = "span" | "generation" | "event" | "embedding" | "agent" | "tool" | "chain" | "retriever" | "evaluator" | "guardrail";
+type ElasticDashObservationType = "span" | "generation" | "event" | "embedding" | "agent" | "tool" | "chain" | "retriever" | "evaluator" | "guardrail";
 /**
  * Severity levels for observations in ElasticDash.
  *
@@ -33,7 +33,7 @@ type ObservationLevel = "DEBUG" | "DEFAULT" | "WARNING" | "ERROR";
  *
  * @public
  */
-type LangfuseSpanAttributes = {
+type ElasticDashSpanAttributes = {
     /** Input data for the operation being tracked */
     input?: unknown;
     /** Output data from the operation */
@@ -57,7 +57,7 @@ type LangfuseSpanAttributes = {
  *
  * @public
  */
-type LangfuseGenerationAttributes = LangfuseSpanAttributes & {
+type ElasticDashGenerationAttributes = ElasticDashSpanAttributes & {
     /** Timestamp when the model started generating completion */
     completionStartTime?: Date;
     /** Name of the language model used (e.g., 'gpt-4', 'claude-3') */
@@ -84,14 +84,14 @@ type LangfuseGenerationAttributes = LangfuseSpanAttributes & {
         isFallback: boolean;
     };
 };
-type LangfuseEventAttributes = LangfuseSpanAttributes;
-type LangfuseAgentAttributes = LangfuseSpanAttributes;
-type LangfuseToolAttributes = LangfuseSpanAttributes;
-type LangfuseChainAttributes = LangfuseSpanAttributes;
-type LangfuseRetrieverAttributes = LangfuseSpanAttributes;
-type LangfuseEvaluatorAttributes = LangfuseSpanAttributes;
-type LangfuseGuardrailAttributes = LangfuseSpanAttributes;
-type LangfuseEmbeddingAttributes = LangfuseGenerationAttributes;
+type ElasticDashEventAttributes = ElasticDashSpanAttributes;
+type ElasticDashAgentAttributes = ElasticDashSpanAttributes;
+type ElasticDashToolAttributes = ElasticDashSpanAttributes;
+type ElasticDashChainAttributes = ElasticDashSpanAttributes;
+type ElasticDashRetrieverAttributes = ElasticDashSpanAttributes;
+type ElasticDashEvaluatorAttributes = ElasticDashSpanAttributes;
+type ElasticDashGuardrailAttributes = ElasticDashSpanAttributes;
+type ElasticDashEmbeddingAttributes = ElasticDashGenerationAttributes;
 /**
  * Union type representing any ElasticDash observation attributes.
  *
@@ -99,7 +99,7 @@ type LangfuseEmbeddingAttributes = LangfuseGenerationAttributes;
  *
  * @public
  */
-type LangfuseObservationAttributes = LangfuseSpanAttributes & LangfuseGenerationAttributes & LangfuseEventAttributes & LangfuseAgentAttributes & LangfuseToolAttributes & LangfuseChainAttributes & LangfuseRetrieverAttributes & LangfuseEvaluatorAttributes & LangfuseGuardrailAttributes;
+type ElasticDashObservationAttributes = ElasticDashSpanAttributes & ElasticDashGenerationAttributes & ElasticDashEventAttributes & ElasticDashAgentAttributes & ElasticDashToolAttributes & ElasticDashChainAttributes & ElasticDashRetrieverAttributes & ElasticDashEvaluatorAttributes & ElasticDashGuardrailAttributes;
 /**
  * Attributes for ElasticDash traces.
  *
@@ -108,7 +108,7 @@ type LangfuseObservationAttributes = LangfuseSpanAttributes & LangfuseGeneration
  *
  * @public
  */
-type LangfuseTraceAttributes = {
+type ElasticDashTraceAttributes = {
     /** Human-readable name for the trace */
     name?: string;
     /** Identifier for the user associated with this trace */
@@ -141,21 +141,21 @@ type LangfuseTraceAttributes = {
  * particularly useful for generic functions that work with any observation type.
  *
  * ## Included Types
- * - **LangfuseSpan**: General-purpose operations and workflows
- * - **LangfuseGeneration**: LLM calls and AI model interactions
- * - **LangfuseEmbedding**: Text embedding and vector operations
- * - **LangfuseAgent**: AI agent workflows with tool usage
- * - **LangfuseTool**: Individual tool calls and API requests
- * - **LangfuseChain**: Multi-step processes and pipelines
- * - **LangfuseRetriever**: Document retrieval and search operations
- * - **LangfuseEvaluator**: Quality assessment and scoring
- * - **LangfuseGuardrail**: Safety checks and content filtering
- * - **LangfuseEvent**: Point-in-time occurrences and log entries
+ * - **ElasticDashSpan**: General-purpose operations and workflows
+ * - **ElasticDashGeneration**: LLM calls and AI model interactions
+ * - **ElasticDashEmbedding**: Text embedding and vector operations
+ * - **ElasticDashAgent**: AI agent workflows with tool usage
+ * - **ElasticDashTool**: Individual tool calls and API requests
+ * - **ElasticDashChain**: Multi-step processes and pipelines
+ * - **ElasticDashRetriever**: Document retrieval and search operations
+ * - **ElasticDashEvaluator**: Quality assessment and scoring
+ * - **ElasticDashGuardrail**: Safety checks and content filtering
+ * - **ElasticDashEvent**: Point-in-time occurrences and log entries
  *
  * @example
  * ```typescript
  * // Function accepting any observation type
- * function logObservation(obs: LangfuseObservation) {
+ * function logObservation(obs: ElasticDashObservation) {
  *   console.log(`Observation ${obs.id} in trace ${obs.traceId}`);
  *
  *   // All observations have common methods
@@ -175,16 +175,16 @@ type LangfuseTraceAttributes = {
  *
  * @public
  */
-type LangfuseObservation = LangfuseSpan | LangfuseGeneration | LangfuseEvent | LangfuseAgent | LangfuseTool | LangfuseChain | LangfuseRetriever | LangfuseEvaluator | LangfuseGuardrail | LangfuseEmbedding;
+type ElasticDashObservation = ElasticDashSpan | ElasticDashGeneration | ElasticDashEvent | ElasticDashAgent | ElasticDashTool | ElasticDashChain | ElasticDashRetriever | ElasticDashEvaluator | ElasticDashGuardrail | ElasticDashEmbedding;
 /**
  * Parameters for creating a ElasticDash observation wrapper.
  *
  * @internal
  */
-type LangfuseObservationParams = {
+type ElasticDashObservationParams = {
     otelSpan: Span;
-    type: LangfuseObservationType;
-    attributes?: LangfuseSpanAttributes | LangfuseGenerationAttributes | LangfuseEventAttributes;
+    type: ElasticDashObservationType;
+    attributes?: ElasticDashSpanAttributes | ElasticDashGenerationAttributes | ElasticDashEventAttributes;
 };
 /**
  * Base class for all ElasticDash observation wrappers providing unified functionality.
@@ -215,7 +215,7 @@ type LangfuseObservationParams = {
  * @example
  * ```typescript
  * // All observation types share these common capabilities
- * const observation: LangfuseObservation = startObservation('my-operation');
+ * const observation: ElasticDashObservation = startObservation('my-operation');
  *
  * // Common properties available on all observations
  * console.log(`Observation ID: ${observation.id}`);
@@ -241,16 +241,16 @@ type LangfuseObservationParams = {
  *
  * @internal
  */
-declare abstract class LangfuseBaseObservation {
+declare abstract class ElasticDashBaseObservation {
     /** The underlying OpenTelemetry span */
     readonly otelSpan: Span;
     /** The underlying OpenTelemetry span */
-    readonly type: LangfuseObservationType;
+    readonly type: ElasticDashObservationType;
     /** The span ID from the OpenTelemetry span context */
     id: string;
     /** The trace ID from the OpenTelemetry span context */
     traceId: string;
-    constructor(params: LangfuseObservationParams);
+    constructor(params: ElasticDashObservationParams);
     /** Gets the ElasticDash OpenTelemetry tracer instance */
     protected get tracer(): _opentelemetry_api.Tracer;
     /**
@@ -259,11 +259,11 @@ declare abstract class LangfuseBaseObservation {
      * @param endTime - Optional end time, defaults to current time
      */
     end(endTime?: TimeInput): void;
-    updateOtelSpanAttributes(attributes: LangfuseObservationAttributes): void;
+    updateOtelSpanAttributes(attributes: ElasticDashObservationAttributes): void;
     /**
      * Updates the parent trace with new attributes.
      */
-    updateTrace(attributes: LangfuseTraceAttributes): this;
+    updateTrace(attributes: ElasticDashTraceAttributes): this;
     /**
      * Creates a new child observation within this observation's context with full type safety.
      *
@@ -298,7 +298,7 @@ declare abstract class LangfuseBaseObservation {
      * const dataProcessing = parentObservation.startObservation('data-processing', {
      *   input: { userId: '123', dataSize: 1024 },
      *   metadata: { processor: 'fast-lane', version: '2.1' }
-     * }); // Returns LangfuseSpan
+     * }); // Returns ElasticDashSpan
      *
      * // Create child generation with full LLM attributes
      * const llmCall = parentObservation.startObservation('openai-gpt-4', {
@@ -311,7 +311,7 @@ declare abstract class LangfuseBaseObservation {
      *     topP: 1.0
      *   },
      *   metadata: { priority: 'high', timeout: 30000 }
-     * }, { asType: 'generation' }); // Returns LangfuseGeneration
+     * }, { asType: 'generation' }); // Returns ElasticDashGeneration
      *
      * // Create child agent for complex reasoning
      * const reasoningAgent = parentObservation.startObservation('reasoning-agent', {
@@ -324,7 +324,7 @@ declare abstract class LangfuseBaseObservation {
      *     tools: ['calculator', 'web-search', 'data-analysis'],
      *     maxIterations: 5
      *   }
-     * }, { asType: 'agent' }); // Returns LangfuseAgent
+     * }, { asType: 'agent' }); // Returns ElasticDashAgent
      *
      * // Create child tool for external API calls
      * const apiCall = reasoningAgent.startObservation('market-data-api', {
@@ -337,7 +337,7 @@ declare abstract class LangfuseBaseObservation {
      *     rateLimit: 5,
      *     timeout: 10000
      *   }
-     * }, { asType: 'tool' }); // Returns LangfuseTool
+     * }, { asType: 'tool' }); // Returns ElasticDashTool
      *
      * // Create child retriever for document search
      * const docSearch = parentObservation.startObservation('document-retrieval', {
@@ -351,7 +351,7 @@ declare abstract class LangfuseBaseObservation {
      *     embeddingModel: 'text-embedding-ada-002',
      *     similarity: 'cosine'
      *   }
-     * }, { asType: 'retriever' }); // Returns LangfuseRetriever
+     * }, { asType: 'retriever' }); // Returns ElasticDashRetriever
      *
      * // Create child evaluator for quality assessment
      * const qualityCheck = parentObservation.startObservation('response-evaluator', {
@@ -365,7 +365,7 @@ declare abstract class LangfuseBaseObservation {
      *     threshold: 0.8,
      *     metrics: ['bleu', 'rouge', 'semantic-similarity']
      *   }
-     * }, { asType: 'evaluator' }); // Returns LangfuseEvaluator
+     * }, { asType: 'evaluator' }); // Returns ElasticDashEvaluator
      *
      * // Create child guardrail for safety checking
      * const safetyCheck = parentObservation.startObservation('content-guardrail', {
@@ -378,7 +378,7 @@ declare abstract class LangfuseBaseObservation {
      *     strictMode: true,
      *     confidence: 0.95
      *   }
-     * }, { asType: 'guardrail' }); // Returns LangfuseGuardrail
+     * }, { asType: 'guardrail' }); // Returns ElasticDashGuardrail
      *
      * // Create child embedding for vector generation
      * const textEmbedding = parentObservation.startObservation('text-embedder', {
@@ -392,7 +392,7 @@ declare abstract class LangfuseBaseObservation {
      *     normalization: 'l2',
      *     purpose: 'semantic-search'
      *   }
-     * }, { asType: 'embedding' }); // Returns LangfuseEmbedding
+     * }, { asType: 'embedding' }); // Returns ElasticDashEmbedding
      *
      * // Create child event for point-in-time logging
      * const userAction = parentObservation.startObservation('user-interaction', {
@@ -407,7 +407,7 @@ declare abstract class LangfuseBaseObservation {
      *     userId: 'user_456',
      *     browser: 'Chrome 120.0'
      *   }
-     * }, { asType: 'event' }); // Returns LangfuseEvent (auto-ended)
+     * }, { asType: 'event' }); // Returns ElasticDashEvent (auto-ended)
      *
      * // Chain operations - each child inherits context
      * dataProcessing.update({ output: { processed: true, records: 1000 } });
@@ -432,45 +432,45 @@ declare abstract class LangfuseBaseObservation {
      * @see {@link startObservation} for creating root-level observations
      * @see {@link startActiveObservation} for function-scoped child observations
      */
-    startObservation(name: string, attributes: LangfuseGenerationAttributes, options: {
+    startObservation(name: string, attributes: ElasticDashGenerationAttributes, options: {
         asType: "generation";
-    }): LangfuseGeneration;
-    startObservation(name: string, attributes: LangfuseEventAttributes, options: {
+    }): ElasticDashGeneration;
+    startObservation(name: string, attributes: ElasticDashEventAttributes, options: {
         asType: "event";
-    }): LangfuseEvent;
-    startObservation(name: string, attributes: LangfuseAgentAttributes, options: {
+    }): ElasticDashEvent;
+    startObservation(name: string, attributes: ElasticDashAgentAttributes, options: {
         asType: "agent";
-    }): LangfuseAgent;
-    startObservation(name: string, attributes: LangfuseToolAttributes, options: {
+    }): ElasticDashAgent;
+    startObservation(name: string, attributes: ElasticDashToolAttributes, options: {
         asType: "tool";
-    }): LangfuseTool;
-    startObservation(name: string, attributes: LangfuseChainAttributes, options: {
+    }): ElasticDashTool;
+    startObservation(name: string, attributes: ElasticDashChainAttributes, options: {
         asType: "chain";
-    }): LangfuseChain;
-    startObservation(name: string, attributes: LangfuseRetrieverAttributes, options: {
+    }): ElasticDashChain;
+    startObservation(name: string, attributes: ElasticDashRetrieverAttributes, options: {
         asType: "retriever";
-    }): LangfuseRetriever;
-    startObservation(name: string, attributes: LangfuseEvaluatorAttributes, options: {
+    }): ElasticDashRetriever;
+    startObservation(name: string, attributes: ElasticDashEvaluatorAttributes, options: {
         asType: "evaluator";
-    }): LangfuseEvaluator;
-    startObservation(name: string, attributes: LangfuseGuardrailAttributes, options: {
+    }): ElasticDashEvaluator;
+    startObservation(name: string, attributes: ElasticDashGuardrailAttributes, options: {
         asType: "guardrail";
-    }): LangfuseGuardrail;
-    startObservation(name: string, attributes: LangfuseEmbeddingAttributes, options: {
+    }): ElasticDashGuardrail;
+    startObservation(name: string, attributes: ElasticDashEmbeddingAttributes, options: {
         asType: "embedding";
-    }): LangfuseEmbedding;
-    startObservation(name: string, attributes?: LangfuseSpanAttributes, options?: {
+    }): ElasticDashEmbedding;
+    startObservation(name: string, attributes?: ElasticDashSpanAttributes, options?: {
         asType?: "span";
-    }): LangfuseSpan;
+    }): ElasticDashSpan;
 }
-type LangfuseSpanParams = {
+type ElasticDashSpanParams = {
     otelSpan: Span;
-    attributes?: LangfuseSpanAttributes;
+    attributes?: ElasticDashSpanAttributes;
 };
 /**
  * General-purpose observation wrapper for tracking operations, functions, and workflows.
  *
- * LangfuseSpan is the default and most versatile observation type, designed for tracing
+ * ElasticDashSpan is the default and most versatile observation type, designed for tracing
  * any operation that has a defined start and end time. It serves as the foundation for
  * building hierarchical traces and can contain any other observation type as children.
  *
@@ -541,13 +541,13 @@ type LangfuseSpanParams = {
  *
  * @see {@link startObservation} - Factory function for creating spans
  * @see {@link startActiveObservation} - Function-scoped span creation
- * @see {@link LangfuseGeneration} - For LLM and AI model interactions
- * @see {@link LangfuseEvent} - For point-in-time occurrences
+ * @see {@link ElasticDashGeneration} - For LLM and AI model interactions
+ * @see {@link ElasticDashEvent} - For point-in-time occurrences
  *
  * @public
  */
-declare class LangfuseSpan extends LangfuseBaseObservation {
-    constructor(params: LangfuseSpanParams);
+declare class ElasticDashSpan extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashSpanParams);
     /**
      * Updates this span with new attributes.
      *
@@ -563,16 +563,16 @@ declare class LangfuseSpan extends LangfuseBaseObservation {
      * });
      * ```
      */
-    update(attributes: LangfuseSpanAttributes): LangfuseSpan;
+    update(attributes: ElasticDashSpanAttributes): ElasticDashSpan;
 }
-type LangfuseAgentParams = {
+type ElasticDashAgentParams = {
     otelSpan: Span;
-    attributes?: LangfuseAgentAttributes;
+    attributes?: ElasticDashAgentAttributes;
 };
 /**
  * Specialized observation wrapper for tracking AI agent workflows and autonomous operations.
  *
- * LangfuseAgent is designed for observing intelligent agent systems that combine reasoning,
+ * ElasticDashAgent is designed for observing intelligent agent systems that combine reasoning,
  * tool usage, memory management, and decision-making in autonomous workflows. It captures
  * the complex multi-step nature of agent operations, including planning, execution, and
  * self-correction cycles typical in advanced AI agent architectures.
@@ -643,13 +643,13 @@ type LangfuseAgentParams = {
  *
  * @see {@link startObservation} with `{ asType: 'agent' }` - Factory function
  * @see {@link startActiveObservation} with `{ asType: 'agent' }` - Function-scoped agent
- * @see {@link LangfuseTool} - For individual tool executions within agents
- * @see {@link LangfuseChain} - For structured multi-step workflows
+ * @see {@link ElasticDashTool} - For individual tool executions within agents
+ * @see {@link ElasticDashChain} - For structured multi-step workflows
  *
  * @public
  */
-declare class LangfuseAgent extends LangfuseBaseObservation {
-    constructor(params: LangfuseAgentParams);
+declare class ElasticDashAgent extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashAgentParams);
     /**
      * Updates this agent observation with new attributes.
      *
@@ -673,16 +673,16 @@ declare class LangfuseAgent extends LangfuseBaseObservation {
      * });
      * ```
      */
-    update(attributes: LangfuseAgentAttributes): LangfuseAgent;
+    update(attributes: ElasticDashAgentAttributes): ElasticDashAgent;
 }
-type LangfuseToolParams = {
+type ElasticDashToolParams = {
     otelSpan: Span;
-    attributes?: LangfuseToolAttributes;
+    attributes?: ElasticDashToolAttributes;
 };
 /**
  * Specialized observation wrapper for tracking individual tool calls and external API interactions.
  *
- * LangfuseTool is designed for observing discrete tool invocations within agent workflows,
+ * ElasticDashTool is designed for observing discrete tool invocations within agent workflows,
  * function calling scenarios, or standalone API integrations. It captures the input parameters,
  * execution results, performance metrics, and error conditions of tool operations, making it
  * essential for debugging tool reliability and optimizing tool selection strategies.
@@ -763,13 +763,13 @@ type LangfuseToolParams = {
  *
  * @see {@link startObservation} with `{ asType: 'tool' }` - Factory function
  * @see {@link startActiveObservation} with `{ asType: 'tool' }` - Function-scoped tool
- * @see {@link LangfuseAgent} - For agent workflows that use multiple tools
- * @see {@link LangfuseChain} - For orchestrated tool sequences
+ * @see {@link ElasticDashAgent} - For agent workflows that use multiple tools
+ * @see {@link ElasticDashChain} - For orchestrated tool sequences
  *
  * @public
  */
-declare class LangfuseTool extends LangfuseBaseObservation {
-    constructor(params: LangfuseToolParams);
+declare class ElasticDashTool extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashToolParams);
     /**
      * Updates this tool observation with new attributes.
      *
@@ -793,16 +793,16 @@ declare class LangfuseTool extends LangfuseBaseObservation {
      * });
      * ```
      */
-    update(attributes: LangfuseToolAttributes): LangfuseTool;
+    update(attributes: ElasticDashToolAttributes): ElasticDashTool;
 }
-type LangfuseChainParams = {
+type ElasticDashChainParams = {
     otelSpan: Span;
-    attributes?: LangfuseChainAttributes;
+    attributes?: ElasticDashChainAttributes;
 };
 /**
  * Specialized observation wrapper for tracking structured multi-step workflows and process chains.
  *
- * LangfuseChain is designed for observing sequential, parallel, or conditional workflow orchestration
+ * ElasticDashChain is designed for observing sequential, parallel, or conditional workflow orchestration
  * where multiple operations are coordinated to achieve a larger goal. It captures the flow of data
  * between steps, manages dependencies, tracks progress through complex pipelines, and provides
  * insights into workflow performance and reliability patterns.
@@ -878,13 +878,13 @@ type LangfuseChainParams = {
  *
  * @see {@link startObservation} with `{ asType: 'chain' }` - Factory function
  * @see {@link startActiveObservation} with `{ asType: 'chain' }` - Function-scoped chain
- * @see {@link LangfuseSpan} - For individual workflow steps
- * @see {@link LangfuseAgent} - For intelligent workflow orchestration
+ * @see {@link ElasticDashSpan} - For individual workflow steps
+ * @see {@link ElasticDashAgent} - For intelligent workflow orchestration
  *
  * @public
  */
-declare class LangfuseChain extends LangfuseBaseObservation {
-    constructor(params: LangfuseChainParams);
+declare class ElasticDashChain extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashChainParams);
     /**
      * Updates this chain observation with new attributes.
      *
@@ -908,16 +908,16 @@ declare class LangfuseChain extends LangfuseBaseObservation {
      * });
      * ```
      */
-    update(attributes: LangfuseChainAttributes): LangfuseChain;
+    update(attributes: ElasticDashChainAttributes): ElasticDashChain;
 }
-type LangfuseRetrieverParams = {
+type ElasticDashRetrieverParams = {
     otelSpan: Span;
-    attributes?: LangfuseRetrieverAttributes;
+    attributes?: ElasticDashRetrieverAttributes;
 };
 /**
  * Specialized observation wrapper for tracking document retrieval and search operations.
  *
- * LangfuseRetriever is designed for observing information retrieval systems that search,
+ * ElasticDashRetriever is designed for observing information retrieval systems that search,
  * filter, and rank content from various data sources. It captures search queries, retrieval
  * strategies, result quality metrics, and performance characteristics of search operations,
  * making it essential for RAG systems, knowledge bases, and content discovery workflows.
@@ -974,29 +974,29 @@ type LangfuseRetrieverParams = {
  * ```
  *
  * @see {@link startObservation} with `{ asType: 'retriever' }` - Factory function
- * @see {@link LangfuseChain} - For multi-step RAG pipelines
- * @see {@link LangfuseEmbedding} - For embedding generation used in vector search
+ * @see {@link ElasticDashChain} - For multi-step RAG pipelines
+ * @see {@link ElasticDashEmbedding} - For embedding generation used in vector search
  *
  * @public
  */
-declare class LangfuseRetriever extends LangfuseBaseObservation {
-    constructor(params: LangfuseRetrieverParams);
+declare class ElasticDashRetriever extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashRetrieverParams);
     /**
      * Updates this retriever observation with new attributes.
      *
      * @param attributes - Retriever attributes to set
      * @returns This retriever for method chaining
      */
-    update(attributes: LangfuseRetrieverAttributes): LangfuseRetriever;
+    update(attributes: ElasticDashRetrieverAttributes): ElasticDashRetriever;
 }
-type LangfuseEvaluatorParams = {
+type ElasticDashEvaluatorParams = {
     otelSpan: Span;
-    attributes?: LangfuseEvaluatorAttributes;
+    attributes?: ElasticDashEvaluatorAttributes;
 };
 /**
  * Specialized observation wrapper for tracking quality assessment and evaluation operations.
  *
- * LangfuseEvaluator is designed for observing evaluation systems that assess, score, and
+ * ElasticDashEvaluator is designed for observing evaluation systems that assess, score, and
  * validate the quality of AI outputs, content, or system performance. It captures evaluation
  * criteria, scoring methodologies, benchmark comparisons, and quality metrics, making it
  * essential for AI system validation, content moderation, and performance monitoring.
@@ -1047,29 +1047,29 @@ type LangfuseEvaluatorParams = {
  * ```
  *
  * @see {@link startObservation} with `{ asType: 'evaluator' }` - Factory function
- * @see {@link LangfuseGeneration} - For LLM outputs being evaluated
- * @see {@link LangfuseGuardrail} - For safety and compliance enforcement
+ * @see {@link ElasticDashGeneration} - For LLM outputs being evaluated
+ * @see {@link ElasticDashGuardrail} - For safety and compliance enforcement
  *
  * @public
  */
-declare class LangfuseEvaluator extends LangfuseBaseObservation {
-    constructor(params: LangfuseEvaluatorParams);
+declare class ElasticDashEvaluator extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashEvaluatorParams);
     /**
      * Updates this evaluator observation with new attributes.
      *
      * @param attributes - Evaluator attributes to set
      * @returns This evaluator for method chaining
      */
-    update(attributes: LangfuseEvaluatorAttributes): LangfuseEvaluator;
+    update(attributes: ElasticDashEvaluatorAttributes): ElasticDashEvaluator;
 }
-type LangfuseGuardrailParams = {
+type ElasticDashGuardrailParams = {
     otelSpan: Span;
-    attributes?: LangfuseGuardrailAttributes;
+    attributes?: ElasticDashGuardrailAttributes;
 };
 /**
  * Specialized observation wrapper for tracking safety checks and compliance enforcement.
  *
- * LangfuseGuardrail is designed for observing safety and compliance systems that prevent,
+ * ElasticDashGuardrail is designed for observing safety and compliance systems that prevent,
  * detect, and mitigate harmful, inappropriate, or policy-violating content and behaviors
  * in AI applications. It captures safety policies, violation detection, risk assessment,
  * and mitigation actions, ensuring responsible AI deployment and regulatory compliance.
@@ -1118,34 +1118,34 @@ type LangfuseGuardrailParams = {
  * ```
  *
  * @see {@link startObservation} with `{ asType: 'guardrail' }` - Factory function
- * @see {@link LangfuseEvaluator} - For detailed quality and safety assessment
- * @see {@link LangfuseGeneration} - For protecting LLM outputs with guardrails
+ * @see {@link ElasticDashEvaluator} - For detailed quality and safety assessment
+ * @see {@link ElasticDashGeneration} - For protecting LLM outputs with guardrails
  *
  * @public
  */
-declare class LangfuseGuardrail extends LangfuseBaseObservation {
-    constructor(params: LangfuseGuardrailParams);
+declare class ElasticDashGuardrail extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashGuardrailParams);
     /**
      * Updates this guardrail observation with new attributes.
      *
      * @param attributes - Guardrail attributes to set
      * @returns This guardrail for method chaining
      */
-    update(attributes: LangfuseGuardrailAttributes): LangfuseGuardrail;
+    update(attributes: ElasticDashGuardrailAttributes): ElasticDashGuardrail;
 }
 /**
  * Parameters for creating a ElasticDash generation.
  *
  * @internal
  */
-type LangfuseGenerationParams = {
+type ElasticDashGenerationParams = {
     otelSpan: Span;
-    attributes?: LangfuseGenerationAttributes;
+    attributes?: ElasticDashGenerationAttributes;
 };
 /**
  * Specialized observation wrapper for tracking LLM interactions, AI model calls, and text generation.
  *
- * LangfuseGeneration is purpose-built for observing AI model interactions, providing rich
+ * ElasticDashGeneration is purpose-built for observing AI model interactions, providing rich
  * metadata capture for prompts, completions, model parameters, token usage, and costs.
  * It's the go-to observation type for any operation involving language models, chat APIs,
  * completion APIs, or other generative AI services.
@@ -1243,23 +1243,23 @@ type LangfuseGenerationParams = {
  *
  * @see {@link startObservation} with `{ asType: 'generation' }` - Factory function
  * @see {@link startActiveObservation} with `{ asType: 'generation' }` - Function-scoped generation
- * @see {@link LangfuseSpan} - For general-purpose operations
- * @see {@link LangfuseEmbedding} - For text embedding and vector operations
+ * @see {@link ElasticDashSpan} - For general-purpose operations
+ * @see {@link ElasticDashEmbedding} - For text embedding and vector operations
  *
  * @public
  */
-declare class LangfuseGeneration extends LangfuseBaseObservation {
-    constructor(params: LangfuseGenerationParams);
-    update(attributes: LangfuseGenerationAttributes): LangfuseGeneration;
+declare class ElasticDashGeneration extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashGenerationParams);
+    update(attributes: ElasticDashGenerationAttributes): ElasticDashGeneration;
 }
-type LangfuseEmbeddingParams = {
+type ElasticDashEmbeddingParams = {
     otelSpan: Span;
-    attributes?: LangfuseEmbeddingAttributes;
+    attributes?: ElasticDashEmbeddingAttributes;
 };
 /**
  * Specialized observation wrapper for tracking text embedding and vector generation operations.
  *
- * LangfuseEmbedding is designed for observing embedding model interactions that convert
+ * ElasticDashEmbedding is designed for observing embedding model interactions that convert
  * text, images, or other content into high-dimensional vector representations. It captures
  * embedding model parameters, input preprocessing, vector characteristics, and performance
  * metrics, making it essential for semantic search, RAG systems, and similarity-based applications.
@@ -1319,29 +1319,29 @@ type LangfuseEmbeddingParams = {
  * ```
  *
  * @see {@link startObservation} with `{ asType: 'embedding' }` - Factory function
- * @see {@link LangfuseRetriever} - For using embeddings in vector search
- * @see {@link LangfuseGeneration} - For LLM operations that may use embeddings
+ * @see {@link ElasticDashRetriever} - For using embeddings in vector search
+ * @see {@link ElasticDashGeneration} - For LLM operations that may use embeddings
  *
  * @public
  */
-declare class LangfuseEmbedding extends LangfuseBaseObservation {
-    constructor(params: LangfuseEmbeddingParams);
+declare class ElasticDashEmbedding extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashEmbeddingParams);
     /**
      * Updates this embedding observation with new attributes.
      *
      * @param attributes - Embedding attributes to set
      * @returns This embedding for method chaining
      */
-    update(attributes: LangfuseEmbeddingAttributes): LangfuseEmbedding;
+    update(attributes: ElasticDashEmbeddingAttributes): ElasticDashEmbedding;
 }
 /**
  * Parameters for creating a ElasticDash event.
  *
  * @internal
  */
-type LangfuseEventParams = {
+type ElasticDashEventParams = {
     otelSpan: Span;
-    attributes?: LangfuseEventAttributes;
+    attributes?: ElasticDashEventAttributes;
     timestamp: TimeInput;
 };
 /**
@@ -1353,8 +1353,8 @@ type LangfuseEventParams = {
  *
  * @public
  */
-declare class LangfuseEvent extends LangfuseBaseObservation {
-    constructor(params: LangfuseEventParams);
+declare class ElasticDashEvent extends ElasticDashBaseObservation {
+    constructor(params: ElasticDashEventParams);
 }
 
 /**
@@ -1383,8 +1383,8 @@ declare class LangfuseEvent extends LangfuseBaseObservation {
  *
  * @public
  */
-declare function createTraceAttributes({ name, userId, sessionId, version, release, input, output, metadata, tags, environment, public: isPublic, }?: LangfuseTraceAttributes): Attributes;
-declare function createObservationAttributes(type: LangfuseObservationType, attributes: LangfuseObservationAttributes): Attributes;
+declare function createTraceAttributes({ name, userId, sessionId, version, release, input, output, metadata, tags, environment, public: isPublic, }?: ElasticDashTraceAttributes): Attributes;
+declare function createObservationAttributes(type: ElasticDashObservationType, attributes: ElasticDashObservationAttributes): Attributes;
 
 /**
  * Sets an isolated TracerProvider for ElasticDash tracing operations.
@@ -1413,42 +1413,42 @@ declare function createObservationAttributes(type: LangfuseObservationType, attr
  * @example
  * ```typescript
  * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
- * import { LangfuseSpanProcessor } from '@elasticdash/otel';
- * import { setLangfuseTracerProvider } from '@elasticdash/tracing';
+ * import { ElasticDashSpanProcessor } from '@elasticdash/otel';
+ * import { setElasticDashTracerProvider } from '@elasticdash/tracing';
  *
  * // Create provider with span processors in constructor
  * const provider = new NodeTracerProvider({
- *   spanProcessors: [new LangfuseSpanProcessor()]
+ *   spanProcessors: [new ElasticDashSpanProcessor()]
  * });
  *
- * setLangfuseTracerProvider(provider);
+ * setElasticDashTracerProvider(provider);
  *
- * // Note: Spans created with getLangfuseTracer() may still inherit
+ * // Note: Spans created with getElasticDashTracer() may still inherit
  * // context from spans created with the global tracer
  * ```
  *
  * @param provider - The TracerProvider instance to use, or null to clear the isolated provider
  * @public
  */
-declare function setLangfuseTracerProvider(provider: TracerProvider | null): void;
+declare function setElasticDashTracerProvider(provider: TracerProvider | null): void;
 /**
  * Gets the TracerProvider for ElasticDash tracing operations.
  *
- * Returns the isolated TracerProvider if one has been set via setLangfuseTracerProvider(),
+ * Returns the isolated TracerProvider if one has been set via setElasticDashTracerProvider(),
  * otherwise falls back to the global OpenTelemetry TracerProvider.
  *
  * @example
  * ```typescript
- * import { getLangfuseTracerProvider } from '@elasticdash/tracing';
+ * import { getElasticDashTracerProvider } from '@elasticdash/tracing';
  *
- * const provider = getLangfuseTracerProvider();
+ * const provider = getElasticDashTracerProvider();
  * const tracer = provider.getTracer('my-tracer', '1.0.0');
  * ```
  *
  * @returns The TracerProvider instance to use for ElasticDash tracing
  * @public
  */
-declare function getLangfuseTracerProvider(): TracerProvider;
+declare function getElasticDashTracerProvider(): TracerProvider;
 /**
  * Gets the OpenTelemetry tracer instance for ElasticDash.
  *
@@ -1460,15 +1460,15 @@ declare function getLangfuseTracerProvider(): TracerProvider;
  *
  * @example
  * ```typescript
- * import { getLangfuseTracer } from '@elasticdash/tracing';
+ * import { getElasticDashTracer } from '@elasticdash/tracing';
  *
- * const tracer = getLangfuseTracer();
+ * const tracer = getElasticDashTracer();
  * const span = tracer.startSpan('my-operation');
  * ```
  *
  * @public
  */
-declare function getLangfuseTracer(): _opentelemetry_api.Tracer;
+declare function getElasticDashTracer(): _opentelemetry_api.Tracer;
 
 /**
  * Options for starting observations (spans, generations, events).
@@ -1499,7 +1499,7 @@ type StartActiveObservationContext = StartObservationOptions & {
  */
 type StartObservationOpts = StartObservationOptions & {
     /** Type of observation to create. Defaults to 'span' */
-    asType?: LangfuseObservationType;
+    asType?: ElasticDashObservationType;
 };
 /**
  * Options for startActiveObservation function.
@@ -1508,63 +1508,63 @@ type StartObservationOpts = StartObservationOptions & {
  */
 type StartActiveObservationOpts = StartActiveObservationContext & {
     /** Type of observation to create. Defaults to 'span' */
-    asType?: LangfuseObservationType;
+    asType?: ElasticDashObservationType;
 };
-declare function startObservation(name: string, attributes: LangfuseGenerationAttributes, options: StartObservationOpts & {
+declare function startObservation(name: string, attributes: ElasticDashGenerationAttributes, options: StartObservationOpts & {
     asType: "generation";
-}): LangfuseGeneration;
-declare function startObservation(name: string, attributes: LangfuseEventAttributes, options: StartObservationOpts & {
+}): ElasticDashGeneration;
+declare function startObservation(name: string, attributes: ElasticDashEventAttributes, options: StartObservationOpts & {
     asType: "event";
-}): LangfuseEvent;
-declare function startObservation(name: string, attributes: LangfuseAgentAttributes, options: StartObservationOpts & {
+}): ElasticDashEvent;
+declare function startObservation(name: string, attributes: ElasticDashAgentAttributes, options: StartObservationOpts & {
     asType: "agent";
-}): LangfuseAgent;
-declare function startObservation(name: string, attributes: LangfuseToolAttributes, options: StartObservationOpts & {
+}): ElasticDashAgent;
+declare function startObservation(name: string, attributes: ElasticDashToolAttributes, options: StartObservationOpts & {
     asType: "tool";
-}): LangfuseTool;
-declare function startObservation(name: string, attributes: LangfuseChainAttributes, options: StartObservationOpts & {
+}): ElasticDashTool;
+declare function startObservation(name: string, attributes: ElasticDashChainAttributes, options: StartObservationOpts & {
     asType: "chain";
-}): LangfuseChain;
-declare function startObservation(name: string, attributes: LangfuseRetrieverAttributes, options: StartObservationOpts & {
+}): ElasticDashChain;
+declare function startObservation(name: string, attributes: ElasticDashRetrieverAttributes, options: StartObservationOpts & {
     asType: "retriever";
-}): LangfuseRetriever;
-declare function startObservation(name: string, attributes: LangfuseEvaluatorAttributes, options: StartObservationOpts & {
+}): ElasticDashRetriever;
+declare function startObservation(name: string, attributes: ElasticDashEvaluatorAttributes, options: StartObservationOpts & {
     asType: "evaluator";
-}): LangfuseEvaluator;
-declare function startObservation(name: string, attributes: LangfuseGuardrailAttributes, options: StartObservationOpts & {
+}): ElasticDashEvaluator;
+declare function startObservation(name: string, attributes: ElasticDashGuardrailAttributes, options: StartObservationOpts & {
     asType: "guardrail";
-}): LangfuseGuardrail;
-declare function startObservation(name: string, attributes: LangfuseEmbeddingAttributes, options: StartObservationOpts & {
+}): ElasticDashGuardrail;
+declare function startObservation(name: string, attributes: ElasticDashEmbeddingAttributes, options: StartObservationOpts & {
     asType: "embedding";
-}): LangfuseEmbedding;
-declare function startObservation(name: string, attributes?: LangfuseSpanAttributes, options?: StartObservationOpts & {
+}): ElasticDashEmbedding;
+declare function startObservation(name: string, attributes?: ElasticDashSpanAttributes, options?: StartObservationOpts & {
     asType?: "span";
-}): LangfuseSpan;
-declare function startActiveObservation<F extends (generation: LangfuseGeneration) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
+}): ElasticDashSpan;
+declare function startActiveObservation<F extends (generation: ElasticDashGeneration) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
     asType: "generation";
 }): ReturnType<F>;
-declare function startActiveObservation<F extends (embedding: LangfuseEmbedding) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
+declare function startActiveObservation<F extends (embedding: ElasticDashEmbedding) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
     asType: "embedding";
 }): ReturnType<F>;
-declare function startActiveObservation<F extends (agent: LangfuseAgent) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
+declare function startActiveObservation<F extends (agent: ElasticDashAgent) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
     asType: "agent";
 }): ReturnType<F>;
-declare function startActiveObservation<F extends (tool: LangfuseTool) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
+declare function startActiveObservation<F extends (tool: ElasticDashTool) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
     asType: "tool";
 }): ReturnType<F>;
-declare function startActiveObservation<F extends (chain: LangfuseChain) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
+declare function startActiveObservation<F extends (chain: ElasticDashChain) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
     asType: "chain";
 }): ReturnType<F>;
-declare function startActiveObservation<F extends (retriever: LangfuseRetriever) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
+declare function startActiveObservation<F extends (retriever: ElasticDashRetriever) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
     asType: "retriever";
 }): ReturnType<F>;
-declare function startActiveObservation<F extends (evaluator: LangfuseEvaluator) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
+declare function startActiveObservation<F extends (evaluator: ElasticDashEvaluator) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
     asType: "evaluator";
 }): ReturnType<F>;
-declare function startActiveObservation<F extends (guardrail: LangfuseGuardrail) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
+declare function startActiveObservation<F extends (guardrail: ElasticDashGuardrail) => unknown>(name: string, fn: F, options: StartActiveObservationOpts & {
     asType: "guardrail";
 }): ReturnType<F>;
-declare function startActiveObservation<F extends (span: LangfuseSpan) => unknown>(name: string, fn: F, options?: StartActiveObservationOpts & {
+declare function startActiveObservation<F extends (span: ElasticDashSpan) => unknown>(name: string, fn: F, options?: StartActiveObservationOpts & {
     asType?: "span";
 }): ReturnType<F>;
 /**
@@ -1591,7 +1591,7 @@ declare function startActiveObservation<F extends (span: LangfuseSpan) => unknow
  *
  * @public
  */
-declare function updateActiveTrace(attributes: LangfuseTraceAttributes): void;
+declare function updateActiveTrace(attributes: ElasticDashTraceAttributes): void;
 /**
  * Updates the currently active observation with new attributes.
  *
@@ -1723,31 +1723,31 @@ declare function updateActiveTrace(attributes: LangfuseTraceAttributes): void;
  *
  * @public
  */
-declare function updateActiveObservation(attributes: LangfuseSpanAttributes, options?: {
+declare function updateActiveObservation(attributes: ElasticDashSpanAttributes, options?: {
     asType: "span";
 }): void;
-declare function updateActiveObservation(attributes: LangfuseGenerationAttributes, options: {
+declare function updateActiveObservation(attributes: ElasticDashGenerationAttributes, options: {
     asType: "generation";
 }): void;
-declare function updateActiveObservation(attributes: LangfuseAgentAttributes, options: {
+declare function updateActiveObservation(attributes: ElasticDashAgentAttributes, options: {
     asType: "agent";
 }): void;
-declare function updateActiveObservation(attributes: LangfuseToolAttributes, options: {
+declare function updateActiveObservation(attributes: ElasticDashToolAttributes, options: {
     asType: "tool";
 }): void;
-declare function updateActiveObservation(attributes: LangfuseChainAttributes, options: {
+declare function updateActiveObservation(attributes: ElasticDashChainAttributes, options: {
     asType: "chain";
 }): void;
-declare function updateActiveObservation(attributes: LangfuseEmbeddingAttributes, options: {
+declare function updateActiveObservation(attributes: ElasticDashEmbeddingAttributes, options: {
     asType: "embedding";
 }): void;
-declare function updateActiveObservation(attributes: LangfuseEvaluatorAttributes, options: {
+declare function updateActiveObservation(attributes: ElasticDashEvaluatorAttributes, options: {
     asType: "evaluator";
 }): void;
-declare function updateActiveObservation(attributes: LangfuseGuardrailAttributes, options: {
+declare function updateActiveObservation(attributes: ElasticDashGuardrailAttributes, options: {
     asType: "guardrail";
 }): void;
-declare function updateActiveObservation(attributes: LangfuseRetrieverAttributes, options: {
+declare function updateActiveObservation(attributes: ElasticDashRetrieverAttributes, options: {
     asType: "retriever";
 }): void;
 /**
@@ -1759,7 +1759,7 @@ interface ObserveOptions {
     /** Name for the observation (defaults to function name) */
     name?: string;
     /** Type of observation to create */
-    asType?: LangfuseObservationType;
+    asType?: ElasticDashObservationType;
     /** Whether to capture function input as observation input */
     captureInput?: boolean;
     /** Whether to capture function output as observation output */
@@ -2087,4 +2087,4 @@ declare function getActiveTraceId(): string | undefined;
  */
 declare function getActiveSpanId(): string | undefined;
 
-export { LangfuseAgent, LangfuseChain, LangfuseEmbedding, LangfuseEvaluator, LangfuseEvent, type LangfuseEventAttributes, LangfuseGeneration, type LangfuseGenerationAttributes, LangfuseGuardrail, type LangfuseObservation, type LangfuseObservationAttributes, type LangfuseObservationType, LangfuseRetriever, LangfuseSpan, type LangfuseSpanAttributes, LangfuseTool, type LangfuseTraceAttributes, type ObservationLevel, type ObserveOptions, type StartActiveObservationContext, type StartActiveObservationOpts, type StartObservationOptions, type StartObservationOpts, createObservationAttributes, createTraceAttributes, createTraceId, getActiveSpanId, getActiveTraceId, getLangfuseTracer, getLangfuseTracerProvider, observe, setLangfuseTracerProvider, startActiveObservation, startObservation, updateActiveObservation, updateActiveTrace };
+export { ElasticDashAgent, ElasticDashChain, ElasticDashEmbedding, ElasticDashEvaluator, ElasticDashEvent, type ElasticDashEventAttributes, ElasticDashGeneration, type ElasticDashGenerationAttributes, ElasticDashGuardrail, type ElasticDashObservation, type ElasticDashObservationAttributes, type ElasticDashObservationType, ElasticDashRetriever, ElasticDashSpan, type ElasticDashSpanAttributes, ElasticDashTool, type ElasticDashTraceAttributes, type ObservationLevel, type ObserveOptions, type StartActiveObservationContext, type StartActiveObservationOpts, type StartObservationOptions, type StartObservationOpts, createObservationAttributes, createTraceAttributes, createTraceId, getActiveSpanId, getActiveTraceId, getElasticDashTracer, getElasticDashTracerProvider, observe, setElasticDashTracerProvider, startActiveObservation, startObservation, updateActiveObservation, updateActiveTrace };