raindrop-ai 0.4.0 → 0.5.0

package/dist/tracing/index.js

@@ -39,7 +39,69 @@ module.exports = __toCommonJS(tracing_exports);
 var import_api6 = require("@opentelemetry/api");
 var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
 
-// ../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 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"]));
@@ -462,6 +524,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
@@ -590,6 +653,55 @@ 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 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/";
@@ -655,19 +767,23 @@ 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 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(
@@ -1096,570 +1212,179 @@ var import_instrumentation_anthropic = require("@traceloop/instrumentation-anthr
 var import_instrumentation_bedrock = require("@traceloop/instrumentation-bedrock");
 var import_instrumentation_chromadb = require("@traceloop/instrumentation-chromadb");
 var import_instrumentation_cohere = require("@traceloop/instrumentation-cohere");
-var import_instrumentation_openai = require("@traceloop/instrumentation-openai");
 var import_instrumentation_langchain = require("@traceloop/instrumentation-langchain");
 var import_instrumentation_llamaindex = require("@traceloop/instrumentation-llamaindex");
+var import_instrumentation_openai = require("@traceloop/instrumentation-openai");
 var import_instrumentation_pinecone = require("@traceloop/instrumentation-pinecone");
 var import_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
 var import_instrumentation_together = require("@traceloop/instrumentation-together");
 var import_instrumentation_vertexai = require("@traceloop/instrumentation-vertexai");
+var import_weakref = require("weakref");
 
-// src/tracing/otel-core/index.ts
-var import_api = require("@opentelemetry/api");
-var import_core = require("@opentelemetry/core");
-var import_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
-var import_instrumentation = require("@opentelemetry/instrumentation");
-var resourceModule = __toESM(require("@opentelemetry/resources"));
-var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
-var import_ai_semantic_conventions = require("@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_KEY = /* @__PURE__ */ Symbol.for("raindrop.otelCore.state");
-function getState() {
-  var _a;
-  const holder = globalThis;
-  (_a = holder[STATE_KEY]) != null ? _a : holder[STATE_KEY] = {};
-  return holder[STATE_KEY];
-}
-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;
+// src/lib/inject-als.ts
+var import_node_async_hooks = require("async_hooks");
+if (!globalThis.RAINDROP_ASYNC_LOCAL_STORAGE) {
+  globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = import_node_async_hooks.AsyncLocalStorage;
 }
-function safeStringify(value) {
-  try {
-    const result = JSON.stringify(value);
-    return result === void 0 ? String(value) : result;
-  } catch (e) {
-    return "[unserializable]";
-  }
+
+// src/tracing/direct/http.ts
+function wait2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function createResource(attributes) {
-  if ("resourceFromAttributes" in resourceModule) {
-    const factory = resourceModule.resourceFromAttributes;
-    if (typeof factory === "function") return factory(attributes);
-  }
-  return new resourceModule.Resource(attributes);
+function formatEndpoint2(endpoint) {
+  if (!endpoint) return void 0;
+  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
 }
-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) {
+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 logLevel(level) {
-  switch (level) {
-    case "debug":
-      return import_api.DiagLogLevel.DEBUG;
-    case "info":
-      return import_api.DiagLogLevel.INFO;
-    case "warn":
-      return import_api.DiagLogLevel.WARN;
-    default:
-      return import_api.DiagLogLevel.ERROR;
+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);
   }
+  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 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[`${import_ai_semantic_conventions.SpanAttributes.LLM_COMPLETIONS}.0.content`] = response;
+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}`);
     }
-    attributes[`${import_ai_semantic_conventions.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[`${import_ai_semantic_conventions.SpanAttributes.LLM_PROMPTS}.${index}.content`] = typeof content === "string" ? content : safeStringify(content);
-          if (typeof role === "string") {
-            attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_PROMPTS}.${index}.role`] = role;
-          }
-        });
+      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)" : ""}`
+        );
       }
-      delete attributes[AI_PROMPT_MESSAGES];
-    } catch (e) {
+      if (attemptNumber === opts.maxAttempts) break;
     }
   }
-  if (AI_PROMPT_TOKENS in attributes) {
-    attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_PROMPT_TOKENS] = Number(attributes[AI_PROMPT_TOKENS]);
-    delete attributes[AI_PROMPT_TOKENS];
-  }
-  if (AI_COMPLETION_TOKENS in attributes) {
-    attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_COMPLETION_TOKENS] = Number(attributes[AI_COMPLETION_TOKENS]);
-    delete attributes[AI_COMPLETION_TOKENS];
-  }
-  const prompt = attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_PROMPT_TOKENS];
-  const completion = attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_COMPLETION_TOKENS];
-  if (prompt !== void 0 && completion !== void 0) {
-    attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_TOTAL_TOKENS] = Number(prompt) + Number(completion);
-  }
-  if (AI_MODEL_PROVIDER in attributes) {
-    const vendor = String(attributes[AI_MODEL_PROVIDER]);
-    attributes[import_ai_semantic_conventions.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;
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
-function scopeName(span) {
+async function postJson2(url, body, headers, opts) {
   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 = import_api.context.active().getValue(import_ai_semantic_conventions.CONTEXT_KEY_ALLOW_TRACE_CONTENT);
-  if (typeof contextual === "boolean") return contextual;
-  if (((_a = getState().configuration) == null ? void 0 : _a.traceContent) === false) return false;
-  return (process.env.TRACELOOP_TRACE_CONTENT || "true").toLowerCase() !== "false";
-}
-function enrichStart(span) {
-  const active = import_api.context.active();
-  const workflow = active.getValue(WORKFLOW_NAME_KEY);
-  if (typeof workflow === "string") span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_WORKFLOW_NAME, workflow);
-  const entity = active.getValue(ENTITY_NAME_KEY);
-  if (typeof entity === "string") span.setAttribute(import_ai_semantic_conventions.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(`${import_ai_semantic_conventions.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 import_exporter_trace_otlp_proto.OTLPTraceExporter({ url: `${baseUrl}/v1/traces`, headers: resolvedHeaders });
-  const processor = options.disableBatch ? new import_sdk_trace_base.SimpleSpanProcessor(exporter) : new import_sdk_trace_base.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;
+  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;
       }
-      outgoing = transformAiSdkSpan(span);
-    } catch (e) {
-    }
-    try {
-      originalOnEnd(outgoing);
-    } catch (e) {
-    }
-  };
-  return processor;
+    },
+    opName,
+    opts
+  );
 }
-function initialize(options = {}) {
-  var _a;
-  const state = getState();
-  if (state.configuration) return;
-  state.configuration = Object.freeze({ ...options });
-  if (options.logLevel) import_api.diag.setLogger(new import_api.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 import_sdk_trace_node.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) {
-      }
-    }
-  }
-  (0, import_instrumentation.registerInstrumentations)({ instrumentations });
+
+// src/tracing/direct/ids.ts
+function getCrypto2() {
+  const c = globalThis.crypto;
+  return c;
 }
-async function forceFlush() {
-  var _a, _b;
-  const state = getState();
-  try {
-    await ((_a = state.provider) == null ? void 0 : _a.forceFlush());
-    await ((_b = state.defaultProcessor) == null ? void 0 : _b.forceFlush());
-  } catch (e) {
+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 withEntity(type, config, fn, args) {
-  let entityContext = import_api.context.active();
-  if (type === import_ai_semantic_conventions.TraceloopSpanKindValues.WORKFLOW) {
-    entityContext = entityContext.setValue(WORKFLOW_NAME_KEY, config.name);
-  }
-  const parentPath = entityContext.getValue(ENTITY_NAME_KEY);
-  if (type === import_ai_semantic_conventions.TraceloopSpanKindValues.TASK || type === import_ai_semantic_conventions.TraceloopSpanKindValues.TOOL) {
-    entityContext = entityContext.setValue(
-      ENTITY_NAME_KEY,
-      `${typeof parentPath === "string" ? `${parentPath}.` : ""}${config.name}`
-    );
+function base64Encode2(bytes) {
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(bytes).toString("base64");
   }
-  if (config.traceContent !== void 0) {
-    entityContext = entityContext.setValue(import_ai_semantic_conventions.CONTEXT_KEY_ALLOW_TRACE_CONTENT, config.traceContent);
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
   }
-  if (config.associationProperties) {
-    entityContext = entityContext.setValue(ASSOCIATION_PROPERTIES_KEY, config.associationProperties);
+  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);
   }
-  if (config.suppressTracing) {
-    entityContext = (0, import_core.suppressTracing)(entityContext);
+  return out;
+}
+function base64ToHex2(base64) {
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(base64, "base64").toString("hex");
   }
-  let callbackStarted = false;
-  const run = (span) => {
-    var _a;
-    try {
-      span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_ENTITY_NAME, config.name);
-      span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_ENTITY_PATH, typeof parentPath === "string" ? parentPath : "");
-      span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_SPAN_KIND, type);
-      if (type === import_ai_semantic_conventions.TraceloopSpanKindValues.WORKFLOW) {
-        span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_WORKFLOW_NAME, config.name);
-      }
-      if (config.version !== void 0) span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_ENTITY_VERSION, config.version);
-      const input = (_a = config.inputParameters) != null ? _a : args;
-      if (shouldSendTraceContent()) {
-        span.setAttribute(
-          import_ai_semantic_conventions.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(import_ai_semantic_conventions.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(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_ENTITY_OUTPUT, safeStringify(result));
-      span.end();
-    } catch (e) {
+  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 result;
-  };
-  try {
-    const tracer = import_api.trace.getTracer(TRACER_NAME);
-    return import_api.context.with(
-      entityContext,
-      () => tracer.startActiveSpan(`${config.name}.${type}`, {}, entityContext, run)
-    );
-  } catch (error) {
-    if (callbackStarted) throw error;
-    return fn(...args);
+    return hex;
   }
-}
-function withTask(config, fn, ...args) {
-  return withEntity(import_ai_semantic_conventions.TraceloopSpanKindValues.TASK, config, fn, args);
-}
-function withTool(config, fn, ...args) {
-  return withEntity(import_ai_semantic_conventions.TraceloopSpanKindValues.TOOL, config, fn, args);
-}
-
-// src/tracing/tracer-core.ts
-var import_weakref = require("weakref");
-
-// src/lib/inject-als.ts
-var import_node_async_hooks = require("async_hooks");
-if (!globalThis.RAINDROP_ASYNC_LOCAL_STORAGE) {
-  globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = import_node_async_hooks.AsyncLocalStorage;
-}
-
-// 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;
-  }
-  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);
-  }
-  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`
-        );
-      }
-      if (delay > 0) await wait2(delay);
-    } else if (opts.debug) {
-      console.log(`[raindrop] ${opName} attempt ${attemptNumber}/${opts.maxAttempts}`);
-    }
-    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;
-    }
-  }
-  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;
-}
-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;
-  }
-  throw new Error("No base64 decoder available in this runtime");
+  throw new Error("No base64 decoder available in this runtime");
 }
 
 // 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",
@@ -1670,9 +1395,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",
@@ -1712,8 +1442,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",
@@ -1722,6 +1452,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",
@@ -1732,16 +1463,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"
   },
@@ -1831,520 +1563,1063 @@ function buildExportTraceServiceRequest2(spans) {
             scope: { name: SERVICE_NAME, version: libraryVersion },
             spans
           }
-        ]
+        ]
+      }
+    ]
+  };
+}
+
+// src/tracing/direct/context.ts
+var import_api = require("@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 getExplicitTraceContext(traceId, parentSpanId) {
+  if (!traceId || !parentSpanId || !(0, import_api.isValidTraceId)(traceId) || !(0, import_api.isValidSpanId)(parentSpanId)) {
+    return void 0;
+  }
+  return {
+    traceIdB64: hexToBase64(traceId),
+    parentSpanIdB64: hexToBase64(parentSpanId)
+  };
+}
+function getActiveTraceContext() {
+  const activeSpan = import_api.trace.getSpan(import_api.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
+  };
+}
+
+// src/tracing/multi-project.ts
+var import_node_crypto = require("crypto");
+var import_exporter_trace_otlp_proto2 = require("@opentelemetry/exporter-trace-otlp-proto");
+
+// src/tracing/replay-routing.ts
+var import_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
+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 import_exporter_trace_otlp_proto.OTLPTraceExporter({
+      url: replayTraceUrl(destination.url)
+    });
+  }
+  return new import_exporter_trace_otlp_proto.OTLPTraceExporter({
+    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 (0, import_node_crypto.createHash)("sha256").update(writeKey, "utf8").digest("hex").slice(0, 8);
+}
+var STATE_KEY2 = /* @__PURE__ */ Symbol.for("raindrop.tracing.multiProjectState");
+function getState() {
+  const holder = globalThis;
+  let state2 = holder[STATE_KEY2];
+  if (!state2) {
+    state2 = {
+      foreignClientSeen: false,
+      seenClientHints: /* @__PURE__ */ new Set(),
+      ownerAuthHint: void 0,
+      ownerProjectId: void 0,
+      pipelineClaimed: false,
+      traceloopConfiguredWithoutClaim: false,
+      multiKeyWarned: false,
+      pendingMultiKeyWarning: false
+    };
+    holder[STATE_KEY2] = state2;
+  }
+  return state2;
+}
+function emitMultiKeyWarningOnce() {
+  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 state2 = getState();
+  state2.seenClientHints.add(authHint);
+  if (state2.seenClientHints.size > 1) {
+    state2.foreignClientSeen = true;
+    if (tracingEnabled || state2.pipelineClaimed) {
+      emitMultiKeyWarningOnce();
+    } else {
+      state2.pendingMultiKeyWarning = true;
+    }
+  }
+}
+function markForeignClient() {
+  getState().foreignClientSeen = true;
+}
+function foreignClientSeen() {
+  return getState().foreignClientSeen;
+}
+function stampSpan(span, projectId, authHint) {
+  try {
+    if (projectId) {
+      span.setAttribute(PROJECT_ID_SPAN_ATTRIBUTE, projectId);
+    }
+    if (authHint && foreignClientSeen()) {
+      span.setAttribute(AUTH_HINT_SPAN_ATTRIBUTE, authHint);
+    }
+  } catch (e) {
+  }
+}
+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) {
+  }
+}
+var RaindropContextSpanProcessor = class {
+  onStart(span) {
+    try {
+      stampContextAttributes(span);
+      rememberReplayTraceDestination(span);
+      const bound = currentRoutingBinding();
+      if (!bound) return;
+      stampSpan(span, bound.projectId, bound.authHint);
+    } catch (e) {
+    }
+  }
+  onEnd(span) {
+    var _a;
+    try {
+      if (((_a = span == null ? void 0 : span.status) == null ? void 0 : _a.code) !== SPAN_STATUS_ERROR) return;
+      markErrorSpanSeen(span);
+    } catch (e) {
+    }
+  }
+  async forceFlush() {
+  }
+  async shutdown() {
+  }
+};
+var GuardedSpanExporter = class {
+  constructor(inner, ownerAuthHint) {
+    this.droppedTotal = 0;
+    this.inner = inner;
+    this.ownerAuthHint = ownerAuthHint;
+  }
+  partition(spans) {
+    var _a;
+    const allowed = [];
+    let dropped = 0;
+    const requirePositive = foreignClientSeen();
+    for (const span of spans) {
+      const attrs = (_a = span.attributes) != null ? _a : {};
+      const hint = attrs[AUTH_HINT_SPAN_ATTRIBUTE];
+      const keep = requirePositive ? hint === this.ownerAuthHint : hint === void 0 || hint === this.ownerAuthHint;
+      if (keep) {
+        allowed.push(span);
+      } else {
+        dropped += 1;
+      }
+    }
+    return { allowed, dropped };
+  }
+  warnDropped(dropped) {
+    this.droppedTotal += dropped;
+    const total = this.droppedTotal;
+    rateLimitedLog(
+      "js-sdk.multi-project.dropped",
+      () => console.warn(
+        `[raindrop] Dropped ${dropped} span(s) produced under a different API key than the tracing pipeline's (total dropped: ${total}). One process has ONE OTel pipeline authenticating with the first tracing-enabled client's key; tracing for a different key/org in the same process is unsupported \u2014 run it in its own process. Manual events (track_ai/begin/finish/signals/identify) are unaffected.`
+      )
+    );
+  }
+  export(spans, resultCallback) {
+    let allowed;
+    let dropped;
+    try {
+      ({ allowed, dropped } = this.partition(spans));
+    } catch (e) {
+      if (foreignClientSeen()) {
+        this.warnDropped(spans.length);
+        resultCallback({ code: EXPORT_FAILED2 });
+        return;
+      }
+      this.inner.export(spans, resultCallback);
+      return;
+    }
+    if (dropped) {
+      this.warnDropped(dropped);
+    }
+    if (allowed.length === 0) {
+      resultCallback({ code: EXPORT_SUCCESS2 });
+      return;
+    }
+    this.inner.export(allowed, resultCallback);
+  }
+  shutdown() {
+    return this.inner.shutdown();
+  }
+  forceFlush() {
+    return this.inner.forceFlush ? this.inner.forceFlush() : Promise.resolve();
+  }
+};
+function buildGuardedExporter(baseUrl, headers, ownerAuthHint) {
+  const inner = new import_exporter_trace_otlp_proto2.OTLPTraceExporter({
+    url: `${baseUrl}/v1/traces`,
+    headers
+  });
+  return new GuardedSpanExporter(inner, ownerAuthHint);
+}
+function pipelineOwnerHint() {
+  return getState().ownerAuthHint;
+}
+function claimPipeline(authHint, projectId) {
+  const state2 = getState();
+  if (state2.pipelineClaimed) {
+    return false;
+  }
+  state2.pipelineClaimed = true;
+  state2.ownerAuthHint = authHint;
+  state2.ownerProjectId = projectId;
+  if (state2.foreignClientSeen && state2.pendingMultiKeyWarning) {
+    emitMultiKeyWarningOnce();
+  }
+  return true;
+}
+function releasePipelineClaim() {
+  const state2 = getState();
+  state2.pipelineClaimed = false;
+  state2.ownerAuthHint = void 0;
+  state2.ownerProjectId = void 0;
+}
+function markTraceloopConfiguredWithoutClaim() {
+  getState().traceloopConfiguredWithoutClaim = true;
+}
+function traceloopConfiguredWithoutClaim() {
+  return getState().traceloopConfiguredWithoutClaim;
+}
+
+// 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;
+    }
+  }
+  /**
+   * 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;
+      }
+      attributes.push(
+        attrString2(`traceloop.association.properties.${key}`, serializeAssociationValue(value))
+      );
+    }
+    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));
+    }
+    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)
+    );
+    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}"`);
+    }
+  }
+  sendToolSpan(params) {
+    this.sendSpan({
+      ...params,
+      spanKind: "tool"
+    });
+  }
+  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);
+    }
+  }
+  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;
+      }
+      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);
+        }
       }
-    ]
-  };
-}
-
-// src/tracing/direct/context.ts
-var import_api2 = require("@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 getExplicitTraceContext(traceId, parentSpanId) {
-  if (!traceId || !parentSpanId || !(0, import_api2.isValidTraceId)(traceId) || !(0, import_api2.isValidSpanId)(parentSpanId)) {
-    return void 0;
+  /**
+   * 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 };
   }
-  return {
-    traceIdB64: hexToBase64(traceId),
-    parentSpanIdB64: hexToBase64(parentSpanId)
-  };
-}
-function getActiveTraceContext() {
-  const activeSpan = import_api2.trace.getSpan(import_api2.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 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;
+    }
+  }
+};
 
-// src/tracing/multi-project.ts
-var import_node_crypto = require("crypto");
-var import_exporter_trace_otlp_proto2 = require("@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;
-var SPAN_STATUS_ERROR = 2;
-function authHintForKey(writeKey) {
-  if (!writeKey) return void 0;
-  return (0, import_node_crypto.createHash)("sha256").update(writeKey, "utf8").digest("hex").slice(0, 8);
-}
-var STATE_KEY2 = /* @__PURE__ */ Symbol.for("raindrop.tracing.multiProjectState");
+// src/tracing/otel-core/index.ts
+var import_api2 = require("@opentelemetry/api");
+var import_core6 = require("@opentelemetry/core");
+var import_exporter_trace_otlp_proto3 = require("@opentelemetry/exporter-trace-otlp-proto");
+var import_instrumentation = require("@opentelemetry/instrumentation");
+var resourceModule = __toESM(require("@opentelemetry/resources"));
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+var import_ai_semantic_conventions = require("@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;
-  let state = holder[STATE_KEY2];
-  if (!state) {
-    state = {
-      foreignClientSeen: false,
-      seenClientHints: /* @__PURE__ */ new Set(),
-      ownerAuthHint: void 0,
-      ownerProjectId: void 0,
-      pipelineClaimed: false,
-      traceloopConfiguredWithoutClaim: false,
-      multiKeyWarned: false,
-      pendingMultiKeyWarning: false
-    };
-    holder[STATE_KEY2] = state;
-  }
-  return state;
+  (_a = holder[STATE_KEY3]) != null ? _a : holder[STATE_KEY3] = {};
+  return holder[STATE_KEY3];
 }
-function emitMultiKeyWarningOnce() {
-  const state = getState2();
-  if (state.multiKeyWarned) return;
-  state.multiKeyWarned = true;
-  state.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 = getState2();
-  state.seenClientHints.add(authHint);
-  if (state.seenClientHints.size > 1) {
-    state.foreignClientSeen = true;
-    if (tracingEnabled || state.pipelineClaimed) {
-      emitMultiKeyWarningOnce();
-    } else {
-      state.pendingMultiKeyWarning = true;
+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 markForeignClient() {
-  getState2().foreignClientSeen = true;
-}
-function foreignClientSeen() {
-  return getState2().foreignClientSeen;
-}
-function stampSpan(span, projectId, authHint) {
+function safeStringify(value) {
   try {
-    if (projectId) {
-      span.setAttribute(PROJECT_ID_SPAN_ATTRIBUTE, projectId);
-    }
-    if (authHint && foreignClientSeen()) {
-      span.setAttribute(AUTH_HINT_SPAN_ATTRIBUTE, authHint);
-    }
+    const result = JSON.stringify(value);
+    return result === void 0 ? String(value) : result;
   } catch (e) {
+    return "[unserializable]";
   }
 }
-function stampContextAttributes(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 detectRuntimeResource() {
   try {
-    applySpanAttributeFrames(span, (key, value) => span.setAttribute(key, value));
+    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;
 }
-var RaindropContextSpanProcessor = class {
-  onStart(span) {
-    try {
-      stampContextAttributes(span);
-      const bound = currentRoutingBinding();
-      if (!bound) return;
-      stampSpan(span, bound.projectId, bound.authHint);
-    } catch (e) {
+function logLevel(level) {
+  switch (level) {
+    case "debug":
+      return import_api2.DiagLogLevel.DEBUG;
+    case "info":
+      return import_api2.DiagLogLevel.INFO;
+    case "warn":
+      return import_api2.DiagLogLevel.WARN;
+    default:
+      return import_api2.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[`${import_ai_semantic_conventions.SpanAttributes.LLM_COMPLETIONS}.0.content`] = response;
     }
+    attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_COMPLETIONS}.0.role`] = "assistant";
+    delete attributes[AI_RESPONSE_TEXT];
   }
-  onEnd(span) {
-    var _a;
+  if (AI_PROMPT_MESSAGES in attributes) {
     try {
-      if (((_a = span == null ? void 0 : span.status) == null ? void 0 : _a.code) !== SPAN_STATUS_ERROR) return;
-      markErrorSpanSeen(span);
+      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[`${import_ai_semantic_conventions.SpanAttributes.LLM_PROMPTS}.${index}.content`] = typeof content === "string" ? content : safeStringify(content);
+          if (typeof role === "string") {
+            attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_PROMPTS}.${index}.role`] = role;
+          }
+        });
+      }
+      delete attributes[AI_PROMPT_MESSAGES];
     } catch (e) {
     }
   }
-  async forceFlush() {
-  }
-  async shutdown() {
-  }
-};
-var GuardedSpanExporter = class {
-  constructor(inner, ownerAuthHint) {
-    this.droppedTotal = 0;
-    this.inner = inner;
-    this.ownerAuthHint = ownerAuthHint;
-  }
-  partition(spans) {
-    var _a;
-    const allowed = [];
-    let dropped = 0;
-    const requirePositive = foreignClientSeen();
-    for (const span of spans) {
-      const attrs = (_a = span.attributes) != null ? _a : {};
-      const hint = attrs[AUTH_HINT_SPAN_ATTRIBUTE];
-      const keep = requirePositive ? hint === this.ownerAuthHint : hint === void 0 || hint === this.ownerAuthHint;
-      if (keep) {
-        allowed.push(span);
-      } else {
-        dropped += 1;
-      }
-    }
-    return { allowed, dropped };
+  if (AI_PROMPT_TOKENS in attributes) {
+    attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_PROMPT_TOKENS] = Number(attributes[AI_PROMPT_TOKENS]);
+    delete attributes[AI_PROMPT_TOKENS];
   }
-  warnDropped(dropped) {
-    this.droppedTotal += dropped;
-    const total = this.droppedTotal;
-    rateLimitedLog(
-      "js-sdk.multi-project.dropped",
-      () => console.warn(
-        `[raindrop] Dropped ${dropped} span(s) produced under a different API key than the tracing pipeline's (total dropped: ${total}). One process has ONE OTel pipeline authenticating with the first tracing-enabled client's key; tracing for a different key/org in the same process is unsupported \u2014 run it in its own process. Manual events (track_ai/begin/finish/signals/identify) are unaffected.`
-      )
+  if (AI_COMPLETION_TOKENS in attributes) {
+    attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_COMPLETION_TOKENS] = Number(
+      attributes[AI_COMPLETION_TOKENS]
     );
+    delete attributes[AI_COMPLETION_TOKENS];
   }
-  export(spans, resultCallback) {
-    let allowed;
-    let dropped;
-    try {
-      ({ allowed, dropped } = this.partition(spans));
-    } catch (e) {
-      if (foreignClientSeen()) {
-        this.warnDropped(spans.length);
-        resultCallback({ code: EXPORT_FAILED });
-        return;
-      }
-      this.inner.export(spans, resultCallback);
-      return;
-    }
-    if (dropped) {
-      this.warnDropped(dropped);
-    }
-    if (allowed.length === 0) {
-      resultCallback({ code: EXPORT_SUCCESS });
-      return;
-    }
-    this.inner.export(allowed, resultCallback);
-  }
-  shutdown() {
-    return this.inner.shutdown();
+  const prompt = attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_PROMPT_TOKENS];
+  const completion = attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_COMPLETION_TOKENS];
+  if (prompt !== void 0 && completion !== void 0) {
+    attributes[import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_TOTAL_TOKENS] = Number(prompt) + Number(completion);
   }
-  forceFlush() {
-    return this.inner.forceFlush ? this.inner.forceFlush() : Promise.resolve();
+  if (AI_MODEL_PROVIDER in attributes) {
+    const vendor = String(attributes[AI_MODEL_PROVIDER]);
+    attributes[import_ai_semantic_conventions.SpanAttributes.LLM_SYSTEM] = vendor.startsWith("openai") ? "OpenAI" : vendor;
+    delete attributes[AI_MODEL_PROVIDER];
   }
-};
-function buildGuardedExporter(baseUrl, headers, ownerAuthHint) {
-  const inner = new import_exporter_trace_otlp_proto2.OTLPTraceExporter({
-    url: `${baseUrl}/v1/traces`,
-    headers
+  Object.defineProperty(span, "name", {
+    configurable: true,
+    value: names[span.name],
+    writable: true
   });
-  return new GuardedSpanExporter(inner, ownerAuthHint);
-}
-function pipelineOwnerHint() {
-  return getState2().ownerAuthHint;
+  return span;
 }
-function claimPipeline(authHint, projectId) {
-  const state = getState2();
-  if (state.pipelineClaimed) {
-    return false;
-  }
-  state.pipelineClaimed = true;
-  state.ownerAuthHint = authHint;
-  state.ownerProjectId = projectId;
-  if (state.foreignClientSeen && state.pendingMultiKeyWarning) {
-    emitMultiKeyWarningOnce();
+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 true;
-}
-function releasePipelineClaim() {
-  const state = getState2();
-  state.pipelineClaimed = false;
-  state.ownerAuthHint = void 0;
-  state.ownerProjectId = void 0;
-}
-function markTraceloopConfiguredWithoutClaim() {
-  getState2().traceloopConfiguredWithoutClaim = true;
-}
-function traceloopConfiguredWithoutClaim() {
-  return getState2().traceloopConfiguredWithoutClaim;
+  return (_a = span.instrumentationLibrary) == null ? void 0 : _a.name;
 }
-
-// src/tracing/direct/shipper.ts
-function serializeAssociationValue(value) {
-  return stringifyBounded(value);
+function contentCaptureDisabled(options) {
+  return options.traceContent === false || (process.env.TRACELOOP_TRACE_CONTENT || "true").toLowerCase() === "false";
 }
-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;
-    }
-  }
-  /**
-   * 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;
-      }
-      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 */
-      };
-    }
-    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"
-      });
-    }
-    this.enqueue(span);
-    if (this.debug) {
-      console.log(`[raindrop] direct shipper: enqueued span "${params.name}"`);
+function shouldSendTraceContent() {
+  var _a;
+  const contextual = import_api2.context.active().getValue(import_ai_semantic_conventions.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 = import_api2.context.active();
+  const workflow = active.getValue(WORKFLOW_NAME_KEY);
+  if (typeof workflow === "string")
+    span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_WORKFLOW_NAME, workflow);
+  const entity = active.getValue(ENTITY_NAME_KEY);
+  if (typeof entity === "string") span.setAttribute(import_ai_semantic_conventions.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(`${import_ai_semantic_conventions.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 import_exporter_trace_otlp_proto3.OTLPTraceExporter({ url: `${baseUrl}/v1/traces`, headers: resolvedHeaders });
+  const exporter = options.routeReplayTraces ? new ReplayRoutingSpanExporter(baseExporter) : baseExporter;
+  const processor = options.disableBatch ? new import_sdk_trace_base.SimpleSpanProcessor(exporter) : new import_sdk_trace_base.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) import_api2.diag.setLogger(new import_api2.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 import_sdk_trace_node.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;
+  }
+  (0, import_instrumentation.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 = import_api2.context.active();
+  if (type === import_ai_semantic_conventions.TraceloopSpanKindValues.WORKFLOW) {
+    entityContext = entityContext.setValue(WORKFLOW_NAME_KEY, config.name);
+  }
+  const parentPath = entityContext.getValue(ENTITY_NAME_KEY);
+  if (type === import_ai_semantic_conventions.TraceloopSpanKindValues.TASK || type === import_ai_semantic_conventions.TraceloopSpanKindValues.TOOL) {
+    entityContext = entityContext.setValue(
+      ENTITY_NAME_KEY,
+      `${typeof parentPath === "string" ? `${parentPath}.` : ""}${config.name}`
+    );
+  }
+  if (config.traceContent !== void 0) {
+    entityContext = entityContext.setValue(import_ai_semantic_conventions.CONTEXT_KEY_ALLOW_TRACE_CONTENT, config.traceContent);
+  }
+  if (config.associationProperties) {
+    entityContext = entityContext.setValue(
+      ASSOCIATION_PROPERTIES_KEY,
+      config.associationProperties
+    );
+  }
+  if (config.suppressTracing) {
+    entityContext = (0, import_core6.suppressTracing)(entityContext);
+  }
+  let callbackStarted = false;
+  const run = (span) => {
+    var _a;
+    try {
+      span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_ENTITY_NAME, config.name);
+      span.setAttribute(
+        import_ai_semantic_conventions.SpanAttributes.TRACELOOP_ENTITY_PATH,
+        typeof parentPath === "string" ? parentPath : ""
+      );
+      span.setAttribute(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_SPAN_KIND, type);
+      if (type === import_ai_semantic_conventions.TraceloopSpanKindValues.WORKFLOW) {
+        span.setAttribute(import_ai_semantic_conventions.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(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_ENTITY_VERSION, config.version);
+      const input = (_a = config.inputParameters) != null ? _a : args;
+      if (shouldSendTraceContent()) {
+        span.setAttribute(
+          import_ai_semantic_conventions.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(import_ai_semantic_conventions.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(import_ai_semantic_conventions.SpanAttributes.TRACELOOP_ENTITY_OUTPUT, safeStringify(result));
+      span.end();
+    } catch (e) {
     }
+    return result;
+  };
+  try {
+    const tracer = import_api2.trace.getTracer(TRACER_NAME);
+    return import_api2.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(import_ai_semantic_conventions.TraceloopSpanKindValues.TASK, config, fn, args);
+}
+function withTool(config, fn, ...args) {
+  return withEntity(import_ai_semantic_conventions.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(() => {
       })
@@ -3686,6 +3961,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;
@@ -3817,10 +4100,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: {},
@@ -4234,7 +4531,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) {
@@ -4242,22 +4540,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();
@@ -4285,7 +4601,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;
@@ -4536,7 +4853,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 : {
@@ -4557,6 +4875,7 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
         apiKey: writeKey,
         disableBatch: disableBatching,
         ...processorOptions != null ? processorOptions : {},
+        routeReplayTraces: true,
         ...headers ? { headers } : {}
       });
       const localDebuggerProcessor = createLocalDebuggerSpanProcessor({