raindrop-ai 0.0.56 → 0.0.58

package/dist/chunk-PGSDYIYM.mjs

@@ -0,0 +1,219 @@
+// src/tracing/noOpSpan.ts
+import {
+  TraceFlags
+} from "@opentelemetry/api";
+var INVALID_SPAN_CONTEXT = {
+  traceId: "",
+  spanId: "",
+  traceFlags: TraceFlags.NONE,
+  isRemote: false
+};
+var NoOpSpan = class {
+  spanContext() {
+    return INVALID_SPAN_CONTEXT;
+  }
+  setAttribute(_key, _value) {
+    return this;
+  }
+  setAttributes(_attributes) {
+    return this;
+  }
+  addEvent(_name, _attributesOrStartTime, _startTime) {
+    return this;
+  }
+  addLink(_link) {
+    return this;
+  }
+  addLinks(_links) {
+    return this;
+  }
+  setStatus(_status) {
+    return this;
+  }
+  updateName(_name) {
+    return this;
+  }
+  end(_endTime) {
+  }
+  recordException(_exception, _time) {
+  }
+  isRecording() {
+    return false;
+  }
+};
+var NO_OP_SPAN = new NoOpSpan();
+
+// src/tracing/nonLiveInteraction.ts
+var NonLiveInteraction = class {
+  constructor(context, traceId, analytics) {
+    this.context = context;
+    this.analytics = analytics;
+  }
+  withSpan(_params, fn, thisArg, ...args) {
+    var _a;
+    if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
+      console.log("[raindrop] using withSpan in nonLiveInteraction");
+    }
+    try {
+      return Promise.resolve(fn.apply(thisArg, args));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  withTool(_params, fn, thisArg, ...args) {
+    var _a;
+    if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
+      console.log("[raindrop] using withTool in nonLiveInteraction");
+    }
+    try {
+      return Promise.resolve(fn.apply(thisArg, args));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  startSpan(_params) {
+    return NO_OP_SPAN;
+  }
+  setProperties(_properties) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      properties: _properties
+    });
+  }
+  setProperty(_key, _value) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      properties: {
+        [_key]: _value
+      }
+    });
+  }
+  addAttachments(_attachments) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      attachments: _attachments
+    });
+  }
+  setInput(_input) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      input: _input
+    });
+  }
+  finish(resultEvent) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      ...resultEvent,
+      eventId: this.context.eventId,
+      isPending: false
+    });
+  }
+};
+
+// src/tracing/nonLiveTracer.ts
+var NoOpTracer = class {
+  withSpan(_params, fn, thisArg, ...args) {
+    try {
+      return Promise.resolve(fn.apply(thisArg, args));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+};
+
+// src/tracing/tracer-core.ts
+var getGlobalRegistry = () => {
+  if (typeof globalThis !== "undefined") {
+    globalThis.__RAINDROP_TRACING_REGISTRY__ = globalThis.__RAINDROP_TRACING_REGISTRY__ || {
+      hasRealImplementation: false,
+      realImplementation: null
+    };
+    return globalThis.__RAINDROP_TRACING_REGISTRY__;
+  } else if (typeof window !== "undefined") {
+    window.__RAINDROP_TRACING_REGISTRY__ = window.__RAINDROP_TRACING_REGISTRY__ || {
+      hasRealImplementation: false,
+      realImplementation: null
+    };
+    return window.__RAINDROP_TRACING_REGISTRY__;
+  } else if (typeof global !== "undefined") {
+    global.__RAINDROP_TRACING_REGISTRY__ = global.__RAINDROP_TRACING_REGISTRY__ || {
+      hasRealImplementation: false,
+      realImplementation: null
+    };
+    return global.__RAINDROP_TRACING_REGISTRY__;
+  }
+  return {
+    hasRealImplementation: false,
+    realImplementation: null
+  };
+};
+var createTracing = (analytics, _apiUrl, _writeKey, _options, isDebug = false) => ({
+  createSpanProcessor(processorOptions) {
+    return {
+      forceFlush: async () => {
+      },
+      onStart: (span, parentContext) => {
+      },
+      onEnd: (span) => {
+      },
+      shutdown: async () => {
+      }
+    };
+  },
+  begin(traceContext) {
+    if (isDebug) {
+      console.log("not using traces");
+    }
+    if (!traceContext.eventId) {
+      traceContext.eventId = crypto.randomUUID();
+    }
+    analytics._trackAiPartial({
+      ...traceContext
+    });
+    return new NonLiveInteraction(
+      traceContext,
+      void 0,
+      // No traceId in stub
+      analytics
+    );
+  },
+  getActiveInteraction(eventId) {
+    return new NonLiveInteraction({ eventId }, void 0, analytics);
+  },
+  tracer(globalProperties) {
+    return new NoOpTracer();
+  },
+  async close() {
+  }
+});
+var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
+  const registry = getGlobalRegistry();
+  if (registry.hasRealImplementation && registry.realImplementation) {
+    if (isDebug) {
+      console.log("[raindrop] Using real tracing implementation");
+    }
+    return registry.realImplementation(analytics, apiUrl, writeKey, options, isDebug);
+  }
+  if (isDebug) {
+    console.log("[raindrop] Using stub implementation");
+  }
+  return createTracing(analytics, apiUrl, writeKey, options, isDebug);
+};
+var _setImplementation = (impl) => {
+  const registry = getGlobalRegistry();
+  registry.realImplementation = impl;
+  registry.hasRealImplementation = true;
+  if (typeof process !== "undefined" && process.env.RAINDROP_DEBUG === "true") {
+    console.log("[raindrop] Set real implementation in global registry");
+  }
+};
+
+export {
+  NonLiveInteraction,
+  tracing,
+  _setImplementation
+};