raindrop-ai 0.4.0 → 0.5.0

package/dist/{chunk-MZZJWWWB.mjs → chunk-AUNFORWV.mjs}

@@ -4,7 +4,82 @@ if (!globalThis.RAINDROP_ASYNC_LOCAL_STORAGE) {
   globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = AsyncLocalStorage;
 }
 
-// ../core/dist/chunk-3V4MIA75.js
+// ../core/dist/chunk-BYBMRLZM.js
+var EVAL_CORRELATION_ID_ATTRIBUTE = "raindrop.eval_correlation_id";
+var PROBE_SCOPE = { correlationId: "" };
+var EvalScopeStorage = class {
+  constructor() {
+    this._als = null;
+    this._probed = false;
+  }
+  maybeAdoptAsyncLocalStorage() {
+    if (this._probed) return;
+    this._probed = true;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (!Ctor) return;
+      const als = new Ctor();
+      als.run(PROBE_SCOPE, () => {
+      });
+      this._als = als;
+    } catch (e) {
+      this._als = null;
+    }
+  }
+  run(scope, callback) {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return this._als.run(scope, callback);
+    const previous = this._syncScope;
+    this._syncScope = scope;
+    try {
+      return callback();
+    } finally {
+      this._syncScope = previous;
+    }
+  }
+  current() {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return this._als.getStore();
+    return this._syncScope;
+  }
+};
+var EVAL_SCOPE_STORAGE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.evalScopeStorage");
+function evalScopeStorage() {
+  const holder = globalThis;
+  let storage = holder[EVAL_SCOPE_STORAGE_KEY];
+  if (!storage) {
+    storage = new EvalScopeStorage();
+    holder[EVAL_SCOPE_STORAGE_KEY] = storage;
+  }
+  return storage;
+}
+function withEvalScope(scope, callback) {
+  const correlationId = scope == null ? void 0 : scope.correlationId;
+  if (typeof correlationId !== "string" || correlationId.length === 0) {
+    return callback();
+  }
+  let storage;
+  try {
+    storage = evalScopeStorage();
+  } catch (e) {
+  }
+  if (!storage) return callback();
+  return storage.run({ correlationId }, callback);
+}
+function currentEvalScope() {
+  try {
+    return evalScopeStorage().current();
+  } catch (e) {
+    return void 0;
+  }
+}
+function evalScopeAttributes() {
+  const scope = currentEvalScope();
+  if (!scope) return {};
+  return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
+}
+
+// ../core/dist/chunk-T53LQAH7.js
 function normalizeFeatureFlags(input) {
   if (Array.isArray(input)) {
     return Object.fromEntries(input.map((name) => [name, "true"]));
@@ -427,6 +502,7 @@ async function postJson(url, body, headers, opts) {
       const resp = await runWithTracingSuppressed(
         () => fetch(url, {
           method: "POST",
+          redirect: headers["X-Raindrop-Replay-Id"] !== void 0 ? "error" : "follow",
           headers: {
             "Content-Type": "application/json",
             ...headers
@@ -566,6 +642,66 @@ function attrDouble(key, value) {
   if (!Number.isFinite(value)) return void 0;
   return { key, value: { doubleValue: value } };
 }
+var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
+function state() {
+  const holder = globalThis;
+  let current = holder[STATE_KEY];
+  if (!current) {
+    let storage = null;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (Ctor) storage = new Ctor();
+    } catch (e) {
+      storage = null;
+    }
+    current = {
+      storage,
+      syncDestination: void 0,
+      spanDestinations: /* @__PURE__ */ new WeakMap()
+    };
+    holder[STATE_KEY] = current;
+  }
+  return current;
+}
+function withReplayTraceDestination(destination, callback) {
+  const routing = state();
+  if (routing.storage) return routing.storage.run(destination, callback);
+  const previous = routing.syncDestination;
+  routing.syncDestination = destination;
+  try {
+    return callback();
+  } finally {
+    routing.syncDestination = previous;
+  }
+}
+function currentReplayTraceDestination() {
+  var _a, _b;
+  const routing = state();
+  return (_b = (_a = routing.storage) == null ? void 0 : _a.getStore()) != null ? _b : routing.syncDestination;
+}
+function rememberReplayTraceDestination(span) {
+  const destination = currentReplayTraceDestination();
+  if (destination) state().spanDestinations.set(span, destination);
+}
+function copyReplayTraceDestination(source, target) {
+  const destination = state().spanDestinations.get(source);
+  if (destination) state().spanDestinations.set(target, destination);
+}
+function replayTraceDestinationFor(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return void 0;
+  }
+  return state().spanDestinations.get(value);
+}
+function recordReplayExportedSpan(destination, spanId, traceId) {
+  var _a, _b;
+  if (!destination || !spanId || !traceId) return;
+  (_a = destination.exportedSpanIds) == null ? void 0 : _a.add(spanId);
+  (_b = destination.exportedTraceIds) == null ? void 0 : _b.add(traceId);
+}
+function replayTraceUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
+}
 var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
 var WORKSHOP_ENV_VAR = "RAINDROP_WORKSHOP";
 var DEFAULT_LOCAL_WORKSHOP_URL = "http://localhost:5899/v1/";
@@ -631,31 +767,36 @@ function resolveLocalDebuggerBaseUrl(baseUrl) {
 function localDebuggerEnabled(baseUrl) {
   return resolveLocalDebuggerBaseUrl(baseUrl) !== null;
 }
+var LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS = 2e3;
 function mirrorTraceExportToLocalDebugger(body, options = {}) {
   var _a;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
-  if (!baseUrl) return;
-  void postJson(`${baseUrl}traces`, body, {}, {
+  if (!baseUrl) return Promise.resolve();
+  return postJson(`${baseUrl}traces`, body, {}, {
     maxAttempts: 1,
     debug: (_a = options.debug) != null ? _a : false,
-    sdkName: options.sdkName
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
   }).catch(() => {
   });
 }
 function mirrorPartialEventToLocalDebugger(event, options = {}) {
   var _a;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
-  if (!baseUrl) return;
+  if (!baseUrl) return Promise.resolve();
   const headers = options.writeKey ? { Authorization: `Bearer ${options.writeKey}` } : {};
-  void postJson(`${baseUrl}events/track_partial`, event, headers, {
+  return postJson(`${baseUrl}events/track_partial`, event, headers, {
     maxAttempts: 1,
     debug: (_a = options.debug) != null ? _a : false,
-    sdkName: options.sdkName
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
   }).catch(() => {
   });
 }
 function sendLocalDebuggerLiveEvent(event, options = {}) {
   var _a, _b;
+  const destination = currentReplayTraceDestination();
+  if (destination && destination.kind !== "workshop") return;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
   if (!baseUrl) return;
   void postJson(
@@ -1097,7 +1238,7 @@ installTracingSuppressionHook();
 // package.json
 var package_default = {
   name: "raindrop-ai",
-  version: "0.4.0",
+  version: "0.5.0",
   main: "dist/index.js",
   module: "dist/index.mjs",
   types: "dist/index.d.ts",
@@ -1108,9 +1249,14 @@ var package_default = {
   },
   exports: {
     ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.mjs",
-      require: "./dist/index.js"
+      import: {
+        types: "./dist/index.d.mts",
+        default: "./dist/index.mjs"
+      },
+      require: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      }
     },
     "./tracing": {
       types: "./dist/tracing/index.d.ts",
@@ -1150,8 +1296,8 @@ var package_default = {
     "@raindrop-ai/core": "workspace:*",
     "@raindrop-ai/redact-pii": "workspace:*",
     "@raindrop-ai/schemas": "workspace:*",
-    ai: "^6.0.0",
     "@types/node": "^20.11.17",
+    ai: "^6.0.0",
     msw: "^2.12.8",
     tsup: "^8.4.0",
     tsx: "^4.20.3",
@@ -1160,6 +1306,7 @@ var package_default = {
     vitest: "^4.0.10"
   },
   dependencies: {
+    "@jitl/quickjs-singlefile-cjs-release-sync": "0.32.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^1.30.1",
     "@opentelemetry/exporter-trace-otlp-http": "^0.57.2",
@@ -1170,16 +1317,17 @@ var package_default = {
     "@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-cohere": "0.19.0-otel-v1",
     "@traceloop/instrumentation-langchain": "0.19.0-otel-v1",
     "@traceloop/instrumentation-llamaindex": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-openai": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-pinecone": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-qdrant": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-together": "0.19.0-otel-v1",
+    "@traceloop/instrumentation-vertexai": "0.19.0-otel-v1",
+    "quickjs-emscripten-core": "0.32.0",
     weakref: "^0.2.1",
     zod: "^3.23.8"
   },
@@ -1233,22 +1381,136 @@ var package_default = {
 
 // src/tracing/multi-project.ts
 import { createHash } from "crypto";
+import { OTLPTraceExporter as OTLPProtoTraceExporter2 } from "@opentelemetry/exporter-trace-otlp-proto";
+
+// src/tracing/replay-routing.ts
 import { OTLPTraceExporter as OTLPProtoTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
-var PROJECT_ID_SPAN_ATTRIBUTE = "raindrop.project_id";
-var AUTH_HINT_SPAN_ATTRIBUTE = "raindrop.auth_hint";
 var EXPORT_SUCCESS = 0;
 var EXPORT_FAILED = 1;
+function recordExportedSpan(destination, span) {
+  if (typeof span !== "object" && typeof span !== "function" || span === null) return;
+  const spanContext = span.spanContext;
+  if (typeof spanContext !== "function") return;
+  const context7 = spanContext.call(span);
+  if (typeof (context7 == null ? void 0 : context7.spanId) === "string" && typeof context7.traceId === "string") {
+    recordReplayExportedSpan(destination, context7.spanId, context7.traceId);
+  }
+}
+function createReplayExporter(destination) {
+  var _a;
+  if (destination.kind === "workshop") {
+    return new OTLPProtoTraceExporter({
+      url: replayTraceUrl(destination.url)
+    });
+  }
+  return new OTLPProtoTraceExporter({
+    url: replayTraceUrl(destination.url),
+    headers: {
+      Authorization: `Bearer ${destination.apiKey}`,
+      "X-Raindrop-Replay-Id": destination.replayId,
+      "X-Raindrop-Project-Id": (_a = destination.projectId) != null ? _a : "default"
+    }
+  });
+}
+var ReplayRoutingSpanExporter = class {
+  constructor(normal, replayExporter = createReplayExporter) {
+    this.normal = normal;
+    this.replayExporter = replayExporter;
+  }
+  export(spans, resultCallback) {
+    const replayGroups = /* @__PURE__ */ new Map();
+    const normalSpans = [];
+    for (const span of spans) {
+      const destination = replayTraceDestinationFor(span);
+      if (!destination) {
+        normalSpans.push(span);
+        continue;
+      }
+      const group = replayGroups.get(destination);
+      recordExportedSpan(destination, span);
+      if (group) group.push(span);
+      else replayGroups.set(destination, [span]);
+    }
+    if (replayGroups.size === 0) {
+      this.normal.export(spans, resultCallback);
+      return;
+    }
+    let remaining = replayGroups.size + (normalSpans.length > 0 ? 1 : 0);
+    let failed = false;
+    let firstError;
+    const finish = (result) => {
+      if (result.code !== EXPORT_SUCCESS) {
+        failed = true;
+        firstError != null ? firstError : firstError = result.error;
+      }
+      remaining -= 1;
+      if (remaining === 0) {
+        resultCallback(
+          firstError ? { code: EXPORT_FAILED, error: firstError } : { code: failed ? EXPORT_FAILED : EXPORT_SUCCESS }
+        );
+      }
+    };
+    if (normalSpans.length > 0) {
+      try {
+        this.normal.export(normalSpans, finish);
+      } catch (cause) {
+        finish({
+          code: EXPORT_FAILED,
+          error: cause instanceof Error ? cause : new Error(String(cause))
+        });
+      }
+    }
+    for (const [destination, replaySpans] of replayGroups) {
+      let exporter;
+      try {
+        exporter = this.replayExporter(destination);
+      } catch (cause) {
+        finish({
+          code: EXPORT_FAILED,
+          error: cause instanceof Error ? cause : new Error(String(cause))
+        });
+        continue;
+      }
+      try {
+        exporter.export(replaySpans, (result) => {
+          finish(result);
+          void exporter.shutdown().catch(() => {
+          });
+        });
+      } catch (cause) {
+        finish({
+          code: EXPORT_FAILED,
+          error: cause instanceof Error ? cause : new Error(String(cause))
+        });
+        void exporter.shutdown().catch(() => {
+        });
+      }
+    }
+  }
+  forceFlush() {
+    return this.normal.forceFlush ? this.normal.forceFlush() : Promise.resolve();
+  }
+  shutdown() {
+    return this.normal.shutdown();
+  }
+};
+
+// src/tracing/multi-project.ts
+var PROJECT_ID_SPAN_ATTRIBUTE = "raindrop.project_id";
+var AUTH_HINT_SPAN_ATTRIBUTE = "raindrop.auth_hint";
+var EXPORT_SUCCESS2 = 0;
+var EXPORT_FAILED2 = 1;
 var SPAN_STATUS_ERROR = 2;
 function authHintForKey(writeKey) {
   if (!writeKey) return void 0;
   return createHash("sha256").update(writeKey, "utf8").digest("hex").slice(0, 8);
 }
-var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.multiProjectState");
+var STATE_KEY2 = /* @__PURE__ */ Symbol.for("raindrop.tracing.multiProjectState");
 function getState() {
   const holder = globalThis;
-  let state = holder[STATE_KEY];
-  if (!state) {
-    state = {
+  let state2 = holder[STATE_KEY2];
+  if (!state2) {
+    state2 = {
       foreignClientSeen: false,
       seenClientHints: /* @__PURE__ */ new Set(),
       ownerAuthHint: void 0,
@@ -1258,29 +1520,29 @@ function getState() {
       multiKeyWarned: false,
       pendingMultiKeyWarning: false
     };
-    holder[STATE_KEY] = state;
+    holder[STATE_KEY2] = state2;
   }
-  return state;
+  return state2;
 }
 function emitMultiKeyWarningOnce() {
-  const state = getState();
-  if (state.multiKeyWarned) return;
-  state.multiKeyWarned = true;
-  state.pendingMultiKeyWarning = false;
+  const state2 = getState();
+  if (state2.multiKeyWarned) return;
+  state2.multiKeyWarned = true;
+  state2.pendingMultiKeyWarning = false;
   console.warn(
     "[raindrop] Multiple API keys detected in one process. The OTel export guard now requires positive attribution: spans not bound to any client (no begin()/asCurrent()) are dropped, and spans bound to a non-owner key are dropped. Manual events are unaffected."
   );
 }
 function registerClientKey(authHint, tracingEnabled = false) {
   if (!authHint) return;
-  const state = getState();
-  state.seenClientHints.add(authHint);
-  if (state.seenClientHints.size > 1) {
-    state.foreignClientSeen = true;
-    if (tracingEnabled || state.pipelineClaimed) {
+  const state2 = getState();
+  state2.seenClientHints.add(authHint);
+  if (state2.seenClientHints.size > 1) {
+    state2.foreignClientSeen = true;
+    if (tracingEnabled || state2.pipelineClaimed) {
       emitMultiKeyWarningOnce();
     } else {
-      state.pendingMultiKeyWarning = true;
+      state2.pendingMultiKeyWarning = true;
     }
   }
 }
@@ -1304,6 +1566,9 @@ function stampSpan(span, projectId, authHint) {
 function stampContextAttributes(span) {
   try {
     applySpanAttributeFrames(span, (key, value) => span.setAttribute(key, value));
+    for (const [key, value] of Object.entries(evalScopeAttributes())) {
+      span.setAttribute(key, value);
+    }
   } catch (e) {
   }
 }
@@ -1311,6 +1576,7 @@ var RaindropContextSpanProcessor = class {
   onStart(span) {
     try {
       stampContextAttributes(span);
+      rememberReplayTraceDestination(span);
       const bound = currentRoutingBinding();
       if (!bound) return;
       stampSpan(span, bound.projectId, bound.authHint);
@@ -1371,7 +1637,7 @@ var GuardedSpanExporter = class {
     } catch (e) {
       if (foreignClientSeen()) {
         this.warnDropped(spans.length);
-        resultCallback({ code: EXPORT_FAILED });
+        resultCallback({ code: EXPORT_FAILED2 });
         return;
       }
       this.inner.export(spans, resultCallback);
@@ -1381,7 +1647,7 @@ var GuardedSpanExporter = class {
       this.warnDropped(dropped);
     }
     if (allowed.length === 0) {
-      resultCallback({ code: EXPORT_SUCCESS });
+      resultCallback({ code: EXPORT_SUCCESS2 });
       return;
     }
     this.inner.export(allowed, resultCallback);
@@ -1394,7 +1660,7 @@ var GuardedSpanExporter = class {
   }
 };
 function buildGuardedExporter(baseUrl, headers, ownerAuthHint) {
-  const inner = new OTLPProtoTraceExporter({
+  const inner = new OTLPProtoTraceExporter2({
     url: `${baseUrl}/v1/traces`,
     headers
   });
@@ -1404,23 +1670,23 @@ function pipelineOwnerHint() {
   return getState().ownerAuthHint;
 }
 function claimPipeline(authHint, projectId) {
-  const state = getState();
-  if (state.pipelineClaimed) {
+  const state2 = getState();
+  if (state2.pipelineClaimed) {
     return false;
   }
-  state.pipelineClaimed = true;
-  state.ownerAuthHint = authHint;
-  state.ownerProjectId = projectId;
-  if (state.foreignClientSeen && state.pendingMultiKeyWarning) {
+  state2.pipelineClaimed = true;
+  state2.ownerAuthHint = authHint;
+  state2.ownerProjectId = projectId;
+  if (state2.foreignClientSeen && state2.pendingMultiKeyWarning) {
     emitMultiKeyWarningOnce();
   }
   return true;
 }
 function releasePipelineClaim() {
-  const state = getState();
-  state.pipelineClaimed = false;
-  state.ownerAuthHint = void 0;
-  state.ownerProjectId = void 0;
+  const state2 = getState();
+  state2.pipelineClaimed = false;
+  state2.ownerAuthHint = void 0;
+  state2.ownerProjectId = void 0;
 }
 function markTraceloopConfiguredWithoutClaim() {
   getState().traceloopConfiguredWithoutClaim = true;
@@ -1436,9 +1702,9 @@ 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 { OpenAIInstrumentation } from "@traceloop/instrumentation-openai";
 import { PineconeInstrumentation } from "@traceloop/instrumentation-pinecone";
 import { QdrantInstrumentation } from "@traceloop/instrumentation-qdrant";
 import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
@@ -1446,920 +1712,954 @@ import {
   AIPlatformInstrumentation,
   VertexAIInstrumentation
 } from "@traceloop/instrumentation-vertexai";
+import { WeakValueMap } from "weakref";
 
-// 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];
+// src/tracing/direct/http.ts
+function wait2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-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 formatEndpoint2(endpoint) {
+  if (!endpoint) return void 0;
+  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
 }
-function safeStringify(value) {
-  try {
-    const result = JSON.stringify(value);
-    return result === void 0 ? String(value) : result;
-  } catch (e) {
-    return "[unserializable]";
+function parseRetryAfter2(headers) {
+  var _a;
+  const value = (_a = headers.get("Retry-After")) != null ? _a : headers.get("retry-after");
+  if (!value) return void 0;
+  const asNumber = Number(value);
+  if (!Number.isNaN(asNumber)) return asNumber * 1e3;
+  const asDate = new Date(value).getTime();
+  if (!Number.isNaN(asDate)) {
+    const delta = asDate - Date.now();
+    return delta > 0 ? delta : 0;
   }
+  return void 0;
 }
-function createResource(attributes) {
-  if ("resourceFromAttributes" in resourceModule) {
-    const factory = resourceModule.resourceFromAttributes;
-    if (typeof factory === "function") return factory(attributes);
+function getRetryDelayMs2(attemptNumber, previousError) {
+  if (previousError && typeof previousError === "object" && previousError !== null && "retryAfterMs" in previousError) {
+    const v = previousError.retryAfterMs;
+    if (typeof v === "number") return Math.min(Math.max(0, v), MAX_RETRY_DELAY_MS);
   }
-  return new resourceModule.Resource(attributes);
+  if (attemptNumber <= 1) return 0;
+  const base = 500;
+  const factor = Math.pow(2, attemptNumber - 2);
+  return Math.min(base * factor, MAX_RETRY_DELAY_MS);
 }
-function detectRuntimeResource() {
-  try {
-    if ("detectResourcesSync" in resourceModule && typeof resourceModule.detectResourcesSync === "function" && "envDetectorSync" in resourceModule) {
-      return resourceModule.detectResourcesSync({
-        detectors: [
-          resourceModule.envDetectorSync,
-          resourceModule.processDetectorSync,
-          resourceModule.hostDetectorSync
-        ]
-      });
+async function withRetry2(operation, opName, opts) {
+  let lastError = void 0;
+  for (let attemptNumber = 1; attemptNumber <= opts.maxAttempts; attemptNumber++) {
+    if (attemptNumber > 1) {
+      const delay = getRetryDelayMs2(attemptNumber, lastError);
+      if (opts.debug) {
+        console.warn(
+          `[raindrop] ${opName} retry ${attemptNumber}/${opts.maxAttempts} in ${delay}ms`
+        );
+      }
+      if (delay > 0) await wait2(delay);
+    } else if (opts.debug) {
+      console.log(`[raindrop] ${opName} attempt ${attemptNumber}/${opts.maxAttempts}`);
     }
-    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;
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      if (opts.debug) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(
+          `[raindrop] ${opName} attempt ${attemptNumber} failed: ${msg}${attemptNumber === opts.maxAttempts ? " (no more retries)" : ""}`
+        );
       }
+      if (attemptNumber === opts.maxAttempts) break;
     }
-  } 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;
   }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
-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;
-          }
-        });
+async function postJson2(url, body, headers, opts) {
+  var _a;
+  const opName = `POST ${redactUrlForLog(url)}`;
+  const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
+  await withRetry2(
+    async () => {
+      const resp = await runWithTracingSuppressed(
+        () => fetch(url, {
+          method: "POST",
+          redirect: headers["X-Raindrop-Replay-Id"] !== void 0 ? "error" : "follow",
+          headers: {
+            "Content-Type": "application/json",
+            ...headers
+          },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(timeoutMs)
+        })
+      );
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        const err = new Error(
+          `HTTP ${resp.status} ${resp.statusText}${text ? `: ${text}` : ""}`
+        );
+        const retryAfterMs = parseRetryAfter2(resp.headers);
+        if (typeof retryAfterMs === "number") err.retryAfterMs = retryAfterMs;
+        throw err;
       }
-      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];
+    },
+    opName,
+    opts
+  );
+}
+
+// src/tracing/direct/ids.ts
+function getCrypto2() {
+  const c = globalThis.crypto;
+  return c;
+}
+function randomBytes2(length) {
+  const cryptoObj = getCrypto2();
+  const out = new Uint8Array(length);
+  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+    cryptoObj.getRandomValues(out);
+    return out;
   }
-  if (AI_COMPLETION_TOKENS in attributes) {
-    attributes[SpanAttributes.LLM_USAGE_COMPLETION_TOKENS] = Number(attributes[AI_COMPLETION_TOKENS]);
-    delete attributes[AI_COMPLETION_TOKENS];
+  for (let i = 0; i < out.length; i++) out[i] = Math.floor(Math.random() * 256);
+  return out;
+}
+function base64Encode2(bytes) {
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(bytes).toString("base64");
   }
-  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);
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
   }
-  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];
+  const btoaFn = globalThis.btoa;
+  if (typeof btoaFn === "function") return btoaFn(binary);
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let out = "";
+  let i = 0;
+  while (i < binary.length) {
+    const c1 = binary.charCodeAt(i++) & 255;
+    const c2 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
+    const c3 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
+    const e1 = c1 >> 2;
+    const e2 = (c1 & 3) << 4 | (Number.isNaN(c2) ? 0 : c2 >> 4);
+    const e3 = Number.isNaN(c2) ? 64 : (c2 & 15) << 2 | (Number.isNaN(c3) ? 0 : c3 >> 6);
+    const e4 = Number.isNaN(c3) ? 64 : c3 & 63;
+    out += alphabet.charAt(e1);
+    out += alphabet.charAt(e2);
+    out += e3 === 64 ? "=" : alphabet.charAt(e3);
+    out += e4 === 64 ? "=" : alphabet.charAt(e4);
   }
-  Object.defineProperty(span, "name", {
-    configurable: true,
-    value: names[span.name],
-    writable: true
-  });
-  return span;
+  return out;
 }
-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;
+function base64ToHex2(base64) {
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(base64, "base64").toString("hex");
+  }
+  const atobFn = globalThis.atob;
+  if (typeof atobFn === "function") {
+    const binary = atobFn(base64);
+    let hex = "";
+    for (let i = 0; i < binary.length; i++) {
+      hex += binary.charCodeAt(i).toString(16).padStart(2, "0");
     }
+    return hex;
   }
-  return (_a = span.instrumentationLibrary) == null ? void 0 : _a.name;
+  throw new Error("No base64 decoder available in this runtime");
 }
-function contentCaptureDisabled(options) {
-  return options.traceContent === false || (process.env.TRACELOOP_TRACE_CONTENT || "true").toLowerCase() === "false";
+
+// src/tracing/direct/otlp.ts
+var libraryVersion = package_default.version;
+var SERVICE_NAME = "raindrop-ai";
+function attrString2(key, value) {
+  if (value === void 0) return void 0;
+  return { key, value: { stringValue: value } };
 }
-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 attrInt2(key, value) {
+  if (value === void 0) return void 0;
+  if (!Number.isFinite(value)) return void 0;
+  return { key, value: { intValue: String(Math.trunc(value)) } };
 }
-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 buildOtlpSpan2(args) {
+  const attrs = args.attributes.filter((x) => x !== void 0);
+  const span = {
+    traceId: args.ids.traceIdB64,
+    spanId: args.ids.spanIdB64,
+    name: args.name,
+    startTimeUnixNano: args.startTimeUnixNano,
+    endTimeUnixNano: args.endTimeUnixNano
+  };
+  if (args.ids.parentSpanIdB64) span.parentSpanId = args.ids.parentSpanIdB64;
+  if (attrs.length) span.attributes = attrs;
+  if (args.status) span.status = args.status;
+  return span;
+}
+function buildExportTraceServiceRequest2(spans) {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [{ key: "service.name", value: { stringValue: SERVICE_NAME } }]
+        },
+        scopeSpans: [
+          {
+            scope: { name: SERVICE_NAME, version: libraryVersion },
+            spans
+          }
+        ]
       }
-    }
+    ]
+  };
+}
+
+// src/tracing/direct/context.ts
+import { context, isValidSpanId, isValidTraceId, trace } from "@opentelemetry/api";
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+var INVALID_SPAN_ID = "0000000000000000";
+function hexToBase64(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
   }
+  return base64Encode2(bytes);
 }
-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) {
-    }
+function getExplicitTraceContext(traceId, parentSpanId) {
+  if (!traceId || !parentSpanId || !isValidTraceId(traceId) || !isValidSpanId(parentSpanId)) {
+    return void 0;
+  }
+  return {
+    traceIdB64: hexToBase64(traceId),
+    parentSpanIdB64: hexToBase64(parentSpanId)
   };
-  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 });
+function getActiveTraceContext() {
+  const activeSpan = trace.getSpan(context.active());
+  if (!activeSpan) return {};
+  const spanContext = activeSpan.spanContext();
+  const traceIdHex = spanContext.traceId;
+  const spanIdHex = spanContext.spanId;
+  if (traceIdHex === INVALID_TRACE_ID) return {};
+  return {
+    traceIdB64: hexToBase64(traceIdHex),
+    parentSpanIdB64: spanIdHex !== INVALID_SPAN_ID ? hexToBase64(spanIdHex) : void 0
+  };
 }
-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) {
-  }
+
+// src/tracing/direct/shipper.ts
+function serializeAssociationValue(value) {
+  return stringifyBounded(value);
 }
-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);
+var DirectTraceShipper = class {
+  constructor(opts) {
+    this.queue = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    /**
+     * Set once `shutdown()` begins and never cleared. Sends issued after the
+     * drain window (stragglers, or flush work the deadline abandoned
+     * mid-drain) run as a single short attempt instead of regaining the full
+     * retry schedule.
+     */
+    this.hasShutdown = false;
+    var _a, _b, _c, _d, _e, _f;
+    this.writeKey = opts.writeKey;
+    this.baseUrl = (_a = formatEndpoint2(opts.endpoint)) != null ? _a : "https://api.raindrop.ai/v1/";
+    this.enabled = (_b = opts.enabled) != null ? _b : true;
+    this.cloudEnabled = (_c = opts.cloudEnabled) != null ? _c : true;
+    this.debug = opts.debug;
+    this.projectId = opts.projectId;
+    this.flushIntervalMs = (_d = opts.flushIntervalMs) != null ? _d : 1e3;
+    this.maxBatchSize = (_e = opts.maxBatchSize) != null ? _e : 50;
+    this.maxQueueSize = (_f = opts.maxQueueSize) != null ? _f : 5e3;
+    const resolved = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl);
+    if (resolved && resolved !== this.baseUrl) {
+      this.localDebuggerUrl = resolved;
+    }
   }
-  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) {
+  /**
+   * Build and enqueue an OTLP span for a trackTool call.
+   *
+   * Reads the active OTEL context if traceId/parentSpanId are not provided,
+   * so spans still appear as children in the trace tree.
+   */
+  sendSpan(params) {
+    var _a, _b, _c;
+    if (!this.enabled) return;
+    let traceIdB64 = params.traceId;
+    let parentSpanIdB64 = params.parentSpanId;
+    if (!traceIdB64) {
+      const activeCtx = getActiveTraceContext();
+      traceIdB64 = activeCtx.traceIdB64;
+      parentSpanIdB64 = activeCtx.parentSpanIdB64;
     }
-    let result;
-    try {
-      callbackStarted = true;
-      result = fn(...args);
-    } catch (error) {
-      try {
-        span.end();
-      } catch (e) {
-      }
-      throw error;
+    const spanIdB64 = (_a = params.spanId) != null ? _a : base64Encode2(randomBytes2(8));
+    if (!traceIdB64) {
+      traceIdB64 = base64Encode2(randomBytes2(16));
     }
-    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;
-        }
+    const startTimeUnixNano = String(params.startTimeMs * 1e6);
+    const endTimeUnixNano = String(params.endTimeMs * 1e6);
+    const attributes = [
+      // Required: passes hasAIOperation() filter in backend (parseSpan.ts)
+      attrString2("traceloop.span.kind", (_b = params.spanKind) != null ? _b : "tool"),
+      // Parsed by backend for input/output payloads
+      attrString2("traceloop.entity.input", params.input),
+      attrString2("traceloop.entity.output", params.output),
+      // Duration tracking
+      attrInt2("traceloop.entity.duration_ms", params.durationMs),
+      // Per-span project routing: the ingest boundary routes on this attribute
+      // (org-validated) and falls back to the request's project header. Direct
+      // spans ship on this instance's own key, so no cross-key auth hint.
+      attrString2(PROJECT_ID_SPAN_ATTRIBUTE, this.projectId)
+    ];
+    for (const [key, value] of Object.entries(params.properties)) {
+      if (value === void 0) {
+        continue;
+      }
+      attributes.push(
+        attrString2(`traceloop.association.properties.${key}`, serializeAssociationValue(value))
       );
     }
-    try {
-      if (shouldSendTraceContent()) span.setAttribute(SpanAttributes.TRACELOOP_ENTITY_OUTPUT, safeStringify(result));
-      span.end();
-    } catch (e) {
+    const spanIdentity = { spanIdB64 };
+    claimSpanForFrames(spanIdentity);
+    for (const [key, value] of Object.entries({
+      ...currentSpanAttributes(),
+      ...params.attributes,
+      // Last, so neither a bound frame nor an explicit caller attribute can
+      // shadow the replay row a span belongs to.
+      ...evalScopeAttributes()
+    })) {
+      attributes.push(attrString2(key, value));
     }
-    return result;
-  };
-  try {
-    const tracer = trace.getTracer(TRACER_NAME);
-    return context.with(
-      entityContext,
-      () => tracer.startActiveSpan(`${config.name}.${type}`, {}, entityContext, run)
+    attributes.push(...(_c = params.otlpAttributes) != null ? _c : []);
+    let status;
+    if (params.error) {
+      status = { code: 2, message: params.error };
+      markErrorSpanSeen(spanIdentity);
+    } else {
+      status = {
+        code: 1
+        /* STATUS_CODE_OK */
+      };
+    }
+    const span = buildOtlpSpan2({
+      ids: {
+        traceIdB64,
+        spanIdB64,
+        parentSpanIdB64
+      },
+      name: params.name,
+      startTimeUnixNano,
+      endTimeUnixNano,
+      attributes,
+      status
+    });
+    const replayDestination = currentReplayTraceDestination();
+    recordReplayExportedSpan(
+      replayDestination,
+      base64ToHex2(span.spanId),
+      base64ToHex2(span.traceId)
     );
-  } catch (error) {
-    if (callbackStarted) throw error;
-    return fn(...args);
+    const mirrorUrl = (replayDestination == null ? void 0 : replayDestination.kind) === "workshop" ? replayDestination.url : replayDestination ? void 0 : this.localDebuggerUrl;
+    if (mirrorUrl) {
+      const body = buildExportTraceServiceRequest2([span]);
+      const mirror = mirrorTraceExportToLocalDebugger(body, {
+        baseUrl: mirrorUrl,
+        debug: false,
+        sdkName: "js-sdk"
+      });
+      this.inFlight.add(mirror);
+      void mirror.finally(() => this.inFlight.delete(mirror));
+    }
+    this.enqueue({ span, replayDestination });
+    if (this.debug) {
+      console.log(`[raindrop] direct shipper: enqueued span "${params.name}"`);
+    }
   }
-}
-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
-function wait2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function formatEndpoint2(endpoint) {
-  if (!endpoint) return void 0;
-  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
-}
-function parseRetryAfter2(headers) {
-  var _a;
-  const value = (_a = headers.get("Retry-After")) != null ? _a : headers.get("retry-after");
-  if (!value) return void 0;
-  const asNumber = Number(value);
-  if (!Number.isNaN(asNumber)) return asNumber * 1e3;
-  const asDate = new Date(value).getTime();
-  if (!Number.isNaN(asDate)) {
-    const delta = asDate - Date.now();
-    return delta > 0 ? delta : 0;
+  sendToolSpan(params) {
+    this.sendSpan({
+      ...params,
+      spanKind: "tool"
+    });
   }
-  return void 0;
-}
-function getRetryDelayMs2(attemptNumber, previousError) {
-  if (previousError && typeof previousError === "object" && previousError !== null && "retryAfterMs" in previousError) {
-    const v = previousError.retryAfterMs;
-    if (typeof v === "number") return Math.min(Math.max(0, v), MAX_RETRY_DELAY_MS);
+  enqueue(queued) {
+    if (!this.enabled) return;
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+    }
+    this.queue.push(queued);
+    if (this.queue.length >= this.maxBatchSize) {
+      void this.flush().catch(() => {
+      });
+      return;
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = void 0;
+        void this.flush().catch(() => {
+        });
+      }, this.flushIntervalMs);
+    }
   }
-  if (attemptNumber <= 1) return 0;
-  const base = 500;
-  const factor = Math.pow(2, attemptNumber - 2);
-  return Math.min(base * factor, MAX_RETRY_DELAY_MS);
-}
-async function withRetry2(operation, opName, opts) {
-  let lastError = void 0;
-  for (let attemptNumber = 1; attemptNumber <= opts.maxAttempts; attemptNumber++) {
-    if (attemptNumber > 1) {
-      const delay = getRetryDelayMs2(attemptNumber, lastError);
-      if (opts.debug) {
-        console.warn(
-          `[raindrop] ${opName} retry ${attemptNumber}/${opts.maxAttempts} in ${delay}ms`
+  async flush() {
+    var _a;
+    if (!this.enabled) return;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    while (this.queue.length > 0) {
+      const batch = this.queue.splice(0, this.maxBatchSize);
+      const opts = this.requestOpts();
+      if (!opts) {
+        rateLimitedLog(
+          "js-sdk.direct.shutdown_deadline",
+          () => console.warn(
+            `[raindrop] direct: shutdown flush deadline exceeded; dropping ${batch.length} spans`
+          )
         );
+        continue;
       }
-      if (delay > 0) await wait2(delay);
-    } else if (opts.debug) {
-      console.log(`[raindrop] ${opName} attempt ${attemptNumber}/${opts.maxAttempts}`);
+      const groups = /* @__PURE__ */ new Map();
+      for (const queued of batch) {
+        const spans = groups.get(queued.replayDestination);
+        if (spans) spans.push(queued.span);
+        else groups.set(queued.replayDestination, [queued.span]);
+      }
+      for (const [replayDestination, spans] of groups) {
+        if (!replayDestination && !this.cloudEnabled) continue;
+        if ((replayDestination == null ? void 0 : replayDestination.kind) === "workshop") continue;
+        const body = buildExportTraceServiceRequest2(spans);
+        const url = replayDestination ? replayTraceUrl(replayDestination.url) : `${this.baseUrl}traces`;
+        const headers = replayDestination ? {
+          Authorization: `Bearer ${replayDestination.apiKey}`,
+          "X-Raindrop-Replay-Id": replayDestination.replayId,
+          "X-Raindrop-Project-Id": (_a = replayDestination.projectId) != null ? _a : "default"
+        } : { Authorization: `Bearer ${this.writeKey}`, ...projectIdHeaders(this.projectId) };
+        const p = postJson2(url, body, headers, opts);
+        this.inFlight.add(p);
+        try {
+          try {
+            await p;
+            if (this.debug) console.log(`[raindrop] direct: sent ${spans.length} spans`);
+          } catch (err) {
+            if (this.debug) {
+              const msg = err instanceof Error ? err.message : String(err);
+              console.warn(`[raindrop] direct: failed to send spans (dropping): ${msg}`);
+            }
+          }
+        } finally {
+          this.inFlight.delete(p);
+        }
+      }
+    }
+  }
+  /**
+   * Retry/timeout options for one batch POST, honoring the shutdown budget:
+   * outside shutdown, the normal 3-attempt schedule; during shutdown, a
+   * single attempt clamped to the remaining window; `null` once the window
+   * is exhausted (caller drops the batch). After shutdown() returns,
+   * stragglers run as a single short attempt.
+   */
+  requestOpts() {
+    if (this.shutdownDeadlineAt !== void 0) {
+      const remainingMs = this.shutdownDeadlineAt - Date.now();
+      if (remainingMs <= 0) return null;
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
+      };
     }
+    if (this.hasShutdown) {
+      return { maxAttempts: 1, debug: this.debug, timeoutMs: POST_SHUTDOWN_TIMEOUT_MS };
+    }
+    return { maxAttempts: 3, debug: this.debug };
+  }
+  async shutdown() {
+    this.hasShutdown = true;
+    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
     try {
-      return await operation();
-    } catch (err) {
-      lastError = err;
-      if (opts.debug) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.warn(
-          `[raindrop] ${opName} attempt ${attemptNumber} failed: ${msg}${attemptNumber === opts.maxAttempts ? " (no more retries)" : ""}`
-        );
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = void 0;
       }
-      if (attemptNumber === opts.maxAttempts) break;
+      const drain = async () => {
+        await this.flush();
+        await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+        })));
+      };
+      const settled = await raceWithTimeout(drain(), SHUTDOWN_DEADLINE_MS);
+      if (!settled && this.debug) {
+        console.warn("[raindrop] direct: shutdown deadline exceeded; abandoning in-flight spans");
+      }
+    } finally {
+      this.shutdownDeadlineAt = void 0;
     }
   }
-  throw lastError instanceof Error ? lastError : new Error(String(lastError));
-}
-async function postJson2(url, body, headers, opts) {
-  var _a;
-  const opName = `POST ${redactUrlForLog(url)}`;
-  const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
-  await withRetry2(
-    async () => {
-      const resp = await runWithTracingSuppressed(
-        () => fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            ...headers
-          },
-          body: JSON.stringify(body),
-          signal: AbortSignal.timeout(timeoutMs)
-        })
-      );
-      if (!resp.ok) {
-        const text = await resp.text().catch(() => "");
-        const err = new Error(
-          `HTTP ${resp.status} ${resp.statusText}${text ? `: ${text}` : ""}`
-        );
-        const retryAfterMs = parseRetryAfter2(resp.headers);
-        if (typeof retryAfterMs === "number") err.retryAfterMs = retryAfterMs;
-        throw err;
-      }
-    },
-    opName,
-    opts
-  );
-}
+};
 
-// src/tracing/direct/ids.ts
-function getCrypto2() {
-  const c = globalThis.crypto;
-  return c;
-}
-function randomBytes2(length) {
-  const cryptoObj = getCrypto2();
-  const out = new Uint8Array(length);
-  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
-    cryptoObj.getRandomValues(out);
-    return out;
-  }
-  for (let i = 0; i < out.length; i++) out[i] = Math.floor(Math.random() * 256);
-  return out;
-}
-function base64Encode2(bytes) {
-  const maybeBuffer = globalThis.Buffer;
-  if (maybeBuffer) {
-    return maybeBuffer.from(bytes).toString("base64");
-  }
-  let binary = "";
-  for (let i2 = 0; i2 < bytes.length; i2++) {
-    binary += String.fromCharCode(bytes[i2]);
-  }
-  const btoaFn = globalThis.btoa;
-  if (typeof btoaFn === "function") return btoaFn(binary);
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  let out = "";
-  let i = 0;
-  while (i < binary.length) {
-    const c1 = binary.charCodeAt(i++) & 255;
-    const c2 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
-    const c3 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
-    const e1 = c1 >> 2;
-    const e2 = (c1 & 3) << 4 | (Number.isNaN(c2) ? 0 : c2 >> 4);
-    const e3 = Number.isNaN(c2) ? 64 : (c2 & 15) << 2 | (Number.isNaN(c3) ? 0 : c3 >> 6);
-    const e4 = Number.isNaN(c3) ? 64 : c3 & 63;
-    out += alphabet.charAt(e1);
-    out += alphabet.charAt(e2);
-    out += e3 === 64 ? "=" : alphabet.charAt(e3);
-    out += e4 === 64 ? "=" : alphabet.charAt(e4);
-  }
-  return out;
+// src/tracing/otel-core/index.ts
+import {
+  DiagConsoleLogger,
+  DiagLogLevel,
+  context as context2,
+  diag,
+  trace as trace2
+} 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_KEY3 = /* @__PURE__ */ Symbol.for("raindrop.otelCore.state");
+function getState2() {
+  var _a;
+  const holder = globalThis;
+  (_a = holder[STATE_KEY3]) != null ? _a : holder[STATE_KEY3] = {};
+  return holder[STATE_KEY3];
 }
-function base64ToHex2(base64) {
-  const maybeBuffer = globalThis.Buffer;
-  if (maybeBuffer) {
-    return maybeBuffer.from(base64, "base64").toString("hex");
-  }
-  const atobFn = globalThis.atob;
-  if (typeof atobFn === "function") {
-    const binary = atobFn(base64);
-    let hex = "";
-    for (let i = 0; i < binary.length; i++) {
-      hex += binary.charCodeAt(i).toString(16).padStart(2, "0");
+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 hex;
   }
-  throw new Error("No base64 decoder available in this runtime");
-}
-
-// src/tracing/direct/otlp.ts
-var libraryVersion = package_default.version;
-var SERVICE_NAME = "raindrop-ai";
-function attrString2(key, value) {
-  if (value === void 0) return void 0;
-  return { key, value: { stringValue: value } };
+  return headers;
 }
-function attrInt2(key, value) {
-  if (value === void 0) return void 0;
-  if (!Number.isFinite(value)) return void 0;
-  return { key, value: { intValue: String(Math.trunc(value)) } };
+function safeStringify(value) {
+  try {
+    const result = JSON.stringify(value);
+    return result === void 0 ? String(value) : result;
+  } catch (e) {
+    return "[unserializable]";
+  }
 }
-function buildOtlpSpan2(args) {
-  const attrs = args.attributes.filter((x) => x !== void 0);
-  const span = {
-    traceId: args.ids.traceIdB64,
-    spanId: args.ids.spanIdB64,
-    name: args.name,
-    startTimeUnixNano: args.startTimeUnixNano,
-    endTimeUnixNano: args.endTimeUnixNano
-  };
-  if (args.ids.parentSpanIdB64) span.parentSpanId = args.ids.parentSpanIdB64;
-  if (attrs.length) span.attributes = attrs;
-  if (args.status) span.status = args.status;
-  return span;
+function createResource(attributes) {
+  if ("resourceFromAttributes" in resourceModule) {
+    const factory = resourceModule.resourceFromAttributes;
+    if (typeof factory === "function") return factory(attributes);
+  }
+  return new resourceModule.Resource(attributes);
 }
-function buildExportTraceServiceRequest2(spans) {
-  return {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: [{ key: "service.name", value: { stringValue: SERVICE_NAME } }]
-        },
-        scopeSpans: [
-          {
-            scope: { name: SERVICE_NAME, version: libraryVersion },
-            spans
-          }
+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;
       }
-    ]
-  };
-}
-
-// src/tracing/direct/context.ts
-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) {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+  } catch (e) {
   }
-  return base64Encode2(bytes);
+  return void 0;
 }
-function getExplicitTraceContext(traceId, parentSpanId) {
-  if (!traceId || !parentSpanId || !isValidTraceId(traceId) || !isValidSpanId(parentSpanId)) {
-    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;
   }
-  return {
-    traceIdB64: hexToBase64(traceId),
-    parentSpanIdB64: hexToBase64(parentSpanId)
-  };
 }
-function getActiveTraceContext() {
-  const activeSpan = trace2.getSpan(context2.active());
-  if (!activeSpan) return {};
-  const spanContext = activeSpan.spanContext();
-  const traceIdHex = spanContext.traceId;
-  const spanIdHex = spanContext.spanId;
-  if (traceIdHex === INVALID_TRACE_ID) return {};
-  return {
-    traceIdB64: hexToBase64(traceIdHex),
-    parentSpanIdB64: spanIdHex !== INVALID_SPAN_ID ? hexToBase64(spanIdHex) : void 0
+function transformAiSdkSpan(span) {
+  const names = {
+    [AI_GENERATE_TEXT]: "ai.generateText.generate",
+    [AI_STREAM_TEXT]: "ai.streamText.stream"
   };
-}
-
-// src/tracing/direct/shipper.ts
-function serializeAssociationValue(value) {
-  return stringifyBounded(value);
-}
-var DirectTraceShipper = class {
-  constructor(opts) {
-    this.queue = [];
-    this.inFlight = /* @__PURE__ */ new Set();
-    /**
-     * Set once `shutdown()` begins and never cleared. Sends issued after the
-     * drain window (stragglers, or flush work the deadline abandoned
-     * mid-drain) run as a single short attempt instead of regaining the full
-     * retry schedule.
-     */
-    this.hasShutdown = false;
-    var _a, _b, _c, _d, _e, _f;
-    this.writeKey = opts.writeKey;
-    this.baseUrl = (_a = formatEndpoint2(opts.endpoint)) != null ? _a : "https://api.raindrop.ai/v1/";
-    this.enabled = (_b = opts.enabled) != null ? _b : true;
-    this.cloudEnabled = (_c = opts.cloudEnabled) != null ? _c : true;
-    this.debug = opts.debug;
-    this.projectId = opts.projectId;
-    this.flushIntervalMs = (_d = opts.flushIntervalMs) != null ? _d : 1e3;
-    this.maxBatchSize = (_e = opts.maxBatchSize) != null ? _e : 50;
-    this.maxQueueSize = (_f = opts.maxQueueSize) != null ? _f : 5e3;
-    const resolved = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl);
-    if (resolved && resolved !== this.baseUrl) {
-      this.localDebuggerUrl = resolved;
+  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];
   }
-  /**
-   * Build and enqueue an OTLP span for a trackTool call.
-   *
-   * Reads the active OTEL context if traceId/parentSpanId are not provided,
-   * so spans still appear as children in the trace tree.
-   */
-  sendSpan(params) {
-    var _a, _b, _c;
-    if (!this.enabled) return;
-    let traceIdB64 = params.traceId;
-    let parentSpanIdB64 = params.parentSpanId;
-    if (!traceIdB64) {
-      const activeCtx = getActiveTraceContext();
-      traceIdB64 = activeCtx.traceIdB64;
-      parentSpanIdB64 = activeCtx.parentSpanIdB64;
-    }
-    const spanIdB64 = (_a = params.spanId) != null ? _a : base64Encode2(randomBytes2(8));
-    if (!traceIdB64) {
-      traceIdB64 = base64Encode2(randomBytes2(16));
-    }
-    const startTimeUnixNano = String(params.startTimeMs * 1e6);
-    const endTimeUnixNano = String(params.endTimeMs * 1e6);
-    const attributes = [
-      // Required: passes hasAIOperation() filter in backend (parseSpan.ts)
-      attrString2("traceloop.span.kind", (_b = params.spanKind) != null ? _b : "tool"),
-      // Parsed by backend for input/output payloads
-      attrString2("traceloop.entity.input", params.input),
-      attrString2("traceloop.entity.output", params.output),
-      // Duration tracking
-      attrInt2("traceloop.entity.duration_ms", params.durationMs),
-      // Per-span project routing: the ingest boundary routes on this attribute
-      // (org-validated) and falls back to the request's project header. Direct
-      // spans ship on this instance's own key, so no cross-key auth hint.
-      attrString2(PROJECT_ID_SPAN_ATTRIBUTE, this.projectId)
-    ];
-    for (const [key, value] of Object.entries(params.properties)) {
-      if (value === void 0) {
-        continue;
+  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;
+          }
+        });
       }
-      attributes.push(
-        attrString2(`traceloop.association.properties.${key}`, serializeAssociationValue(value))
-      );
-    }
-    const spanIdentity = { spanIdB64 };
-    claimSpanForFrames(spanIdentity);
-    for (const [key, value] of Object.entries({
-      ...currentSpanAttributes(),
-      ...params.attributes
-    })) {
-      attributes.push(attrString2(key, value));
-    }
-    attributes.push(...(_c = params.otlpAttributes) != null ? _c : []);
-    let status;
-    if (params.error) {
-      status = { code: 2, message: params.error };
-      markErrorSpanSeen(spanIdentity);
-    } else {
-      status = {
-        code: 1
-        /* STATUS_CODE_OK */
-      };
+      delete attributes[AI_PROMPT_MESSAGES];
+    } catch (e) {
     }
-    const span = buildOtlpSpan2({
-      ids: {
-        traceIdB64,
-        spanIdB64,
-        parentSpanIdB64
-      },
-      name: params.name,
-      startTimeUnixNano,
-      endTimeUnixNano,
-      attributes,
-      status
-    });
-    if (this.localDebuggerUrl) {
-      const body = buildExportTraceServiceRequest2([span]);
-      mirrorTraceExportToLocalDebugger(body, {
-        baseUrl: this.localDebuggerUrl,
-        debug: false,
-        sdkName: "js-sdk"
-      });
+  }
+  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;
     }
-    this.enqueue(span);
-    if (this.debug) {
-      console.log(`[raindrop] direct shipper: enqueued span "${params.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 = context2.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 = context2.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);
+      }
     }
   }
-  sendToolSpan(params) {
-    this.sendSpan({
-      ...params,
-      spanKind: "tool"
-    });
-  }
-  enqueue(span) {
-    if (!this.enabled) return;
-    if (this.queue.length >= this.maxQueueSize) {
-      this.queue.shift();
+}
+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 baseExporter = (_b = options.exporter) != null ? _b : new OTLPTraceExporter({ url: `${baseUrl}/v1/traces`, headers: resolvedHeaders });
+  const exporter = options.routeReplayTraces ? new ReplayRoutingSpanExporter(baseExporter) : baseExporter;
+  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) {
     }
-    this.queue.push(span);
-    if (this.queue.length >= this.maxBatchSize) {
-      void this.flush().catch(() => {
-      });
-      return;
+  };
+  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);
+      if (outgoing !== span) copyReplayTraceDestination(span, outgoing);
+    } catch (e) {
     }
-    if (!this.timer) {
-      this.timer = setTimeout(() => {
-        this.timer = void 0;
-        void this.flush().catch(() => {
-        });
-      }, this.flushIntervalMs);
+    try {
+      originalOnEnd(outgoing);
+    } catch (e) {
     }
-  }
-  async flush() {
-    if (!this.enabled) return;
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = void 0;
+  };
+  return processor;
+}
+function initialize(options = {}) {
+  var _a;
+  const state2 = getState2();
+  if (state2.configuration) return;
+  state2.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";
+  state2.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();
+  state2.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: [state2.defaultProcessor, ...options.processor ? [options.processor] : []]
+  });
+  state2.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) {
+      }
     }
-    while (this.queue.length > 0) {
-      const batch = this.queue.splice(0, this.maxBatchSize);
-      if (!this.cloudEnabled) {
-        if (this.debug) console.log(`[raindrop] direct: dropped ${batch.length} cloud spans (local-only)`);
-        continue;
+  }
+  registerInstrumentations({ instrumentations });
+}
+async function forceFlush() {
+  var _a, _b;
+  const state2 = getState2();
+  try {
+    await ((_a = state2.provider) == null ? void 0 : _a.forceFlush());
+    await ((_b = state2.defaultProcessor) == null ? void 0 : _b.forceFlush());
+  } catch (e) {
+  }
+}
+function withEntity(type, config, fn, args) {
+  let entityContext = context2.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);
       }
-      const opts = this.requestOpts();
-      if (!opts) {
-        rateLimitedLog(
-          "js-sdk.direct.shutdown_deadline",
-          () => console.warn(
-            `[raindrop] direct: shutdown flush deadline exceeded; dropping ${batch.length} spans`
+      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: {} }
           )
         );
-        continue;
       }
-      const body = buildExportTraceServiceRequest2(batch);
-      const url = `${this.baseUrl}traces`;
-      const p = postJson2(
-        url,
-        body,
-        { Authorization: `Bearer ${this.writeKey}`, ...projectIdHeaders(this.projectId) },
-        opts
-      );
-      this.inFlight.add(p);
+    } catch (e) {
+    }
+    let result;
+    try {
+      callbackStarted = true;
+      result = fn(...args);
+    } catch (error) {
       try {
-        try {
-          await p;
-          if (this.debug) console.log(`[raindrop] direct: sent ${batch.length} spans`);
-        } catch (err) {
-          if (this.debug) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[raindrop] direct: failed to send spans (dropping): ${msg}`);
-          }
-        }
-      } finally {
-        this.inFlight.delete(p);
+        span.end();
+      } catch (e) {
       }
+      throw error;
     }
-  }
-  /**
-   * Retry/timeout options for one batch POST, honoring the shutdown budget:
-   * outside shutdown, the normal 3-attempt schedule; during shutdown, a
-   * single attempt clamped to the remaining window; `null` once the window
-   * is exhausted (caller drops the batch). After shutdown() returns,
-   * stragglers run as a single short attempt.
-   */
-  requestOpts() {
-    if (this.shutdownDeadlineAt !== void 0) {
-      const remainingMs = this.shutdownDeadlineAt - Date.now();
-      if (remainingMs <= 0) return null;
-      return {
-        maxAttempts: 1,
-        debug: this.debug,
-        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
-      };
-    }
-    if (this.hasShutdown) {
-      return { maxAttempts: 1, debug: this.debug, timeoutMs: POST_SHUTDOWN_TIMEOUT_MS };
+    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;
+        }
+      );
     }
-    return { maxAttempts: 3, debug: this.debug };
-  }
-  async shutdown() {
-    this.hasShutdown = true;
-    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
     try {
-      if (this.timer) {
-        clearTimeout(this.timer);
-        this.timer = void 0;
-      }
-      const drain = async () => {
-        await this.flush();
-        await Promise.all([...this.inFlight].map((p) => p.catch(() => {
-        })));
-      };
-      const settled = await raceWithTimeout(drain(), SHUTDOWN_DEADLINE_MS);
-      if (!settled && this.debug) {
-        console.warn("[raindrop] direct: shutdown deadline exceeded; abandoning in-flight spans");
-      }
-    } finally {
-      this.shutdownDeadlineAt = void 0;
+      if (shouldSendTraceContent())
+        span.setAttribute(SpanAttributes.TRACELOOP_ENTITY_OUTPUT, safeStringify(result));
+      span.end();
+    } catch (e) {
     }
+    return result;
+  };
+  try {
+    const tracer = trace2.getTracer(TRACER_NAME);
+    return context2.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/exit-flush.ts
-var STATE_KEY3 = /* @__PURE__ */ Symbol.for("raindrop.tracing.exitFlushState");
+var STATE_KEY4 = /* @__PURE__ */ Symbol.for("raindrop.tracing.exitFlushState");
 function getState3() {
   const holder = globalThis;
-  let state = holder[STATE_KEY3];
-  if (!state) {
-    state = {
+  let state2 = holder[STATE_KEY4];
+  if (!state2) {
+    state2 = {
       clientFlushers: /* @__PURE__ */ new Set(),
       pipelineFlushNeeded: false,
       handlerRegistered: false
     };
-    holder[STATE_KEY3] = state;
+    holder[STATE_KEY4] = state2;
   }
-  return state;
+  return state2;
 }
-function ensureExitHandler(state) {
-  if (state.handlerRegistered) return;
+function ensureExitHandler(state2) {
+  if (state2.handlerRegistered) return;
   if (typeof process === "undefined" || typeof process.once !== "function") return;
-  state.handlerRegistered = true;
+  state2.handlerRegistered = true;
   process.once("beforeExit", () => {
     void flushAll();
   });
 }
 function registerClientFlusher(flush) {
-  const state = getState3();
-  state.clientFlushers.add(flush);
-  ensureExitHandler(state);
+  const state2 = getState3();
+  state2.clientFlushers.add(flush);
+  ensureExitHandler(state2);
   return () => {
-    state.clientFlushers.delete(flush);
+    state2.clientFlushers.delete(flush);
   };
 }
 function markPipelineForExitFlush() {
-  const state = getState3();
-  state.pipelineFlushNeeded = true;
-  ensureExitHandler(state);
+  const state2 = getState3();
+  state2.pipelineFlushNeeded = true;
+  ensureExitHandler(state2);
 }
 async function flushAll() {
-  const state = getState3();
+  const state2 = getState3();
   const tasks = [];
-  for (const flush of state.clientFlushers) {
+  for (const flush of state2.clientFlushers) {
     tasks.push(Promise.resolve().then(flush).catch(() => {
     }));
   }
-  if (state.pipelineFlushNeeded) {
+  if (state2.pipelineFlushNeeded) {
     tasks.push(
       Promise.resolve().then(() => forceFlush()).catch(() => {
       })
@@ -3708,6 +4008,14 @@ if (localDebuggerEnabled()) {
     process.env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL = "http/json";
   }
 }
+var DropSpanExporter = class {
+  export(_spans, resultCallback) {
+    resultCallback({ code: 0 });
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
 var CompositeSpanProcessor = class {
   constructor(requiredProcessors, bestEffortProcessors) {
     this.requiredProcessors = requiredProcessors;
@@ -3839,10 +4147,24 @@ function createLocalDebuggerSpanProcessor(options) {
     url: `${localDebuggerUrl}traces`,
     headers: {}
   });
+  if (!options.routeReplayTraces) {
+    const exportLocal = localExporter.export.bind(localExporter);
+    localExporter.export = (spans, callback) => {
+      const localSpans = spans.filter(
+        (span) => {
+          var _a;
+          return ((_a = replayTraceDestinationFor(span)) == null ? void 0 : _a.kind) !== "raindrop";
+        }
+      );
+      if (localSpans.length === 0) callback({ code: 0 });
+      else exportLocal(localSpans, callback);
+    };
+  }
   try {
     return createSpanProcessor({
       apiKey: options.writeKey,
       baseUrl: localDebuggerUrl,
+      routeReplayTraces: options.routeReplayTraces,
       disableBatch: options.disableBatching,
       exporter: localExporter,
       headers: {},
@@ -4256,7 +4578,8 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
         writeKey,
         disableBatching,
         allowedInstrumentationLibraries: ALL_INSTRUMENTATION_LIBRARIES,
-        localDebuggerUrlOpt: localDebuggerUrl
+        localDebuggerUrlOpt: localDebuggerUrl,
+        routeReplayTraces: !cloudEnabledResolved
       });
       if (!cloudEnabledResolved) {
         if (localDebuggerProcessor) {
@@ -4264,22 +4587,40 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
             baseUrl: apiUrl,
             apiKey: writeKey,
             ...otherOptions,
+            exporter: new DropSpanExporter(),
             logLevel: logLevel2,
             silenceInitializationMessage: true,
             tracingEnabled: tracingEnabled !== false,
             disableBatch: disableBatching,
-            processor: localDebuggerProcessor,
+            processor: new CompositeSpanProcessor(
+              [new RaindropContextSpanProcessor(), localDebuggerProcessor],
+              []
+            ),
             instrumentations: createConfiguredInstrumentations(otherOptions)
           });
           traceloopInitialized = true;
           markTraceloopConfiguredWithoutClaim();
         } else {
+          const replayOnlyProcessor = createSpanProcessor({
+            exporter: new DropSpanExporter(),
+            routeReplayTraces: true,
+            disableBatch: disableBatching,
+            allowedInstrumentationLibraries: ALL_INSTRUMENTATION_LIBRARIES
+          });
           initialize({
             baseUrl: apiUrl,
             apiKey: writeKey,
+            ...otherOptions,
+            exporter: new DropSpanExporter(),
             logLevel: logLevel2,
             silenceInitializationMessage: true,
-            tracingEnabled: false
+            tracingEnabled: tracingEnabled !== false,
+            disableBatch: disableBatching,
+            processor: new CompositeSpanProcessor(
+              [new RaindropContextSpanProcessor(), replayOnlyProcessor],
+              []
+            ),
+            instrumentations: createConfiguredInstrumentations(otherOptions)
           });
           traceloopInitialized = true;
           markTraceloopConfiguredWithoutClaim();
@@ -4307,7 +4648,8 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
           let guardedExporter;
           try {
             const callerExporter = otherOptions.exporter;
-            guardedExporter = callerExporter ? new GuardedSpanExporter(callerExporter, ownerHint) : buildGuardedExporter(apiUrl, exporterHeaders, ownerHint);
+            const guarded = callerExporter ? new GuardedSpanExporter(callerExporter, ownerHint) : buildGuardedExporter(apiUrl, exporterHeaders, ownerHint);
+            guardedExporter = new ReplayRoutingSpanExporter(guarded);
           } catch (guardError) {
             releasePipelineClaim();
             claimedPipeline = false;
@@ -4558,7 +4900,8 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
           writeKey,
           disableBatching,
           allowedInstrumentationLibraries: processorOptions == null ? void 0 : processorOptions.allowedInstrumentationLibraries,
-          localDebuggerUrlOpt: localDebuggerUrl
+          localDebuggerUrlOpt: localDebuggerUrl,
+          routeReplayTraces: true
         });
         return withV2SpanCompat(
           localOnlyProcessor != null ? localOnlyProcessor : {
@@ -4579,6 +4922,7 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
         apiKey: writeKey,
         disableBatch: disableBatching,
         ...processorOptions != null ? processorOptions : {},
+        routeReplayTraces: true,
         ...headers ? { headers } : {}
       });
       const localDebuggerProcessor = createLocalDebuggerSpanProcessor({
@@ -4661,7 +5005,12 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
 };
 
 export {
+  EVAL_CORRELATION_ID_ATTRIBUTE,
+  withEvalScope,
+  currentEvalScope,
+  evalScopeAttributes,
   normalizeFeatureFlags,
+  randomUUID,
   runWithTracingSuppressed,
   DEFAULT_REQUEST_TIMEOUT_MS,
   MAX_RETRY_DELAY_MS,
@@ -4671,7 +5020,10 @@ export {
   setDefaultMaxTextFieldChars,
   resolveMaxTextFieldChars,
   capText,
+  boundedClone,
   stringifyBounded,
+  withReplayTraceDestination,
+  currentReplayTraceDestination,
   resolveLocalDebuggerBaseUrl,
   localDebuggerEnabled,
   mirrorPartialEventToLocalDebugger,
@@ -4682,5 +5034,6 @@ export {
   withRoutingContext,
   package_default,
   authHintForKey,
+  withTask,
   tracing
 };