raindrop-ai 0.3.1 → 0.4.0-otelv2

package/dist/{chunk-4TM4IWHB.mjs → chunk-MZZJWWWB.mjs}

@@ -1097,7 +1097,7 @@ installTracingSuppressionHook();
 // package.json
 var package_default = {
   name: "raindrop-ai",
-  version: "0.3.1",
+  version: "0.4.0",
   main: "dist/index.js",
   module: "dist/index.mjs",
   types: "dist/index.d.ts",
@@ -1151,7 +1151,6 @@ var package_default = {
     "@raindrop-ai/redact-pii": "workspace:*",
     "@raindrop-ai/schemas": "workspace:*",
     ai: "^6.0.0",
-    "@opentelemetry/resources": "^2.0.1",
     "@types/node": "^20.11.17",
     msw: "^2.12.8",
     tsup: "^8.4.0",
@@ -1162,9 +1161,25 @@ var package_default = {
   },
   dependencies: {
     "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^1.30.1",
     "@opentelemetry/exporter-trace-otlp-http": "^0.57.2",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.57.2",
-    "@traceloop/node-server-sdk": "0.19.0-otel-v1",
+    "@opentelemetry/instrumentation": "^0.57.2",
+    "@opentelemetry/resources": "^1.30.1",
+    "@opentelemetry/sdk-trace-base": "^1.30.1",
+    "@opentelemetry/sdk-trace-node": "^1.30.1",
+    "@traceloop/ai-semantic-conventions": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-anthropic": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-openai": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-cohere": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-bedrock": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-vertexai": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-pinecone": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-chromadb": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-qdrant": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-together": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-langchain": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-llamaindex": "0.19.0-otel-v1",
     weakref: "^0.2.1",
     zod: "^3.23.8"
   },
@@ -1183,7 +1198,6 @@ var package_default = {
       "esm"
     ],
     external: [
-      "@traceloop/node-server-sdk",
       "@traceloop/instrumentation-anthropic",
       "@traceloop/instrumentation-openai",
       "@traceloop/instrumentation-cohere",
@@ -1193,10 +1207,17 @@ var package_default = {
       "@traceloop/instrumentation-chromadb",
       "@traceloop/instrumentation-qdrant",
       "@traceloop/instrumentation-together",
+      "@traceloop/instrumentation-langchain",
+      "@traceloop/instrumentation-llamaindex",
+      "@traceloop/ai-semantic-conventions",
+      "@opentelemetry/api",
+      "@opentelemetry/core",
       "@opentelemetry/instrumentation",
       "@opentelemetry/exporter-trace-otlp-http",
       "@opentelemetry/exporter-trace-otlp-proto",
-      "@opentelemetry/sdk-trace-base"
+      "@opentelemetry/resources",
+      "@opentelemetry/sdk-trace-base",
+      "@opentelemetry/sdk-trace-node"
     ],
     noExternal: [
       "@raindrop-ai/core",
@@ -1409,13 +1430,15 @@ function traceloopConfiguredWithoutClaim() {
 }
 
 // src/tracing/tracer-core.ts
-import { SpanStatusCode as SpanStatusCode5, context as context5, trace as trace5 } from "@opentelemetry/api";
+import { SpanStatusCode as SpanStatusCode5, context as context6, trace as trace6 } from "@opentelemetry/api";
 import { OTLPTraceExporter as OTLPHttpTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { AnthropicInstrumentation } from "@traceloop/instrumentation-anthropic";
 import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
 import { ChromaDBInstrumentation } from "@traceloop/instrumentation-chromadb";
 import { CohereInstrumentation } from "@traceloop/instrumentation-cohere";
 import { OpenAIInstrumentation } from "@traceloop/instrumentation-openai";
+import { LangChainInstrumentation } from "@traceloop/instrumentation-langchain";
+import { LlamaIndexInstrumentation } from "@traceloop/instrumentation-llamaindex";
 import { PineconeInstrumentation } from "@traceloop/instrumentation-pinecone";
 import { QdrantInstrumentation } from "@traceloop/instrumentation-qdrant";
 import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
@@ -1423,7 +1446,411 @@ import {
   AIPlatformInstrumentation,
   VertexAIInstrumentation
 } from "@traceloop/instrumentation-vertexai";
-import * as traceloop4 from "@traceloop/node-server-sdk";
+
+// src/tracing/otel-core/index.ts
+import {
+  DiagConsoleLogger,
+  DiagLogLevel,
+  context,
+  diag,
+  trace
+} from "@opentelemetry/api";
+import { suppressTracing } from "@opentelemetry/core";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import * as resourceModule from "@opentelemetry/resources";
+import {
+  BatchSpanProcessor,
+  SimpleSpanProcessor
+} from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import {
+  CONTEXT_KEY_ALLOW_TRACE_CONTENT,
+  SpanAttributes,
+  TraceloopSpanKindValues
+} from "@traceloop/ai-semantic-conventions";
+var ALL_INSTRUMENTATION_LIBRARIES = "all";
+var TRACER_NAME = "@traceloop/node-server-sdk";
+var WORKFLOW_NAME_KEY = /* @__PURE__ */ Symbol.for("raindrop.otelCore.workflowName");
+var ENTITY_NAME_KEY = /* @__PURE__ */ Symbol.for("raindrop.otelCore.entityName");
+var ASSOCIATION_PROPERTIES_KEY = /* @__PURE__ */ Symbol.for("raindrop.otelCore.associationProperties");
+var INSTRUMENTATION_LIBRARIES = [
+  "ai",
+  "@traceloop/node-server-sdk",
+  "@traceloop/instrumentation-openai",
+  "@traceloop/instrumentation-langchain",
+  "@traceloop/instrumentation-chroma",
+  "@traceloop/instrumentation-chromadb",
+  "@traceloop/instrumentation-anthropic",
+  "@traceloop/instrumentation-llamaindex",
+  "@traceloop/instrumentation-vertexai",
+  "@traceloop/instrumentation-bedrock",
+  "@traceloop/instrumentation-cohere",
+  "@traceloop/instrumentation-pinecone",
+  "@traceloop/instrumentation-qdrant",
+  "@traceloop/instrumentation-together",
+  TRACER_NAME,
+  "traceloop.tracer"
+];
+var AI_GENERATE_TEXT = "ai.generateText.doGenerate";
+var AI_STREAM_TEXT = "ai.streamText.doStream";
+var AI_RESPONSE_TEXT = "ai.response.text";
+var AI_PROMPT_MESSAGES = "ai.prompt.messages";
+var AI_PROMPT_TOKENS = "ai.usage.promptTokens";
+var AI_COMPLETION_TOKENS = "ai.usage.completionTokens";
+var AI_MODEL_PROVIDER = "ai.model.provider";
+var STATE_KEY2 = /* @__PURE__ */ Symbol.for("raindrop.otelCore.state");
+function getState2() {
+  var _a;
+  const holder = globalThis;
+  (_a = holder[STATE_KEY2]) != null ? _a : holder[STATE_KEY2] = {};
+  return holder[STATE_KEY2];
+}
+function parseHeaders(value) {
+  const headers = {};
+  if (!value) return headers;
+  for (const pair of value.split(",")) {
+    const separator = pair.indexOf("=");
+    if (separator <= 0) continue;
+    try {
+      const key = decodeURIComponent(pair.slice(0, separator).trim());
+      const val = decodeURIComponent(pair.slice(separator + 1).trim());
+      if (key && val) headers[key] = val;
+    } catch (e) {
+    }
+  }
+  return headers;
+}
+function safeStringify(value) {
+  try {
+    const result = JSON.stringify(value);
+    return result === void 0 ? String(value) : result;
+  } catch (e) {
+    return "[unserializable]";
+  }
+}
+function createResource(attributes) {
+  if ("resourceFromAttributes" in resourceModule) {
+    const factory = resourceModule.resourceFromAttributes;
+    if (typeof factory === "function") return factory(attributes);
+  }
+  return new resourceModule.Resource(attributes);
+}
+function detectRuntimeResource() {
+  try {
+    if ("detectResourcesSync" in resourceModule && typeof resourceModule.detectResourcesSync === "function" && "envDetectorSync" in resourceModule) {
+      return resourceModule.detectResourcesSync({
+        detectors: [
+          resourceModule.envDetectorSync,
+          resourceModule.processDetectorSync,
+          resourceModule.hostDetectorSync
+        ]
+      });
+    }
+    if ("detectResources" in resourceModule && typeof resourceModule.detectResources === "function" && "envDetector" in resourceModule) {
+      const detected = resourceModule.detectResources({
+        detectors: [
+          resourceModule.envDetector,
+          resourceModule.processDetector,
+          resourceModule.hostDetector
+        ]
+      });
+      if (!(detected instanceof Promise)) {
+        return detected;
+      }
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function logLevel(level) {
+  switch (level) {
+    case "debug":
+      return DiagLogLevel.DEBUG;
+    case "info":
+      return DiagLogLevel.INFO;
+    case "warn":
+      return DiagLogLevel.WARN;
+    default:
+      return DiagLogLevel.ERROR;
+  }
+}
+function transformAiSdkSpan(span) {
+  const names = {
+    [AI_GENERATE_TEXT]: "ai.generateText.generate",
+    [AI_STREAM_TEXT]: "ai.streamText.stream"
+  };
+  if (!(span.name in names)) return span;
+  const attributes = span.attributes;
+  if (AI_RESPONSE_TEXT in attributes) {
+    const response = attributes[AI_RESPONSE_TEXT];
+    if (typeof response === "string") {
+      attributes[`${SpanAttributes.LLM_COMPLETIONS}.0.content`] = response;
+    }
+    attributes[`${SpanAttributes.LLM_COMPLETIONS}.0.role`] = "assistant";
+    delete attributes[AI_RESPONSE_TEXT];
+  }
+  if (AI_PROMPT_MESSAGES in attributes) {
+    try {
+      const parsed = JSON.parse(String(attributes[AI_PROMPT_MESSAGES]));
+      if (Array.isArray(parsed)) {
+        parsed.forEach((message, index) => {
+          if (!message || typeof message !== "object") return;
+          const content = "content" in message ? message.content : void 0;
+          const role = "role" in message ? message.role : void 0;
+          attributes[`${SpanAttributes.LLM_PROMPTS}.${index}.content`] = typeof content === "string" ? content : safeStringify(content);
+          if (typeof role === "string") {
+            attributes[`${SpanAttributes.LLM_PROMPTS}.${index}.role`] = role;
+          }
+        });
+      }
+      delete attributes[AI_PROMPT_MESSAGES];
+    } catch (e) {
+    }
+  }
+  if (AI_PROMPT_TOKENS in attributes) {
+    attributes[SpanAttributes.LLM_USAGE_PROMPT_TOKENS] = Number(attributes[AI_PROMPT_TOKENS]);
+    delete attributes[AI_PROMPT_TOKENS];
+  }
+  if (AI_COMPLETION_TOKENS in attributes) {
+    attributes[SpanAttributes.LLM_USAGE_COMPLETION_TOKENS] = Number(attributes[AI_COMPLETION_TOKENS]);
+    delete attributes[AI_COMPLETION_TOKENS];
+  }
+  const prompt = attributes[SpanAttributes.LLM_USAGE_PROMPT_TOKENS];
+  const completion = attributes[SpanAttributes.LLM_USAGE_COMPLETION_TOKENS];
+  if (prompt !== void 0 && completion !== void 0) {
+    attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS] = Number(prompt) + Number(completion);
+  }
+  if (AI_MODEL_PROVIDER in attributes) {
+    const vendor = String(attributes[AI_MODEL_PROVIDER]);
+    attributes[SpanAttributes.LLM_SYSTEM] = vendor.startsWith("openai") ? "OpenAI" : vendor;
+    delete attributes[AI_MODEL_PROVIDER];
+  }
+  Object.defineProperty(span, "name", {
+    configurable: true,
+    value: names[span.name],
+    writable: true
+  });
+  return span;
+}
+function scopeName(span) {
+  var _a;
+  if ("instrumentationScope" in span) {
+    const scope = span.instrumentationScope;
+    if (scope && typeof scope === "object" && "name" in scope && typeof scope.name === "string") {
+      return scope.name;
+    }
+  }
+  return (_a = span.instrumentationLibrary) == null ? void 0 : _a.name;
+}
+function contentCaptureDisabled(options) {
+  return options.traceContent === false || (process.env.TRACELOOP_TRACE_CONTENT || "true").toLowerCase() === "false";
+}
+function shouldSendTraceContent() {
+  var _a;
+  const contextual = context.active().getValue(CONTEXT_KEY_ALLOW_TRACE_CONTENT);
+  if (typeof contextual === "boolean") return contextual;
+  if (((_a = getState2().configuration) == null ? void 0 : _a.traceContent) === false) return false;
+  return (process.env.TRACELOOP_TRACE_CONTENT || "true").toLowerCase() !== "false";
+}
+function enrichStart(span) {
+  const active = context.active();
+  const workflow = active.getValue(WORKFLOW_NAME_KEY);
+  if (typeof workflow === "string") span.setAttribute(SpanAttributes.TRACELOOP_WORKFLOW_NAME, workflow);
+  const entity = active.getValue(ENTITY_NAME_KEY);
+  if (typeof entity === "string") span.setAttribute(SpanAttributes.TRACELOOP_ENTITY_PATH, entity);
+  const properties = active.getValue(ASSOCIATION_PROPERTIES_KEY);
+  if (properties && typeof properties === "object") {
+    for (const [key, value] of Object.entries(properties)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        span.setAttribute(`${SpanAttributes.TRACELOOP_ASSOCIATION_PROPERTIES}.${key}`, value);
+      }
+    }
+  }
+}
+function createSpanProcessor(options) {
+  var _a, _b;
+  const baseUrl = options.baseUrl || process.env.TRACELOOP_BASE_URL || "https://api.traceloop.com";
+  const apiKey = options.apiKey || process.env.TRACELOOP_API_KEY;
+  const resolvedHeaders = (_a = options.headers) != null ? _a : process.env.TRACELOOP_HEADERS ? parseHeaders(process.env.TRACELOOP_HEADERS) : { Authorization: `Bearer ${apiKey}` };
+  const exporter = (_b = options.exporter) != null ? _b : new OTLPTraceExporter({ url: `${baseUrl}/v1/traces`, headers: resolvedHeaders });
+  const processor = options.disableBatch ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter);
+  const originalOnStart = processor.onStart.bind(processor);
+  const originalOnEnd = processor.onEnd.bind(processor);
+  processor.onStart = (span, parentContext) => {
+    try {
+      enrichStart(span);
+      originalOnStart(span, parentContext);
+    } catch (e) {
+    }
+  };
+  processor.onEnd = (span) => {
+    var _a2;
+    let outgoing = span;
+    try {
+      const allowed = options.allowedInstrumentationLibraries;
+      if (allowed !== ALL_INSTRUMENTATION_LIBRARIES && ![...INSTRUMENTATION_LIBRARIES, ...allowed != null ? allowed : []].includes((_a2 = scopeName(span)) != null ? _a2 : "")) {
+        return;
+      }
+      outgoing = transformAiSdkSpan(span);
+    } catch (e) {
+    }
+    try {
+      originalOnEnd(outgoing);
+    } catch (e) {
+    }
+  };
+  return processor;
+}
+function initialize(options = {}) {
+  var _a;
+  const state = getState2();
+  if (state.configuration) return;
+  state.configuration = Object.freeze({ ...options });
+  if (options.logLevel) diag.setLogger(new DiagConsoleLogger(), logLevel(options.logLevel));
+  if (options.tracingEnabled === false) return;
+  const baseUrl = options.baseUrl || process.env.TRACELOOP_BASE_URL || "https://api.traceloop.com";
+  state.defaultProcessor = createSpanProcessor({
+    ...options,
+    baseUrl,
+    allowedInstrumentationLibraries: ALL_INSTRUMENTATION_LIBRARIES
+  });
+  const serviceResource = createResource({
+    "service.name": options.appName || process.env.npm_package_name || "unknown_service"
+  });
+  const detectedResource = detectRuntimeResource();
+  state.provider = new NodeTracerProvider({
+    // Detected attributes win over the configured resource, matching
+    // sdk-node's `this._resource.merge(detectResourcesSync(...))` so
+    // OTEL_SERVICE_NAME / OTEL_RESOURCE_ATTRIBUTES can still override appName.
+    resource: detectedResource ? serviceResource.merge(detectedResource) : serviceResource,
+    spanProcessors: [state.defaultProcessor, ...options.processor ? [options.processor] : []]
+  });
+  state.provider.register({
+    contextManager: options.contextManager,
+    propagator: options.propagator
+  });
+  const instrumentations = (_a = options.instrumentations) != null ? _a : [];
+  if (contentCaptureDisabled(options)) {
+    for (const instrumentation of instrumentations) {
+      try {
+        const config = {
+          ...instrumentation.getConfig(),
+          traceContent: false
+        };
+        instrumentation.setConfig(config);
+      } catch (e) {
+      }
+    }
+  }
+  registerInstrumentations({ instrumentations });
+}
+async function forceFlush() {
+  var _a, _b;
+  const state = getState2();
+  try {
+    await ((_a = state.provider) == null ? void 0 : _a.forceFlush());
+    await ((_b = state.defaultProcessor) == null ? void 0 : _b.forceFlush());
+  } catch (e) {
+  }
+}
+function withEntity(type, config, fn, args) {
+  let entityContext = context.active();
+  if (type === TraceloopSpanKindValues.WORKFLOW) {
+    entityContext = entityContext.setValue(WORKFLOW_NAME_KEY, config.name);
+  }
+  const parentPath = entityContext.getValue(ENTITY_NAME_KEY);
+  if (type === TraceloopSpanKindValues.TASK || type === TraceloopSpanKindValues.TOOL) {
+    entityContext = entityContext.setValue(
+      ENTITY_NAME_KEY,
+      `${typeof parentPath === "string" ? `${parentPath}.` : ""}${config.name}`
+    );
+  }
+  if (config.traceContent !== void 0) {
+    entityContext = entityContext.setValue(CONTEXT_KEY_ALLOW_TRACE_CONTENT, config.traceContent);
+  }
+  if (config.associationProperties) {
+    entityContext = entityContext.setValue(ASSOCIATION_PROPERTIES_KEY, config.associationProperties);
+  }
+  if (config.suppressTracing) {
+    entityContext = suppressTracing(entityContext);
+  }
+  let callbackStarted = false;
+  const run = (span) => {
+    var _a;
+    try {
+      span.setAttribute(SpanAttributes.TRACELOOP_ENTITY_NAME, config.name);
+      span.setAttribute(SpanAttributes.TRACELOOP_ENTITY_PATH, typeof parentPath === "string" ? parentPath : "");
+      span.setAttribute(SpanAttributes.TRACELOOP_SPAN_KIND, type);
+      if (type === TraceloopSpanKindValues.WORKFLOW) {
+        span.setAttribute(SpanAttributes.TRACELOOP_WORKFLOW_NAME, config.name);
+      }
+      if (config.version !== void 0) span.setAttribute(SpanAttributes.TRACELOOP_ENTITY_VERSION, config.version);
+      const input = (_a = config.inputParameters) != null ? _a : args;
+      if (shouldSendTraceContent()) {
+        span.setAttribute(
+          SpanAttributes.TRACELOOP_ENTITY_INPUT,
+          safeStringify(input.length === 1 && input[0] !== null && typeof input[0] === "object" && !(input[0] instanceof Map) ? { args: [], kwargs: input[0] } : { args: input, kwargs: {} })
+        );
+      }
+    } catch (e) {
+    }
+    let result;
+    try {
+      callbackStarted = true;
+      result = fn(...args);
+    } catch (error) {
+      try {
+        span.end();
+      } catch (e) {
+      }
+      throw error;
+    }
+    if (result instanceof Promise) {
+      return result.then(
+        (value) => {
+          try {
+            if (shouldSendTraceContent()) span.setAttribute(SpanAttributes.TRACELOOP_ENTITY_OUTPUT, safeStringify(value));
+            span.end();
+          } catch (e) {
+          }
+          return value;
+        },
+        (error) => {
+          try {
+            span.end();
+          } catch (e) {
+          }
+          throw error;
+        }
+      );
+    }
+    try {
+      if (shouldSendTraceContent()) span.setAttribute(SpanAttributes.TRACELOOP_ENTITY_OUTPUT, safeStringify(result));
+      span.end();
+    } catch (e) {
+    }
+    return result;
+  };
+  try {
+    const tracer = trace.getTracer(TRACER_NAME);
+    return context.with(
+      entityContext,
+      () => tracer.startActiveSpan(`${config.name}.${type}`, {}, entityContext, run)
+    );
+  } catch (error) {
+    if (callbackStarted) throw error;
+    return fn(...args);
+  }
+}
+function withTask(config, fn, ...args) {
+  return withEntity(TraceloopSpanKindValues.TASK, config, fn, args);
+}
+function withTool(config, fn, ...args) {
+  return withEntity(TraceloopSpanKindValues.TOOL, config, fn, args);
+}
+
+// src/tracing/tracer-core.ts
 import { WeakValueMap } from "weakref";
 
 // src/tracing/direct/http.ts
@@ -1624,7 +2051,7 @@ function buildExportTraceServiceRequest2(spans) {
 }
 
 // src/tracing/direct/context.ts
-import { context, isValidSpanId, isValidTraceId, trace } from "@opentelemetry/api";
+import { context as context2, isValidSpanId, isValidTraceId, trace as trace2 } from "@opentelemetry/api";
 var INVALID_TRACE_ID = "00000000000000000000000000000000";
 var INVALID_SPAN_ID = "0000000000000000";
 function hexToBase64(hex) {
@@ -1644,7 +2071,7 @@ function getExplicitTraceContext(traceId, parentSpanId) {
   };
 }
 function getActiveTraceContext() {
-  const activeSpan = trace.getSpan(context.active());
+  const activeSpan = trace2.getSpan(context2.active());
   if (!activeSpan) return {};
   const spanContext = activeSpan.spanContext();
   const traceIdHex = spanContext.traceId;
@@ -1890,18 +2317,17 @@ var DirectTraceShipper = class {
 };
 
 // src/tracing/exit-flush.ts
-import * as traceloop from "@traceloop/node-server-sdk";
-var STATE_KEY2 = /* @__PURE__ */ Symbol.for("raindrop.tracing.exitFlushState");
-function getState2() {
+var STATE_KEY3 = /* @__PURE__ */ Symbol.for("raindrop.tracing.exitFlushState");
+function getState3() {
   const holder = globalThis;
-  let state = holder[STATE_KEY2];
+  let state = holder[STATE_KEY3];
   if (!state) {
     state = {
       clientFlushers: /* @__PURE__ */ new Set(),
       pipelineFlushNeeded: false,
       handlerRegistered: false
     };
-    holder[STATE_KEY2] = state;
+    holder[STATE_KEY3] = state;
   }
   return state;
 }
@@ -1914,7 +2340,7 @@ function ensureExitHandler(state) {
   });
 }
 function registerClientFlusher(flush) {
-  const state = getState2();
+  const state = getState3();
   state.clientFlushers.add(flush);
   ensureExitHandler(state);
   return () => {
@@ -1922,12 +2348,12 @@ function registerClientFlusher(flush) {
   };
 }
 function markPipelineForExitFlush() {
-  const state = getState2();
+  const state = getState3();
   state.pipelineFlushNeeded = true;
   ensureExitHandler(state);
 }
 async function flushAll() {
-  const state = getState2();
+  const state = getState3();
   const tasks = [];
   for (const flush of state.clientFlushers) {
     tasks.push(Promise.resolve().then(flush).catch(() => {
@@ -1935,7 +2361,7 @@ async function flushAll() {
   }
   if (state.pipelineFlushNeeded) {
     tasks.push(
-      Promise.resolve().then(() => traceloop.forceFlush()).catch(() => {
+      Promise.resolve().then(() => forceFlush()).catch(() => {
       })
     );
   }
@@ -1946,15 +2372,14 @@ async function flushAll() {
 import {
   SpanStatusCode as SpanStatusCode3,
   TraceFlags,
-  context as context3,
+  context as context4,
   isValidSpanId as isValidSpanId2,
   isValidTraceId as isValidTraceId2,
-  trace as trace3
+  trace as trace4
 } from "@opentelemetry/api";
-import * as traceloop2 from "@traceloop/node-server-sdk";
 
 // src/tracing/subagents.ts
-import { SpanStatusCode as SpanStatusCode2, context as context2, trace as trace2 } from "@opentelemetry/api";
+import { SpanStatusCode as SpanStatusCode2, context as context3, trace as trace3 } from "@opentelemetry/api";
 var DEFAULT_SUBAGENT_NAME = "subagent";
 var DISPATCH_ACCEPTED = "accepted";
 function reasonText(reason) {
@@ -1970,7 +2395,7 @@ function reasonText(reason) {
 }
 function stampCurrentSpan(attributes) {
   try {
-    const span = trace2.getSpan(context2.active());
+    const span = trace3.getSpan(context3.active());
     if (!(span == null ? void 0 : span.isRecording())) return;
     for (const [key, value] of Object.entries(attributes)) {
       span.setAttribute(key, value);
@@ -1981,7 +2406,7 @@ function stampCurrentSpan(attributes) {
 function stampOwnSpan(attributes, frame) {
   if (!frame) return;
   try {
-    const span = trace2.getSpan(context2.active());
+    const span = trace3.getSpan(context3.active());
     if (!(span == null ? void 0 : span.isRecording()) || !frame.ownsSpan(span)) return;
     for (const [key, value] of Object.entries(attributes)) {
       span.setAttribute(key, value);
@@ -1991,7 +2416,7 @@ function stampOwnSpan(attributes, frame) {
 }
 function failOwnSpan(reason, frame) {
   try {
-    const span = trace2.getSpan(context2.active());
+    const span = trace3.getSpan(context3.active());
     if (!(span == null ? void 0 : span.isRecording())) return false;
     if (!(frame == null ? void 0 : frame.ownsSpan(span))) return false;
     const message = reasonText(reason);
@@ -2239,16 +2664,16 @@ var LiveSubagentRun = class {
 };
 
 // src/tracing/liveInteraction.ts
-function getPropertiesFromContext(context6) {
+function getPropertiesFromContext(context7) {
   const properties = {
-    ...context6.userId && { user_id: context6.userId },
-    ...context6.convoId && { convo_id: context6.convoId },
-    ...context6.eventId && { event_id: context6.eventId },
-    ...context6.event && { event_name: context6.event },
-    ...context6.properties || {}
+    ...context7.userId && { user_id: context7.userId },
+    ...context7.convoId && { convo_id: context7.convoId },
+    ...context7.eventId && { event_id: context7.eventId },
+    ...context7.event && { event_name: context7.event },
+    ...context7.properties || {}
   };
-  if (context6.attachments && context6.attachments.length > 0) {
-    properties.attachments = stringifyBounded(context6.attachments);
+  if (context7.attachments && context7.attachments.length > 0) {
+    properties.attachments = stringifyBounded(context7.attachments);
   }
   return properties;
 }
@@ -2268,12 +2693,12 @@ function serializeAssociationProperties(properties) {
 function serializeSpanValue(value) {
   return stringifyBounded(value);
 }
-function getLocalDebuggerMetadata(context6) {
+function getLocalDebuggerMetadata(context7) {
   return {
-    ...context6.eventId ? { eventId: context6.eventId } : {},
-    ...context6.event ? { eventName: context6.event } : {},
-    ...context6.userId ? { userId: context6.userId } : {},
-    ...context6.convoId ? { convoId: context6.convoId } : {}
+    ...context7.eventId ? { eventId: context7.eventId } : {},
+    ...context7.event ? { eventName: context7.event } : {},
+    ...context7.userId ? { userId: context7.userId } : {},
+    ...context7.convoId ? { convoId: context7.convoId } : {}
   };
 }
 var LiveToolSpan = class {
@@ -2374,11 +2799,11 @@ var DirectToolSpan = class {
   }
 };
 var LiveInteraction = class {
-  constructor(context6, traceId, analytics, directShipper, routing) {
+  constructor(context7, traceId, analytics, directShipper, routing) {
     this.usageEmitted = false;
-    this.context = context6;
+    this.context = context7;
     this.analytics = analytics;
-    this.tracer = trace3.getTracer("traceloop.tracer");
+    this.tracer = trace4.getTracer("traceloop.tracer");
     this.traceId = traceId;
     this.directShipper = directShipper;
     this.routing = routing;
@@ -2413,7 +2838,7 @@ var LiveInteraction = class {
       this.traceId = explicitTraceId;
       return explicitTraceId;
     }
-    const activeSpan = trace3.getSpan(context3.active());
+    const activeSpan = trace4.getSpan(context4.active());
     const activeTraceId = activeSpan == null ? void 0 : activeSpan.spanContext().traceId;
     if (activeTraceId) {
       this.traceId = activeTraceId;
@@ -2460,10 +2885,10 @@ var LiveInteraction = class {
         spanId: base64ToHex2(spanIdB64),
         traceFlags: TraceFlags.SAMPLED
       };
-      const wrappedContext = trace3.setSpan(context3.active(), trace3.wrapSpanContext(spanContext));
+      const wrappedContext = trace4.setSpan(context4.active(), trace4.wrapSpanContext(spanContext));
       const invoke = () => this.routing ? withRoutingContext(this.routing, () => fn.apply(thisArg, args)) : fn.apply(thisArg, args);
       try {
-        const result = await context3.with(wrappedContext, invoke);
+        const result = await context4.with(wrappedContext, invoke);
         const endTimeMs = Date.now();
         this.directShipper.sendSpan({
           name: taskName,
@@ -2498,7 +2923,7 @@ var LiveInteraction = class {
       }
     }
     const wrappedFn = (...fnArgs) => {
-      const activeSpan = trace3.getSpan(context3.active());
+      const activeSpan = trace4.getSpan(context4.active());
       const activeTraceId = activeSpan == null ? void 0 : activeSpan.spanContext().traceId;
       if (activeTraceId) {
         this.traceId = activeTraceId;
@@ -2511,7 +2936,7 @@ var LiveInteraction = class {
       }
       return fn.apply(thisArg, fnArgs);
     };
-    return traceloop2.withTask(
+    return withTask(
       {
         name: taskName,
         associationProperties: serializeAssociationProperties(properties),
@@ -2552,12 +2977,12 @@ var LiveInteraction = class {
         spanId: base64ToHex2(spanIdB64),
         traceFlags: TraceFlags.SAMPLED
       };
-      const wrappedContext = trace3.setSpan(context3.active(), trace3.wrapSpanContext(spanContext));
+      const wrappedContext = trace4.setSpan(context4.active(), trace4.wrapSpanContext(spanContext));
       const invoke = () => this.routing ? withRoutingContext(this.routing, () => fn.apply(thisArg, args)) : fn.apply(thisArg, args);
       let result;
       let error;
       try {
-        result = await context3.with(wrappedContext, invoke);
+        result = await context4.with(wrappedContext, invoke);
       } catch (err) {
         error = err instanceof Error ? err.message : String(err);
         const endTimeMs2 = Date.now();
@@ -2622,7 +3047,7 @@ var LiveInteraction = class {
     const inputParams = params.inputParameters ? [params.inputParameters] : void 0;
     const emitLive = (event) => this.emitLiveEvent(event);
     const wrapped = async (...wrappedArgs) => {
-      const activeSpan = trace3.getSpan(context3.active());
+      const activeSpan = trace4.getSpan(context4.active());
       const ctx = activeSpan == null ? void 0 : activeSpan.spanContext();
       const liveSpanId = ctx && isValidSpanId2(ctx.spanId) ? ctx.spanId : void 0;
       if (activeSpan) {
@@ -2662,7 +3087,7 @@ var LiveInteraction = class {
         throw error;
       }
     };
-    return traceloop2.withTool(
+    return withTool(
       {
         name: toolName,
         associationProperties: serializeAssociationProperties(properties),
@@ -3118,11 +3543,10 @@ var LiveInteraction = class {
 };
 
 // src/tracing/liveTracer.ts
-import { context as context4, isValidSpanId as isValidSpanId3, SpanStatusCode as SpanStatusCode4, trace as trace4 } from "@opentelemetry/api";
-import * as traceloop3 from "@traceloop/node-server-sdk";
+import { context as context5, isValidSpanId as isValidSpanId3, SpanStatusCode as SpanStatusCode4, trace as trace5 } from "@opentelemetry/api";
 var LiveTracer = class {
   constructor(globalProperties, directShipper, routing) {
-    this.tracer = trace4.getTracer("traceloop.tracer");
+    this.tracer = trace5.getTracer("traceloop.tracer");
     this.globalProperties = globalProperties || {};
     this.directShipper = directShipper;
     this.routing = routing;
@@ -3134,7 +3558,7 @@ var LiveTracer = class {
   }
   emitLiveEvent(event) {
     var _a, _b;
-    const activeSpan = trace4.getSpan(context4.active());
+    const activeSpan = trace5.getSpan(context5.active());
     const activeTraceId = activeSpan == null ? void 0 : activeSpan.spanContext().traceId;
     const active = getActiveTraceContext();
     const traceId = (_b = (_a = event.traceId) != null ? _a : activeTraceId) != null ? _b : active.traceIdB64;
@@ -3154,7 +3578,7 @@ var LiveTracer = class {
     };
     const inputParameters = typeof params === "string" ? void 0 : params.inputParameters;
     const wrappedFn = (...fnArgs) => {
-      const activeSpan = trace4.getSpan(context4.active());
+      const activeSpan = trace5.getSpan(context5.active());
       if (activeSpan) {
         this.stampRouting(activeSpan);
       }
@@ -3163,7 +3587,7 @@ var LiveTracer = class {
       }
       return fn.apply(thisArg, fnArgs);
     };
-    return traceloop3.withTask(
+    return withTask(
       {
         name: taskName,
         associationProperties: properties,
@@ -3256,7 +3680,7 @@ var LiveTracer = class {
     }
     span.end(endTimeMs);
     const ctx = span.spanContext();
-    const traceId = ctx.traceId || ((_b = trace4.getSpan(context4.active())) == null ? void 0 : _b.spanContext().traceId);
+    const traceId = ctx.traceId || ((_b = trace5.getSpan(context5.active())) == null ? void 0 : _b.spanContext().traceId);
     const spanIdHex = isValidSpanId3(ctx.spanId) ? ctx.spanId : void 0;
     if (traceId) {
       this.emitLiveEvent({
@@ -3416,7 +3840,7 @@ function createLocalDebuggerSpanProcessor(options) {
     headers: {}
   });
   try {
-    return traceloop4.createSpanProcessor({
+    return createSpanProcessor({
       apiKey: options.writeKey,
       baseUrl: localDebuggerUrl,
       disableBatch: options.disableBatching,
@@ -3664,7 +4088,9 @@ function createDefaultInstrumentations() {
   const bedrockInst = new BedrockInstrumentation();
   patchBedrockStreamingBug(bedrockInst);
   return [
-    new OpenAIInstrumentation(),
+    new OpenAIInstrumentation({
+      enrichTokens: (process.env.TRACELOOP_ENRICH_TOKENS || "true").toLowerCase() === "true"
+    }),
     new AnthropicInstrumentation(),
     new CohereInstrumentation(),
     bedrockInst,
@@ -3673,7 +4099,9 @@ function createDefaultInstrumentations() {
     new PineconeInstrumentation(),
     new TogetherInstrumentation(),
     new ChromaDBInstrumentation(),
-    new QdrantInstrumentation()
+    new QdrantInstrumentation(),
+    new LangChainInstrumentation(),
+    new LlamaIndexInstrumentation()
   ];
 }
 function createManualInstrumentations(instrumentModules) {
@@ -3729,17 +4157,29 @@ function createManualInstrumentations(instrumentModules) {
     inst.manuallyInstrument(instrumentModules.qdrant);
     instrumentations.push(inst);
   }
+  instrumentations.push(new LangChainInstrumentation());
+  if (instrumentModules.llamaIndex) {
+    const inst = new LlamaIndexInstrumentation();
+    inst.manuallyInstrument(instrumentModules.llamaIndex);
+    instrumentations.push(inst);
+  }
   return instrumentations;
 }
+function createConfiguredInstrumentations(options) {
+  if (options.instrumentModules && Object.keys(options.instrumentModules).length > 0) {
+    return createManualInstrumentations(options.instrumentModules);
+  }
+  return createDefaultInstrumentations();
+}
 function getCurrentTraceId() {
   var _a;
-  return (_a = trace5.getSpan(context5.active())) == null ? void 0 : _a.spanContext().traceId;
+  return (_a = trace6.getSpan(context6.active())) == null ? void 0 : _a.spanContext().traceId;
 }
 var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
   var _a;
   process.env.TRACELOOP_TELEMETRY = "false";
   const {
-    logLevel,
+    logLevel: logLevel2,
     useExternalOtel,
     tracingEnabled,
     disableBatching,
@@ -3786,10 +4226,10 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
   const activeInteractionsByEventId = new WeakValueMap();
   try {
     if (useExternalOtel) {
-      traceloop4.initialize({
+      initialize({
         baseUrl: apiUrl,
         apiKey: writeKey,
-        logLevel,
+        logLevel: logLevel2,
         // Traceloop's init banner ("Traceloop exporting traces to <baseUrl>") is
         // misleading inside our wrapper: in external-OTEL mode we create no
         // exporter at all (tracingEnabled: false). Suppress it.
@@ -3815,28 +4255,29 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
       const localDebuggerProcessor = createLocalDebuggerSpanProcessor({
         writeKey,
         disableBatching,
-        allowedInstrumentationLibraries: traceloop4.ALL_INSTRUMENTATION_LIBRARIES,
+        allowedInstrumentationLibraries: ALL_INSTRUMENTATION_LIBRARIES,
         localDebuggerUrlOpt: localDebuggerUrl
       });
       if (!cloudEnabledResolved) {
         if (localDebuggerProcessor) {
-          traceloop4.initialize({
+          initialize({
             baseUrl: apiUrl,
             apiKey: writeKey,
             ...otherOptions,
-            logLevel,
+            logLevel: logLevel2,
             silenceInitializationMessage: true,
             tracingEnabled: tracingEnabled !== false,
             disableBatch: disableBatching,
-            processor: localDebuggerProcessor
+            processor: localDebuggerProcessor,
+            instrumentations: createConfiguredInstrumentations(otherOptions)
           });
           traceloopInitialized = true;
           markTraceloopConfiguredWithoutClaim();
         } else {
-          traceloop4.initialize({
+          initialize({
             baseUrl: apiUrl,
             apiKey: writeKey,
-            logLevel,
+            logLevel: logLevel2,
             silenceInitializationMessage: true,
             tracingEnabled: false
           });
@@ -3882,18 +4323,19 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
               localDebuggerProcessor ? [localDebuggerProcessor] : []
             );
             try {
-              traceloop4.initialize({
+              initialize({
                 baseUrl: apiUrl,
                 apiKey: writeKey,
                 ...otherOptions,
-                logLevel,
+                logLevel: logLevel2,
                 silenceInitializationMessage: true,
                 // This branch only runs when tracing is enabled (the disabled
                 // case is handled above), so tracing is always on here.
                 tracingEnabled: true,
                 disableBatch: disableBatching,
                 processor,
-                exporter: guardedExporter
+                exporter: guardedExporter,
+                instrumentations: createConfiguredInstrumentations(otherOptions)
               });
               traceloopInitialized = true;
             } catch (initError) {
@@ -4024,7 +4466,7 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
         });
         return;
       }
-      const span = trace5.getTracer("traceloop.tracer").startSpan("ai.model.usage");
+      const span = trace6.getTracer("traceloop.tracer").startSpan("ai.model.usage");
       span.setAttribute("traceloop.span.kind", "llm");
       span.setAttribute("traceloop.association.properties.event_id", params.eventId);
       stampSpan(span, projectId, authHint);
@@ -4132,7 +4574,7 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
         );
       }
       const headers = withProjectIdHeaders(processorOptions == null ? void 0 : processorOptions.headers);
-      const productionProcessor = traceloop4.createSpanProcessor({
+      const productionProcessor = createSpanProcessor({
         baseUrl: apiUrl,
         apiKey: writeKey,
         disableBatch: disableBatching,
@@ -4198,7 +4640,7 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
       }
       if (traceloopInitialized) {
         try {
-          await traceloop4.forceFlush();
+          await forceFlush();
         } catch (e) {
         }
       }
@@ -4210,7 +4652,7 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
       await (directShipper == null ? void 0 : directShipper.shutdown());
       if (traceloopInitialized) {
         try {
-          await traceloop4.forceFlush();
+          await forceFlush();
         } catch (e) {
         }
       }