raindrop-ai 0.0.80 → 0.0.81-otelv2

package/dist/{chunk-B5UZWYFP.mjs → chunk-PGFJVUKL.mjs}

@@ -1,5 +1,97 @@
+// package.json
+var package_default = {
+  name: "raindrop-ai",
+  version: "0.0.81",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  license: "MIT",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./tracing": {
+      types: "./dist/tracing/index.d.ts",
+      node: "./dist/tracing/index.js",
+      import: "./dist/tracing/index.mjs",
+      require: "./dist/tracing/index.js"
+    },
+    "./otel": {
+      types: "./dist/otel/index.d.ts",
+      node: "./dist/otel/index.js",
+      import: "./dist/otel/index.mjs",
+      require: "./dist/otel/index.js"
+    }
+  },
+  files: [
+    "dist/**"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    clean: "rm -rf .turbo && rm -rf dist",
+    try: "tsx ./src/example/index.ts",
+    test: "vitest run",
+    smoke: "tsx ./scripts/smoke.ts"
+  },
+  devDependencies: {
+    "@types/node": "^20.11.17",
+    msw: "^2.12.8",
+    tsup: "^8.4.0",
+    tsx: "^4.20.3",
+    typescript: "^5.3.3",
+    vitest: "^4.0.10"
+  },
+  dependencies: {
+    "@dawn-analytics/redact-pii": "0.1.2",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@traceloop/node-server-sdk": "0.19.0-otel-v1",
+    weakref: "^0.2.1",
+    zod: "^3.23.8"
+  },
+  publishConfig: {
+    access: "public",
+    provenance: false
+  },
+  tsup: {
+    entry: [
+      "src/index.ts",
+      "src/tracing/index.ts",
+      "src/otel/index.ts"
+    ],
+    format: [
+      "cjs",
+      "esm"
+    ],
+    external: [
+      "@traceloop/node-server-sdk",
+      "@traceloop/instrumentation-anthropic",
+      "@traceloop/instrumentation-openai",
+      "@traceloop/instrumentation-cohere",
+      "@traceloop/instrumentation-bedrock",
+      "@traceloop/instrumentation-vertexai",
+      "@traceloop/instrumentation-pinecone",
+      "@traceloop/instrumentation-chromadb",
+      "@traceloop/instrumentation-qdrant",
+      "@traceloop/instrumentation-together",
+      "@opentelemetry/instrumentation",
+      "@opentelemetry/sdk-trace-base"
+    ],
+    noExternal: [
+      "@dawn/schemas"
+    ],
+    dts: {
+      resolve: true
+    },
+    clean: true
+  }
+};
+
 // src/tracing/tracer-core.ts
-import { context, trace as trace3 } from "@opentelemetry/api";
+import { context as context2, trace as trace4 } from "@opentelemetry/api";
 import { AnthropicInstrumentation } from "@traceloop/instrumentation-anthropic";
 import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
 import { ChromaDBInstrumentation } from "@traceloop/instrumentation-chromadb";
@@ -15,18 +107,353 @@ import {
 import * as traceloop3 from "@traceloop/node-server-sdk";
 import { WeakValueMap } from "weakref";
 
+// src/tracing/direct/http.ts
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatEndpoint(endpoint) {
+  if (!endpoint) return void 0;
+  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
+}
+function parseRetryAfter(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 getRetryDelayMs(attemptNumber, previousError) {
+  if (previousError && typeof previousError === "object" && previousError !== null && "retryAfterMs" in previousError) {
+    const v = previousError.retryAfterMs;
+    if (typeof v === "number") return Math.max(0, v);
+  }
+  if (attemptNumber <= 1) return 0;
+  const base = 500;
+  const factor = Math.pow(2, attemptNumber - 2);
+  return base * factor;
+}
+async function withRetry(operation, opName, opts) {
+  let lastError = void 0;
+  for (let attemptNumber = 1; attemptNumber <= opts.maxAttempts; attemptNumber++) {
+    if (attemptNumber > 1) {
+      const delay = getRetryDelayMs(attemptNumber, lastError);
+      if (opts.debug) {
+        console.warn(
+          `[raindrop] ${opName} retry ${attemptNumber}/${opts.maxAttempts} in ${delay}ms`
+        );
+      }
+      if (delay > 0) await wait(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 postJson(url, body, headers, opts) {
+  const opName = `POST ${url}`;
+  await withRetry(
+    async () => {
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify(body)
+      });
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        const err = new Error(
+          `HTTP ${resp.status} ${resp.statusText}${text ? `: ${text}` : ""}`
+        );
+        const retryAfterMs = parseRetryAfter(resp.headers);
+        if (typeof retryAfterMs === "number") err.retryAfterMs = retryAfterMs;
+        throw err;
+      }
+    },
+    opName,
+    opts
+  );
+}
+
+// src/tracing/direct/ids.ts
+function getCrypto() {
+  const c = globalThis.crypto;
+  return c;
+}
+function randomBytes(length) {
+  const cryptoObj = getCrypto();
+  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 base64Encode(bytes) {
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
+  }
+  const btoaFn = globalThis.btoa;
+  if (typeof btoaFn === "function") return btoaFn(binary);
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let out = "";
+  let i = 0;
+  while (i < binary.length) {
+    const c1 = binary.charCodeAt(i++) & 255;
+    const c2 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
+    const c3 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
+    const e1 = c1 >> 2;
+    const e2 = (c1 & 3) << 4 | (Number.isNaN(c2) ? 0 : c2 >> 4);
+    const e3 = Number.isNaN(c2) ? 64 : (c2 & 15) << 2 | (Number.isNaN(c3) ? 0 : c3 >> 6);
+    const e4 = Number.isNaN(c3) ? 64 : c3 & 63;
+    out += alphabet.charAt(e1);
+    out += alphabet.charAt(e2);
+    out += e3 === 64 ? "=" : alphabet.charAt(e3);
+    out += e4 === 64 ? "=" : alphabet.charAt(e4);
+  }
+  return out;
+}
+
+// src/tracing/direct/otlp.ts
+var libraryVersion = package_default.version;
+var SERVICE_NAME = "raindrop-ai";
+function attrString(key, value) {
+  if (value === void 0) return void 0;
+  return { key, value: { stringValue: value } };
+}
+function attrInt(key, value) {
+  if (value === void 0) return void 0;
+  if (!Number.isFinite(value)) return void 0;
+  return { key, value: { intValue: String(Math.trunc(value)) } };
+}
+function buildOtlpSpan(args) {
+  const attrs = args.attributes.filter((x) => x !== void 0);
+  const span = {
+    traceId: args.ids.traceIdB64,
+    spanId: args.ids.spanIdB64,
+    name: args.name,
+    startTimeUnixNano: args.startTimeUnixNano,
+    endTimeUnixNano: args.endTimeUnixNano
+  };
+  if (args.ids.parentSpanIdB64) span.parentSpanId = args.ids.parentSpanIdB64;
+  if (attrs.length) span.attributes = attrs;
+  if (args.status) span.status = args.status;
+  return span;
+}
+function buildExportTraceServiceRequest(spans) {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [{ key: "service.name", value: { stringValue: SERVICE_NAME } }]
+        },
+        scopeSpans: [
+          {
+            scope: { name: SERVICE_NAME, version: libraryVersion },
+            spans
+          }
+        ]
+      }
+    ]
+  };
+}
+
+// src/tracing/direct/context.ts
+import { context, trace } from "@opentelemetry/api";
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+var INVALID_SPAN_ID = "0000000000000000";
+function hexToBase64(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return base64Encode(bytes);
+}
+function getActiveTraceContext() {
+  const activeSpan = trace.getSpan(context.active());
+  if (!activeSpan) return {};
+  const spanContext = activeSpan.spanContext();
+  const traceIdHex = spanContext.traceId;
+  const spanIdHex = spanContext.spanId;
+  if (traceIdHex === INVALID_TRACE_ID) return {};
+  return {
+    traceIdB64: hexToBase64(traceIdHex),
+    parentSpanIdB64: spanIdHex !== INVALID_SPAN_ID ? hexToBase64(spanIdHex) : void 0
+  };
+}
+
+// src/tracing/direct/shipper.ts
+var DirectTraceShipper = class {
+  constructor(opts) {
+    this.queue = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d, _e;
+    this.writeKey = opts.writeKey;
+    this.baseUrl = (_a = formatEndpoint(opts.endpoint)) != null ? _a : "https://api.raindrop.ai/v1/";
+    this.enabled = (_b = opts.enabled) != null ? _b : true;
+    this.debug = opts.debug;
+    this.flushIntervalMs = (_c = opts.flushIntervalMs) != null ? _c : 1e3;
+    this.maxBatchSize = (_d = opts.maxBatchSize) != null ? _d : 50;
+    this.maxQueueSize = (_e = opts.maxQueueSize) != null ? _e : 5e3;
+  }
+  /**
+   * 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.
+   */
+  sendToolSpan(params) {
+    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 = base64Encode(randomBytes(8));
+    if (!traceIdB64) {
+      traceIdB64 = base64Encode(randomBytes(16));
+    }
+    const startTimeUnixNano = String(params.startTimeMs * 1e6);
+    const endTimeUnixNano = String(params.endTimeMs * 1e6);
+    const attributes = [
+      // Required: passes hasAIOperation() filter in backend (parseSpan.ts)
+      attrString("traceloop.span.kind", "tool"),
+      // Parsed by backend for input/output payloads
+      attrString("traceloop.entity.input", params.input),
+      attrString("traceloop.entity.output", params.output),
+      // Duration tracking
+      attrInt("traceloop.entity.duration_ms", params.durationMs)
+    ];
+    for (const [key, value] of Object.entries(params.properties)) {
+      attributes.push(attrString(`traceloop.association.properties.${key}`, value));
+    }
+    let status;
+    if (params.error) {
+      status = { code: 2, message: params.error };
+    } else {
+      status = {
+        code: 1
+        /* STATUS_CODE_OK */
+      };
+    }
+    const span = buildOtlpSpan({
+      ids: {
+        traceIdB64,
+        spanIdB64,
+        parentSpanIdB64
+      },
+      name: params.name,
+      startTimeUnixNano,
+      endTimeUnixNano,
+      attributes,
+      status
+    });
+    this.enqueue(span);
+    if (this.debug) {
+      console.log(`[raindrop] direct shipper: enqueued span "${params.name}"`);
+    }
+  }
+  enqueue(span) {
+    if (!this.enabled) return;
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+    }
+    this.queue.push(span);
+    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() {
+    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 body = buildExportTraceServiceRequest(batch);
+      const url = `${this.baseUrl}traces`;
+      const p = postJson(
+        url,
+        body,
+        { Authorization: `Bearer ${this.writeKey}` },
+        { maxAttempts: 3, debug: this.debug }
+      );
+      this.inFlight.add(p);
+      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);
+      }
+    }
+  }
+  async shutdown() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    await this.flush();
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+};
+
 // src/tracing/liveInteraction.ts
-import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { SpanStatusCode, trace as trace2 } from "@opentelemetry/api";
 import * as traceloop from "@traceloop/node-server-sdk";
-function getPropertiesFromContext(context2) {
+function getPropertiesFromContext(context3) {
   const properties = {
-    ...context2.userId && { user_id: context2.userId },
-    ...context2.convoId && { convo_id: context2.convoId },
-    ...context2.eventId && { event_id: context2.eventId },
-    ...context2.properties || {}
+    ...context3.userId && { user_id: context3.userId },
+    ...context3.convoId && { convo_id: context3.convoId },
+    ...context3.eventId && { event_id: context3.eventId },
+    ...context3.properties || {}
   };
-  if (context2.attachments && context2.attachments.length > 0) {
-    properties.attachments = JSON.stringify(context2.attachments);
+  if (context3.attachments && context3.attachments.length > 0) {
+    properties.attachments = JSON.stringify(context3.attachments);
   }
   return properties;
 }
@@ -62,11 +489,12 @@ var LiveToolSpan = class {
   }
 };
 var LiveInteraction = class {
-  constructor(context2, traceId, analytics) {
-    this.context = context2;
+  constructor(context3, traceId, analytics, directShipper) {
+    this.context = context3;
     this.analytics = analytics;
-    this.tracer = trace.getTracer("traceloop.tracer");
+    this.tracer = trace2.getTracer("traceloop.tracer");
     this.traceId = traceId;
+    this.directShipper = directShipper;
   }
   async withSpan(params, fn, thisArg, ...args) {
     var _a;
@@ -101,10 +529,54 @@ var LiveInteraction = class {
       ...getPropertiesFromContext(this.context),
       ...params.properties || {}
     };
-    const inputParams = params.inputParameters ? [params.inputParameters] : void 0;
     if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
       console.log("[raindrop] using withTool in liveInteraction");
     }
+    if (this.directShipper) {
+      const { traceIdB64, parentSpanIdB64 } = getActiveTraceContext();
+      const startTimeMs = Date.now();
+      let result;
+      let error;
+      try {
+        result = await fn.apply(thisArg, args);
+      } catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        const endTimeMs2 = Date.now();
+        const durationMs2 = endTimeMs2 - startTimeMs;
+        const inputStr2 = params.inputParameters ? JSON.stringify(params.inputParameters) : void 0;
+        this.directShipper.sendToolSpan({
+          name: toolName,
+          input: inputStr2,
+          output: void 0,
+          durationMs: durationMs2,
+          startTimeMs,
+          endTimeMs: endTimeMs2,
+          error,
+          properties,
+          traceId: traceIdB64,
+          parentSpanId: parentSpanIdB64
+        });
+        throw err;
+      }
+      const endTimeMs = Date.now();
+      const durationMs = endTimeMs - startTimeMs;
+      const inputStr = params.inputParameters ? JSON.stringify(params.inputParameters) : void 0;
+      const outputStr = result !== void 0 ? typeof result === "string" ? result : JSON.stringify(result) : void 0;
+      this.directShipper.sendToolSpan({
+        name: toolName,
+        input: inputStr,
+        output: outputStr,
+        durationMs,
+        startTimeMs,
+        endTimeMs,
+        error: void 0,
+        properties,
+        traceId: traceIdB64,
+        parentSpanId: parentSpanIdB64
+      });
+      return result;
+    }
+    const inputParams = params.inputParameters ? [params.inputParameters] : void 0;
     return traceloop.withTool(
       {
         name: toolName,
@@ -210,10 +682,39 @@ var LiveInteraction = class {
     });
   }
   trackTool(params) {
-    var _a;
+    var _a, _b;
     const { name, input, output, durationMs, startTime, error, properties = {} } = params;
     const startTimeMs = startTime instanceof Date ? startTime.getTime() : typeof startTime === "number" ? startTime : Date.now() - (durationMs != null ? durationMs : 0);
     const endTimeMs = startTimeMs + (durationMs != null ? durationMs : 0);
+    if (this.directShipper) {
+      const { traceIdB64, parentSpanIdB64 } = getActiveTraceContext();
+      const inputStr = input !== void 0 ? typeof input === "string" ? input : JSON.stringify(input) : void 0;
+      const outputStr = output !== void 0 ? typeof output === "string" ? output : JSON.stringify(output) : void 0;
+      this.directShipper.sendToolSpan({
+        name,
+        input: inputStr,
+        output: outputStr,
+        durationMs,
+        startTimeMs,
+        endTimeMs,
+        error: error ? error instanceof Error ? error.message : String(error) : void 0,
+        properties: {
+          ...getPropertiesFromContext(this.context),
+          ...properties
+        },
+        traceId: traceIdB64,
+        parentSpanId: parentSpanIdB64
+      });
+      if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
+        console.log(`[raindrop] trackTool (direct): logged tool span "${name}"`, {
+          input,
+          output,
+          durationMs,
+          error: error ? String(error) : void 0
+        });
+      }
+      return;
+    }
     const span = this.tracer.startSpan(name, {
       startTime: startTimeMs
     });
@@ -240,7 +741,7 @@ var LiveInteraction = class {
       span.setStatus({ code: SpanStatusCode.OK });
     }
     span.end(endTimeMs);
-    if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
+    if ((_b = this.analytics) == null ? void 0 : _b.debugLogs) {
       console.log(`[raindrop] trackTool: logged tool span "${name}"`, {
         input,
         output,
@@ -252,12 +753,13 @@ var LiveInteraction = class {
 };
 
 // src/tracing/liveTracer.ts
-import { SpanStatusCode as SpanStatusCode2, trace as trace2 } from "@opentelemetry/api";
+import { SpanStatusCode as SpanStatusCode2, trace as trace3 } from "@opentelemetry/api";
 import * as traceloop2 from "@traceloop/node-server-sdk";
 var LiveTracer = class {
-  constructor(globalProperties) {
-    this.tracer = trace2.getTracer("traceloop.tracer");
+  constructor(globalProperties, directShipper) {
+    this.tracer = trace3.getTracer("traceloop.tracer");
     this.globalProperties = globalProperties || {};
+    this.directShipper = directShipper;
   }
   async withSpan(params, fn, thisArg, ...args) {
     const taskName = typeof params === "string" ? params : params.name;
@@ -285,6 +787,27 @@ var LiveTracer = class {
     const { name, input, output, durationMs, startTime, error, properties = {} } = params;
     const startTimeMs = startTime instanceof Date ? startTime.getTime() : typeof startTime === "number" ? startTime : Date.now() - (durationMs != null ? durationMs : 0);
     const endTimeMs = startTimeMs + (durationMs != null ? durationMs : 0);
+    if (this.directShipper) {
+      const { traceIdB64, parentSpanIdB64 } = getActiveTraceContext();
+      const inputStr = input !== void 0 ? typeof input === "string" ? input : JSON.stringify(input) : void 0;
+      const outputStr = output !== void 0 ? typeof output === "string" ? output : JSON.stringify(output) : void 0;
+      this.directShipper.sendToolSpan({
+        name,
+        input: inputStr,
+        output: outputStr,
+        durationMs,
+        startTimeMs,
+        endTimeMs,
+        error: error ? error instanceof Error ? error.message : String(error) : void 0,
+        properties: {
+          ...this.globalProperties,
+          ...properties
+        },
+        traceId: traceIdB64,
+        parentSpanId: parentSpanIdB64
+      });
+      return;
+    }
     const span = this.tracer.startSpan(name, {
       startTime: startTimeMs
     });
@@ -390,14 +913,23 @@ var activeInteractions = new WeakValueMap();
 var activeInteractionsByEventId = new WeakValueMap();
 function getCurrentTraceId() {
   var _a;
-  return (_a = trace3.getSpan(context.active())) == null ? void 0 : _a.spanContext().traceId;
+  return (_a = trace4.getSpan(context2.active())) == null ? void 0 : _a.spanContext().traceId;
 }
 var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
-  const { logLevel, useExternalOtel, tracingEnabled, disableBatching, ...otherOptions } = options;
+  const { logLevel, useExternalOtel, tracingEnabled, disableBatching, bypassOtelForTools, directEndpoint, ...otherOptions } = options;
   if (isDebug) {
     const mode = useExternalOtel ? "(external OTEL mode)" : tracingEnabled === false ? "(tracing disabled)" : "";
     console.log("[raindrop] Initializing tracing", mode);
+    if (bypassOtelForTools) {
+      console.log("[raindrop] bypassOtelForTools enabled \u2014 tool spans ship directly via HTTP");
+    }
   }
+  const directShipper = bypassOtelForTools ? new DirectTraceShipper({
+    writeKey,
+    endpoint: directEndpoint != null ? directEndpoint : apiUrl,
+    debug: isDebug,
+    enabled: tracingEnabled !== false
+  }) : void 0;
   let traceloopInitialized = false;
   try {
     if (useExternalOtel) {
@@ -522,7 +1054,8 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
       const interaction = new LiveInteraction(
         traceContext,
         traceId,
-        analytics
+        analytics,
+        directShipper
       );
       if (traceId) {
         activeInteractions.set(traceId, interaction);
@@ -542,16 +1075,17 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
           return interactionByTraceId;
         }
       }
-      const interaction = new LiveInteraction({ eventId }, traceId, analytics);
+      const interaction = new LiveInteraction({ eventId }, traceId, analytics, directShipper);
       activeInteractionsByEventId.set(eventId, interaction);
       return interaction;
     },
     tracer(globalProperties) {
-      return new LiveTracer(globalProperties);
+      return new LiveTracer(globalProperties, directShipper);
     },
     async close() {
       activeInteractions.clear();
       activeInteractionsByEventId.clear();
+      await (directShipper == null ? void 0 : directShipper.shutdown());
       if (traceloopInitialized) {
         try {
           await traceloop3.forceFlush();
@@ -563,5 +1097,6 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
 };
 
 export {
+  package_default,
   tracing
 };

package/dist/index.d.mts

@@ -620,6 +620,20 @@ interface AnalyticsConfig {
      * Defaults to true in development (NODE_ENV !== 'production').
      */
     disableBatching?: boolean;
+    /**
+     * When true, all `trackTool()` and `withTool()` calls bypass the OTEL
+     * exporter pipeline and ship spans directly to the Raindrop API via HTTP POST.
+     *
+     * Spans still read the active OTEL context to inherit traceId
+     * and parentSpanId — they still appear as children in the trace tree.
+     * Only the shipping mechanism changes.
+     *
+     * This is useful when OTEL setup is fragile (e.g., conflicting providers,
+     * broken exporters) but you still want tool spans to work reliably.
+     *
+     * @default false
+     */
+    bypassOtelForTools?: boolean;
     /**
      * Explicitly specify modules to instrument. Optional.
      *