@raindrop-ai/ai-sdk 0.0.1

package/dist/chunk-A4YZKNFM.mjs

@@ -0,0 +1,2068 @@
+// src/internal/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, opName2, 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-ai/ai-sdk] ${opName2} retry ${attemptNumber}/${opts.maxAttempts} in ${delay}ms`);
+      }
+      if (delay > 0) await wait(delay);
+    } else if (opts.debug) {
+      console.log(`[raindrop-ai/ai-sdk] ${opName2} 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-ai/ai-sdk] ${opName2} 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 opName2 = `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;
+      }
+    },
+    opName2,
+    opts
+  );
+}
+
+// src/internal/events.ts
+function getRuntimeContext() {
+  const isNode = typeof process !== "undefined" && typeof process.version === "string";
+  return {
+    library: { name: "@raindrop-ai/ai-sdk", version: "0.0.1" },
+    metadata: {
+      jsRuntime: isNode ? "node" : "web",
+      ...isNode ? { nodeVersion: process.version } : {}
+    }
+  };
+}
+function mergePatches(target, source) {
+  var _a, _b, _c, _d;
+  const out = { ...target, ...source };
+  if (target.properties || source.properties) {
+    out.properties = { ...(_a = target.properties) != null ? _a : {}, ...(_b = source.properties) != null ? _b : {} };
+  }
+  if (target.attachments || source.attachments) {
+    out.attachments = [...(_c = target.attachments) != null ? _c : [], ...(_d = source.attachments) != null ? _d : []];
+  }
+  return out;
+}
+var EventShipper = class {
+  constructor(opts) {
+    this.buffers = /* @__PURE__ */ new Map();
+    this.sticky = /* @__PURE__ */ new Map();
+    this.timers = /* @__PURE__ */ new Map();
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b;
+    if (!opts.writeKey) throw new Error("[raindrop-ai/ai-sdk] writeKey is required");
+    this.writeKey = opts.writeKey;
+    this.baseUrl = (_a = formatEndpoint(opts.endpoint)) != null ? _a : "https://api.raindrop.ai/v1/";
+    this.enabled = opts.enabled;
+    this.debug = opts.debug;
+    this.partialFlushMs = (_b = opts.partialFlushMs) != null ? _b : 1e3;
+    this.context = getRuntimeContext();
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  async patch(eventId, patch) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    if (!this.enabled) return;
+    if (!eventId) return;
+    const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
+    const existing = (_b = this.buffers.get(eventId)) != null ? _b : {};
+    const merged = mergePatches(existing, patch);
+    merged.isPending = (_e = (_d = (_c = patch.isPending) != null ? _c : existing.isPending) != null ? _d : sticky.isPending) != null ? _e : true;
+    this.buffers.set(eventId, merged);
+    this.sticky.set(eventId, {
+      userId: (_f = merged.userId) != null ? _f : sticky.userId,
+      convoId: (_g = merged.convoId) != null ? _g : sticky.convoId,
+      eventName: (_h = merged.eventName) != null ? _h : sticky.eventName,
+      isPending: (_i = merged.isPending) != null ? _i : sticky.isPending
+    });
+    const t = this.timers.get(eventId);
+    if (t) clearTimeout(t);
+    if (merged.isPending === false) {
+      await this.flushOne(eventId);
+      return;
+    }
+    const timeout = setTimeout(() => {
+      void this.flushOne(eventId).catch(() => {
+      });
+    }, this.partialFlushMs);
+    this.timers.set(eventId, timeout);
+  }
+  async finish(eventId, patch) {
+    await this.patch(eventId, { ...patch, isPending: false });
+  }
+  async flush() {
+    if (!this.enabled) return;
+    const ids = [...this.buffers.keys()];
+    await Promise.all(ids.map((id) => this.flushOne(id)));
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+  async shutdown() {
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+    await this.flush();
+  }
+  async trackSignal(signal) {
+    var _a, _b;
+    if (!this.enabled) return;
+    const body = [
+      {
+        event_id: signal.eventId,
+        signal_name: signal.name,
+        signal_type: (_a = signal.type) != null ? _a : "default",
+        timestamp: signal.timestamp,
+        sentiment: signal.sentiment,
+        attachment_id: signal.attachmentId,
+        properties: {
+          ...(_b = signal.properties) != null ? _b : {},
+          ...signal.comment ? { comment: signal.comment } : {},
+          ...signal.after ? { after: signal.after } : {}
+        }
+      }
+    ];
+    const url = `${this.baseUrl}signals/track`;
+    try {
+      await postJson(
+        url,
+        body,
+        { Authorization: `Bearer ${this.writeKey}` },
+        { maxAttempts: 3, debug: this.debug }
+      );
+    } catch (err) {
+      if (this.debug) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[raindrop-ai/ai-sdk] failed to send signal (dropping): ${msg}`);
+      }
+    }
+  }
+  async flushOne(eventId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    if (!this.enabled) return;
+    const timer = this.timers.get(eventId);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(eventId);
+    }
+    const accumulated = this.buffers.get(eventId);
+    this.buffers.delete(eventId);
+    if (!accumulated) return;
+    const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
+    const eventName = (_c = (_b = accumulated.eventName) != null ? _b : sticky.eventName) != null ? _c : "ai_generation";
+    const userId = (_d = accumulated.userId) != null ? _d : sticky.userId;
+    if (!userId) {
+      if (this.debug) {
+        console.warn(`[raindrop-ai/ai-sdk] skipping track_partial for ${eventId}: missing userId`);
+      }
+      return;
+    }
+    const payload = {
+      event_id: eventId,
+      user_id: userId,
+      event: eventName,
+      timestamp: (_e = accumulated.timestamp) != null ? _e : (/* @__PURE__ */ new Date()).toISOString(),
+      ai_data: {
+        input: accumulated.input,
+        output: accumulated.output,
+        model: accumulated.model,
+        convo_id: (_f = accumulated.convoId) != null ? _f : sticky.convoId
+      },
+      properties: {
+        ...(_g = accumulated.properties) != null ? _g : {},
+        $context: this.context
+      },
+      attachments: accumulated.attachments,
+      is_pending: ((_i = (_h = accumulated.isPending) != null ? _h : sticky.isPending) != null ? _i : true) !== false
+    };
+    const url = `${this.baseUrl}events/track_partial`;
+    const p = postJson(
+      url,
+      payload,
+      { Authorization: `Bearer ${this.writeKey}` },
+      { maxAttempts: 3, debug: this.debug }
+    );
+    this.inFlight.add(p);
+    try {
+      try {
+        await p;
+        if (this.debug) {
+          console.log(`[raindrop-ai/ai-sdk] sent track_partial ${eventId} (${eventName})`);
+        }
+      } catch (err) {
+        if (this.debug) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.warn(`[raindrop-ai/ai-sdk] failed to send track_partial (dropping): ${msg}`);
+        }
+      }
+    } finally {
+      this.inFlight.delete(p);
+    }
+    const isPending = payload.is_pending;
+    if (!isPending) {
+      this.sticky.delete(eventId);
+    }
+  }
+};
+
+// src/internal/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 randomUUID() {
+  const cryptoObj = getCrypto();
+  if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
+    return cryptoObj.randomUUID();
+  }
+  const b = randomBytes(16);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const hex = [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+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/internal/otlp.ts
+function createSpanIds(parent) {
+  const traceId = parent ? parent.traceIdB64 : base64Encode(randomBytes(16));
+  const spanId = base64Encode(randomBytes(8));
+  return {
+    traceIdB64: traceId,
+    spanIdB64: spanId,
+    parentSpanIdB64: parent ? parent.spanIdB64 : void 0
+  };
+}
+function nowUnixNanoString() {
+  return String(Date.now() * 1e6);
+}
+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 attrDouble(key, value) {
+  if (value === void 0) return void 0;
+  if (!Number.isFinite(value)) return void 0;
+  return { key, value: { doubleValue: value } };
+}
+function attrBool(key, value) {
+  if (value === void 0) return void 0;
+  return { key, value: { boolValue: value } };
+}
+function attrStringArray(key, values) {
+  if (!values || values.length === 0) return void 0;
+  return {
+    key,
+    value: {
+      arrayValue: {
+        values: values.filter((v) => typeof v === "string").map((v) => ({ stringValue: v }))
+      }
+    }
+  };
+}
+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;
+  return span;
+}
+function buildExportTraceServiceRequest(spans) {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [
+            { key: "service.name", value: { stringValue: "raindrop.ai-sdk" } }
+          ]
+        },
+        scopeSpans: [
+          {
+            scope: { name: "raindrop.ai-sdk", version: "0.0.1" },
+            spans
+          }
+        ]
+      }
+    ]
+  };
+}
+
+// src/internal/traces.ts
+var TraceShipper = class {
+  constructor(opts) {
+    this.queue = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d;
+    if (!opts.writeKey) throw new Error("[raindrop-ai/ai-sdk] writeKey is required");
+    this.writeKey = opts.writeKey;
+    this.baseUrl = (_a = formatEndpoint(opts.endpoint)) != null ? _a : "https://api.raindrop.ai/v1/";
+    this.enabled = opts.enabled;
+    this.debug = opts.debug;
+    this.debugSpans = opts.debugSpans === true;
+    this.flushIntervalMs = (_b = opts.flushIntervalMs) != null ? _b : 1e3;
+    this.maxBatchSize = (_c = opts.maxBatchSize) != null ? _c : 50;
+    this.maxQueueSize = (_d = opts.maxQueueSize) != null ? _d : 5e3;
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  startSpan(args) {
+    var _a;
+    const ids = createSpanIds(args.parent);
+    const started = nowUnixNanoString();
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
+      // Important: omit userId to avoid backend spans->events duplication
+      attrString("ai.operationId", args.operationId)
+    ];
+    if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
+    return { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
+  }
+  endSpan(span, extra) {
+    var _a;
+    if (span.endTimeUnixNano) return;
+    span.endTimeUnixNano = nowUnixNanoString();
+    if ((_a = extra == null ? void 0 : extra.attributes) == null ? void 0 : _a.length) {
+      span.attributes.push(...extra.attributes);
+    }
+    const otlp = buildOtlpSpan({
+      ids: span.ids,
+      name: span.name,
+      startTimeUnixNano: span.startTimeUnixNano,
+      endTimeUnixNano: span.endTimeUnixNano,
+      attributes: span.attributes
+    });
+    this.enqueue(otlp);
+  }
+  enqueue(span) {
+    if (!this.enabled) return;
+    if (this.debugSpans) {
+      const short = (s) => s ? s.slice(-8) : "none";
+      console.log(
+        `[raindrop-ai/ai-sdk][span] name=${span.name} trace=${short(span.traceId)} span=${short(span.spanId)} parent=${short(
+          span.parentSpanId
+        )}`
+      );
+    }
+    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-ai/ai-sdk] sent ${batch.length} spans`);
+        } catch (err) {
+          if (this.debug) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[raindrop-ai/ai-sdk] 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/internal/spanContext.ts
+var NOOP_SPAN = {
+  traceIdB64: "",
+  spanIdB64: "",
+  eventId: "",
+  log() {
+  }
+};
+function isPromiseLike(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+var PendingAsyncLocalStorage = class {
+  constructor() {
+    this._real = null;
+    this._stack = [];
+  }
+  setReal(real) {
+    const current = this._stack.length ? this._stack[this._stack.length - 1] : void 0;
+    this._real = real;
+    if (current !== void 0 && typeof this._real.enterWith === "function") {
+      this._real.enterWith(current);
+    }
+  }
+  getStore() {
+    var _a, _b;
+    return (_b = (_a = this._real) == null ? void 0 : _a.getStore()) != null ? _b : this._stack[this._stack.length - 1];
+  }
+  run(store, callback) {
+    if (this._real) {
+      return this._real.run(store, callback);
+    }
+    this._stack.push(store);
+    try {
+      const result = callback();
+      if (isPromiseLike(result)) {
+        return result.then(
+          (value) => {
+            this._stack.pop();
+            return value;
+          },
+          (err) => {
+            this._stack.pop();
+            throw err;
+          }
+        );
+      }
+      this._stack.pop();
+      return result;
+    } catch (err) {
+      this._stack.pop();
+      throw err;
+    }
+  }
+};
+var ContextManager = class {
+};
+var RaindropContextManager = class extends ContextManager {
+  constructor() {
+    var _a;
+    super();
+    this._storage = null;
+    this._pending = null;
+    this._initPromise = null;
+    const isNode = typeof process !== "undefined" && typeof ((_a = process == null ? void 0 : process.versions) == null ? void 0 : _a.node) === "string";
+    const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+    if (Ctor) {
+      this._storage = new Ctor();
+      this._pending = null;
+      this._initPromise = null;
+      return;
+    }
+    if (isNode) {
+      this._pending = new PendingAsyncLocalStorage();
+      this._storage = this._pending;
+      this._initPromise = this._initialize();
+    } else {
+      this._storage = null;
+      this._pending = null;
+      this._initPromise = null;
+    }
+  }
+  async _initialize() {
+    try {
+      const mod = await import('async_hooks');
+      const real = new mod.AsyncLocalStorage();
+      if (this._pending) {
+        this._pending.setReal(real);
+      }
+      this._storage = real;
+    } catch (e) {
+      this._storage = null;
+    }
+  }
+  async ensureReady() {
+    if (this._initPromise) {
+      await this._initPromise;
+      this._initPromise = null;
+    }
+  }
+  isReady() {
+    return this._initPromise === null;
+  }
+  getParentSpanIds() {
+    var _a;
+    const span = (_a = this._storage) == null ? void 0 : _a.getStore();
+    if (!span || span === NOOP_SPAN) return void 0;
+    return {
+      traceIdB64: span.traceIdB64,
+      spanIdB64: span.spanIdB64,
+      eventId: span.eventId
+    };
+  }
+  runInContext(span, callback) {
+    if (!this._storage) return callback();
+    return this._storage.run(span, callback);
+  }
+  getCurrentSpan() {
+    var _a;
+    return (_a = this._storage) == null ? void 0 : _a.getStore();
+  }
+};
+var _contextManager = null;
+function getContextManager() {
+  if (!_contextManager) {
+    _contextManager = globalThis.RAINDROP_CONTEXT_MANAGER ? new globalThis.RAINDROP_CONTEXT_MANAGER() : new RaindropContextManager();
+  }
+  return _contextManager;
+}
+function currentSpan() {
+  var _a;
+  return (_a = getContextManager().getCurrentSpan()) != null ? _a : NOOP_SPAN;
+}
+function withCurrent(span, callback) {
+  return getContextManager().runInContext(span, callback);
+}
+async function getCurrentParentSpanContext() {
+  const cm = getContextManager();
+  if (cm instanceof RaindropContextManager) {
+    await cm.ensureReady();
+  }
+  return cm.getParentSpanIds();
+}
+async function runWithParentSpanContext(ctx, fn) {
+  const cm = getContextManager();
+  if (cm instanceof RaindropContextManager) {
+    await cm.ensureReady();
+  }
+  const span = {
+    traceIdB64: ctx.traceIdB64,
+    spanIdB64: ctx.spanIdB64,
+    eventId: ctx.eventId
+  };
+  return cm.runInContext(span, fn);
+}
+async function* asyncGeneratorWithCurrent(span, gen) {
+  let nextValue;
+  while (true) {
+    const result = await withCurrent(span, async () => {
+      try {
+        return await gen.next(nextValue);
+      } catch (e) {
+        return { value: void 0, done: true, error: e };
+      }
+    });
+    if ("error" in result && result.error !== void 0) {
+      throw result.error;
+    }
+    if (result.done) {
+      return result.value;
+    }
+    nextValue = yield result.value;
+  }
+}
+function isAsyncGenerator(value) {
+  return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value.next === "function";
+}
+
+// src/internal/wrap/helpers.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isModuleNamespace(obj) {
+  var _a;
+  if (!obj || typeof obj !== "object") return false;
+  const asObject = obj;
+  if (((_a = asObject.constructor) == null ? void 0 : _a.name) === "Module") return true;
+  try {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return false;
+    const descriptor = Object.getOwnPropertyDescriptor(obj, keys[0]);
+    if (!descriptor) return false;
+    const isWritable = "writable" in descriptor ? descriptor.writable : true;
+    return !descriptor.configurable && !isWritable;
+  } catch (e) {
+    return false;
+  }
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return void 0;
+  }
+}
+function safeJsonWithUint8(value) {
+  try {
+    return JSON.stringify(value, (_key, v) => {
+      if (v instanceof Uint8Array) return base64Encode(v);
+      return v;
+    });
+  } catch (e) {
+    return void 0;
+  }
+}
+function extractModelInfo(model) {
+  if (typeof model === "string") {
+    const slashIndex2 = model.indexOf("/");
+    if (slashIndex2 > 0 && slashIndex2 < model.length - 1) {
+      return {
+        provider: model.slice(0, slashIndex2),
+        modelId: model.slice(slashIndex2 + 1)
+      };
+    }
+    return { modelId: model };
+  }
+  if (!isRecord(model)) return {};
+  const provider = typeof model["provider"] === "string" ? model["provider"] : void 0;
+  let modelIdRaw;
+  if (typeof model["modelId"] === "string") {
+    modelIdRaw = model["modelId"];
+  } else if (typeof model["model"] === "string") {
+    modelIdRaw = model["model"];
+  }
+  if (!modelIdRaw) {
+    return { provider };
+  }
+  const slashIndex = modelIdRaw.indexOf("/");
+  if (!provider && slashIndex > 0 && slashIndex < modelIdRaw.length - 1) {
+    return {
+      provider: modelIdRaw.slice(0, slashIndex),
+      modelId: modelIdRaw.slice(slashIndex + 1)
+    };
+  }
+  return { provider, modelId: modelIdRaw };
+}
+function extractTextOutput(result) {
+  if (!isRecord(result)) return void 0;
+  const text = result["text"];
+  return typeof text === "string" ? text : void 0;
+}
+function extractObjectOutput(result) {
+  var _a;
+  if (!isRecord(result)) return void 0;
+  const obj = result["object"];
+  if (obj === void 0) return void 0;
+  return (_a = safeJson(obj)) != null ? _a : String(obj);
+}
+function extractUsage(result) {
+  if (!isRecord(result)) return void 0;
+  const usage = isRecord(result["totalUsage"]) ? result["totalUsage"] : result["usage"];
+  if (!isRecord(usage)) return void 0;
+  let inputTokens;
+  const inputVal = usage["inputTokens"];
+  if (typeof inputVal === "number") {
+    inputTokens = inputVal;
+  } else if (isRecord(inputVal) && typeof inputVal["total"] === "number") {
+    inputTokens = inputVal["total"];
+  } else if (typeof usage["promptTokens"] === "number") {
+    inputTokens = usage["promptTokens"];
+  }
+  let outputTokens;
+  const outputVal = usage["outputTokens"];
+  if (typeof outputVal === "number") {
+    outputTokens = outputVal;
+  } else if (isRecord(outputVal) && typeof outputVal["total"] === "number") {
+    outputTokens = outputVal["total"];
+  } else if (typeof usage["completionTokens"] === "number") {
+    outputTokens = usage["completionTokens"];
+  }
+  if (inputTokens === void 0 && outputTokens === void 0) return void 0;
+  return { inputTokens, outputTokens };
+}
+function isAgentClass(value) {
+  if (typeof value !== "function") return false;
+  const proto = value.prototype;
+  if (!isRecord(proto)) return false;
+  return typeof proto["generate"] === "function" && typeof proto["stream"] === "function";
+}
+function extractModel(result) {
+  if (!isRecord(result)) return void 0;
+  const model = result["model"];
+  return typeof model === "string" && model.length ? model : void 0;
+}
+function extractFinishReason(result) {
+  if (!isRecord(result)) return void 0;
+  if (typeof result["finishReason"] === "string") return result["finishReason"];
+  if (isRecord(result["finishReason"]) && typeof result["finishReason"]["unified"] === "string") {
+    return result["finishReason"]["unified"];
+  }
+  return void 0;
+}
+function lastUserMessageTextFromArgs(args) {
+  var _a;
+  if (!isRecord(args)) return void 0;
+  const messages = args["messages"];
+  if (!Array.isArray(messages)) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!isRecord(message) || message["role"] !== "user") continue;
+    const content = message["content"];
+    if (typeof content === "string") return content;
+    return (_a = safeJsonWithUint8(content)) != null ? _a : String(content);
+  }
+  return void 0;
+}
+function extractInputFromArgs(args) {
+  var _a;
+  if (!isRecord(args)) return void 0;
+  const prompt = args["prompt"];
+  if (typeof prompt === "string") return prompt;
+  const messages = args["messages"];
+  if (Array.isArray(messages) && messages.length > 0) {
+    const last = messages[messages.length - 1];
+    if (isRecord(last)) {
+      const content = last["content"];
+      if (typeof content === "string") return content;
+      const asJson = safeJson(content);
+      if (asJson) return asJson;
+    }
+    return (_a = safeJson(messages)) != null ? _a : void 0;
+  }
+  const input = args["input"];
+  if (typeof input === "string") return input;
+  return safeJson(args);
+}
+function coerceMessagesFromArgs(args) {
+  if (!isRecord(args)) return [];
+  const result = [];
+  if (typeof args["system"] === "string" && args["system"]) {
+    result.push({ role: "system", content: args["system"] });
+  }
+  const messages = args["messages"];
+  if (Array.isArray(messages)) {
+    for (const message of messages) {
+      if (isRecord(message) && typeof message["role"] === "string") {
+        result.push(message);
+      }
+    }
+    return result;
+  }
+  if (typeof args["prompt"] === "string" && args["prompt"]) {
+    result.push({ role: "user", content: args["prompt"] });
+  }
+  return result;
+}
+function extractResponseMessages(result) {
+  if (!isRecord(result)) return [];
+  const response = result["response"];
+  if (isRecord(response) && Array.isArray(response["messages"])) {
+    return response["messages"].filter((message) => isRecord(message) && typeof message["role"] === "string" && "content" in message).map((message) => message);
+  }
+  const steps = result["steps"];
+  if (Array.isArray(steps) && steps.length > 0) {
+    const lastStep = steps[steps.length - 1];
+    if (isRecord(lastStep) && isRecord(lastStep["response"])) {
+      const responseMessages = lastStep["response"]["messages"];
+      if (Array.isArray(responseMessages)) {
+        return responseMessages.filter((message) => isRecord(message) && typeof message["role"] === "string" && "content" in message).map((message) => message);
+      }
+    }
+  }
+  return [];
+}
+function extractTextFromLmContent(content) {
+  if (!Array.isArray(content)) return void 0;
+  let result = "";
+  for (const part of content) {
+    if (isRecord(part) && part["type"] === "text" && typeof part["text"] === "string") {
+      result += part["text"];
+    }
+  }
+  return result.length ? result : void 0;
+}
+function extractToolCallsFromLmContent(content) {
+  if (!Array.isArray(content)) return void 0;
+  const calls = [];
+  for (const part of content) {
+    if (!isRecord(part) || part["type"] !== "tool-call") continue;
+    const toolCallId = typeof part["toolCallId"] === "string" ? part["toolCallId"] : void 0;
+    const toolName = typeof part["toolName"] === "string" ? part["toolName"] : void 0;
+    if (toolCallId || toolName) {
+      calls.push({ toolCallId, toolName, input: part["input"] });
+    }
+  }
+  return calls.length ? calls : void 0;
+}
+function extractExperimentalTelemetry(args) {
+  if (!isRecord(args)) return void 0;
+  const telemetryConfig = args["experimental_telemetry"];
+  if (!isRecord(telemetryConfig)) return void 0;
+  return {
+    functionId: typeof telemetryConfig["functionId"] === "string" ? telemetryConfig["functionId"] : void 0,
+    isEnabled: typeof telemetryConfig["isEnabled"] === "boolean" ? telemetryConfig["isEnabled"] : void 0,
+    recordInputs: typeof telemetryConfig["recordInputs"] === "boolean" ? telemetryConfig["recordInputs"] : void 0,
+    recordOutputs: typeof telemetryConfig["recordOutputs"] === "boolean" ? telemetryConfig["recordOutputs"] : void 0,
+    metadata: isRecord(telemetryConfig["metadata"]) ? telemetryConfig["metadata"] : void 0
+  };
+}
+function opName(operationId, functionId) {
+  return {
+    operationName: `${operationId}${functionId ? ` ${functionId}` : ""}`,
+    resourceName: functionId
+  };
+}
+function toOtlpAttr(key, value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return attrString(key, value);
+  if (typeof value === "number") return Number.isInteger(value) ? attrInt(key, value) : attrDouble(key, value);
+  if (typeof value === "boolean") return attrBool(key, value);
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) return attrStringArray(key, value);
+  const asJson = safeJsonWithUint8(value);
+  return asJson ? attrString(key, asJson) : void 0;
+}
+function attrsFromTelemetryMetadata(metadata) {
+  if (!metadata) return [];
+  return Object.entries(metadata).map(([k, v]) => {
+    const key = k === "raindrop.userId" ? "raindrop.ai.userId" : k;
+    return toOtlpAttr(`ai.telemetry.metadata.${key}`, v);
+  });
+}
+function attrsFromHeaders(headers) {
+  if (!isRecord(headers)) return [];
+  return Object.entries(headers).filter(([, v]) => typeof v === "string").map(([k, v]) => attrString(`ai.request.headers.${k}`, v));
+}
+function attrsFromSettings(args) {
+  if (!isRecord(args)) return [];
+  const result = [];
+  const settingKeys = [
+    "maxRetries",
+    "timeout",
+    "maxOutputTokens",
+    "temperature",
+    "topP",
+    "topK",
+    "presencePenalty",
+    "frequencyPenalty",
+    "seed",
+    "stopSequences"
+  ];
+  for (const key of settingKeys) {
+    if (!(key in args)) continue;
+    const value = args[key];
+    if (key === "stopSequences" && Array.isArray(value) && value.every((item) => typeof item === "string")) {
+      result.push(attrStringArray(`ai.settings.${key}`, value));
+    } else if (key === "timeout" && typeof value === "number") {
+      result.push(attrInt(`ai.settings.${key}`, value));
+    } else {
+      result.push(toOtlpAttr(`ai.settings.${key}`, value));
+    }
+  }
+  return result;
+}
+function attrsFromGenAiRequest(options) {
+  if (!isRecord(options)) return [];
+  return [
+    attrDouble("gen_ai.request.frequency_penalty", typeof options["frequencyPenalty"] === "number" ? options["frequencyPenalty"] : void 0),
+    attrInt("gen_ai.request.max_tokens", typeof options["maxOutputTokens"] === "number" ? options["maxOutputTokens"] : void 0),
+    attrDouble("gen_ai.request.presence_penalty", typeof options["presencePenalty"] === "number" ? options["presencePenalty"] : void 0),
+    ...Array.isArray(options["stopSequences"]) && options["stopSequences"].every((x) => typeof x === "string") ? [attrStringArray("gen_ai.request.stop_sequences", options["stopSequences"])] : [],
+    attrDouble("gen_ai.request.temperature", typeof options["temperature"] === "number" ? options["temperature"] : void 0),
+    attrInt("gen_ai.request.top_k", typeof options["topK"] === "number" ? options["topK"] : void 0),
+    attrDouble("gen_ai.request.top_p", typeof options["topP"] === "number" ? options["topP"] : void 0)
+  ];
+}
+
+// src/internal/wrap/wrapAISDK.ts
+function extractRaindropMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object") return {};
+  const result = {};
+  const userId = metadata["raindrop.userId"];
+  if (typeof userId === "string" && userId) result.userId = userId;
+  const eventId = metadata["raindrop.eventId"];
+  if (typeof eventId === "string" && eventId) result.eventId = eventId;
+  const convoId = metadata["raindrop.convoId"];
+  if (typeof convoId === "string" && convoId) result.convoId = convoId;
+  const eventName = metadata["raindrop.eventName"];
+  if (typeof eventName === "string" && eventName) result.eventName = eventName;
+  const properties = metadata["raindrop.properties"];
+  if (typeof properties === "string") {
+    try {
+      result.properties = JSON.parse(properties);
+    } catch (e) {
+    }
+  } else if (properties && typeof properties === "object") {
+    result.properties = properties;
+  }
+  return result;
+}
+function mergeContexts(wrapTime, callTime) {
+  const result = { ...wrapTime };
+  if (callTime.userId) result.userId = callTime.userId;
+  if (callTime.eventId) result.eventId = callTime.eventId;
+  if (callTime.convoId) result.convoId = callTime.convoId;
+  if (callTime.eventName) result.eventName = callTime.eventName;
+  if (callTime.properties) {
+    result.properties = {
+      ...wrapTime.properties,
+      ...callTime.properties
+    };
+  }
+  return result;
+}
+function wrapAISDK(aiSDK, deps) {
+  var _a, _b;
+  const debug = deps.eventShipper.isDebugEnabled() || deps.traceShipper.isDebugEnabled();
+  const instrumentedOps = /* @__PURE__ */ new Set(["generateText", "streamText", "generateObject", "streamObject"]);
+  const agentClasses = /* @__PURE__ */ new Set(["ToolLoopAgent"]);
+  const sendEvents = ((_a = deps.options.send) == null ? void 0 : _a.events) !== false;
+  const sendTraces = ((_b = deps.options.send) == null ? void 0 : _b.traces) !== false;
+  const proxyTarget = isModuleNamespace(aiSDK) ? Object.setPrototypeOf({}, aiSDK) : aiSDK;
+  return new Proxy(proxyTarget, {
+    get(target, prop, receiver) {
+      const original = Reflect.get(target, prop, receiver);
+      if (typeof prop === "string" && agentClasses.has(prop) && isAgentClass(original)) {
+        if (debug) console.log(`[raindrop-ai/ai-sdk] Wrapping Agent class: ${prop}`);
+        return wrapAgentClass(original, aiSDK, deps, debug);
+      }
+      if (typeof prop !== "string" || !instrumentedOps.has(prop) || !isFunction(original)) {
+        return original;
+      }
+      return async (...callArgs) => {
+        var _a2, _b2, _c;
+        const arg = callArgs[0];
+        const operation = prop;
+        const wrapTimeCtx = resolveContext(deps.options.context, { operation, args: arg });
+        const telemetry = extractExperimentalTelemetry(arg);
+        const callTimeCtx = extractRaindropMetadata(telemetry == null ? void 0 : telemetry.metadata);
+        const mergedCtx = mergeContexts(wrapTimeCtx, callTimeCtx);
+        const inherited = await getCurrentParentSpanContext();
+        const eventId = (_c = (_b2 = (_a2 = callTimeCtx.eventId) != null ? _a2 : mergedCtx.eventId) != null ? _b2 : inherited == null ? void 0 : inherited.eventId) != null ? _c : randomUUID();
+        const ctx = { ...mergedCtx};
+        const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
+        const outerOperationId = `ai.${operation}`;
+        const { operationName, resourceName } = opName(outerOperationId, telemetry == null ? void 0 : telemetry.functionId);
+        const modelInfoFromArgs = isRecord(arg) ? extractModelInfo(arg["model"]) : {};
+        const rootSpan = sendTraces ? deps.traceShipper.startSpan({
+          name: outerOperationId,
+          parent: inheritedParent,
+          eventId,
+          operationId: outerOperationId,
+          attributes: [
+            attrString("operation.name", operationName),
+            attrString("resource.name", resourceName),
+            attrString("ai.telemetry.functionId", telemetry == null ? void 0 : telemetry.functionId),
+            attrString("ai.model.provider", modelInfoFromArgs.provider),
+            attrString("ai.model.id", modelInfoFromArgs.modelId),
+            ...attrsFromTelemetryMetadata(telemetry == null ? void 0 : telemetry.metadata),
+            ...attrsFromHeaders(isRecord(arg) ? arg["headers"] : void 0),
+            ...attrsFromSettings(arg),
+            ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
+              attrString(
+                "ai.prompt",
+                safeJsonWithUint8({
+                  system: isRecord(arg) ? arg["system"] : void 0,
+                  prompt: isRecord(arg) ? arg["prompt"] : void 0,
+                  messages: isRecord(arg) ? arg["messages"] : void 0
+                })
+              )
+            ]
+          ]
+        }) : void 0;
+        const rootParentForChildren = rootSpan ? { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64 } : inheritedParent;
+        const wrapCtx = { eventId, telemetry, sendTraces, traceShipper: deps.traceShipper, rootParentForChildren };
+        const toolCalls = [];
+        const argWithWrappedTools = wrapTools(arg, wrapCtx, toolCalls);
+        const argWithWrappedModel = wrapModel(argWithWrappedTools, aiSDK, outerOperationId, wrapCtx);
+        const finalize = async (result, error) => {
+          var _a3, _b3, _c2;
+          const usage = extractUsage(result);
+          const model = extractModel(result);
+          const baseMessages = coerceMessagesFromArgs(arg);
+          const responseMessages = extractResponseMessages(result);
+          const allMessages = [...baseMessages, ...responseMessages];
+          const outputText = extractTextOutput(result);
+          const outputObjectJson = extractObjectOutput(result);
+          const defaultOutput = operation === "generateObject" || operation === "streamObject" ? outputObjectJson : outputText;
+          const defaultPatch = {
+            eventName: (_a3 = ctx.eventName) != null ? _a3 : operation,
+            input: (_b3 = lastUserMessageTextFromArgs(arg)) != null ? _b3 : extractInputFromArgs(arg),
+            output: defaultOutput,
+            model,
+            properties: ctx.properties,
+            attachments: ctx.attachments
+          };
+          const built = await maybeBuildEvent(deps.options.buildEvent, allMessages);
+          const patch = mergeBuildEventPatch(defaultPatch, built);
+          const output = patch.output;
+          const finalModel = (_c2 = patch.model) != null ? _c2 : model;
+          if (rootSpan) {
+            const finishReason = extractFinishReason(result);
+            const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
+            const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
+            const usageRec = isRecord(result) && isRecord(result["usage"]) ? result["usage"] : void 0;
+            const totalTokens = typeof (usageRec == null ? void 0 : usageRec["totalTokens"]) === "number" ? usageRec["totalTokens"] : void 0;
+            const reasoningTokens = typeof (usageRec == null ? void 0 : usageRec["reasoningTokens"]) === "number" ? usageRec["reasoningTokens"] : void 0;
+            const cachedInputTokens = typeof (usageRec == null ? void 0 : usageRec["cachedInputTokens"]) === "number" ? usageRec["cachedInputTokens"] : void 0;
+            deps.traceShipper.endSpan(rootSpan, {
+              attributes: [
+                ...(telemetry == null ? void 0 : telemetry.recordOutputs) === false ? [] : [
+                  attrString("ai.response.finishReason", finishReason),
+                  operation === "generateObject" || operation === "streamObject" ? attrString("ai.response.object", output) : attrString("ai.response.text", output),
+                  attrString("ai.response.toolCalls", resultToolCalls),
+                  attrString("ai.response.providerMetadata", safeJsonWithUint8(providerMetadata))
+                ],
+                attrInt("ai.usage.promptTokens", usage == null ? void 0 : usage.inputTokens),
+                attrInt("ai.usage.completionTokens", usage == null ? void 0 : usage.outputTokens),
+                attrInt("ai.usage.inputTokens", usage == null ? void 0 : usage.inputTokens),
+                attrInt("ai.usage.outputTokens", usage == null ? void 0 : usage.outputTokens),
+                attrInt("ai.usage.totalTokens", totalTokens),
+                attrInt("ai.usage.reasoningTokens", reasoningTokens),
+                attrInt("ai.usage.cachedInputTokens", cachedInputTokens),
+                attrInt("ai.toolCall.count", toolCalls.length),
+                ...error ? [attrString("error.message", error instanceof Error ? error.message : String(error))] : []
+              ]
+            });
+          }
+          if (sendEvents) {
+            void deps.eventShipper.patch(eventId, {
+              eventName: patch.eventName,
+              userId: ctx.userId,
+              convoId: ctx.convoId,
+              input: patch.input,
+              output,
+              model: finalModel,
+              properties: patch.properties,
+              attachments: patch.attachments,
+              isPending: false
+            }).catch((err) => {
+              if (debug) console.warn(`[raindrop-ai/ai-sdk] event patch failed: ${err instanceof Error ? err.message : err}`);
+            });
+          }
+        };
+        const callOriginal = async (...args) => {
+          return await original.call(aiSDK, ...args);
+        };
+        const runWithContext = async (fn) => {
+          if (!rootSpan) return await fn();
+          return await runWithParentSpanContext(
+            { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64, eventId },
+            fn
+          );
+        };
+        if (operation === "streamText" || operation === "streamObject") {
+          const argWithOnFinish = wrapOnFinish(argWithWrappedModel, async (result) => {
+            try {
+              await finalize(result);
+            } catch (err) {
+              if (debug) console.warn(`[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`);
+            }
+          });
+          try {
+            const result = await runWithContext(async () => {
+              const nextArgs = [...callArgs];
+              nextArgs[0] = argWithOnFinish;
+              return await callOriginal(...nextArgs);
+            });
+            if (operation === "streamObject" && result && isRecord(result)) {
+              const baseStream = result["baseStream"];
+              if (baseStream && typeof baseStream === "object" && "tee" in baseStream) {
+                try {
+                  const [consumeStream, userStream] = baseStream.tee();
+                  result["baseStream"] = userStream;
+                  consumeStream.pipeTo(new WritableStream({ write() {
+                  } })).catch(() => {
+                  });
+                } catch (e) {
+                }
+              }
+            }
+            return result;
+          } catch (error) {
+            try {
+              await finalize(void 0, error);
+            } catch (err) {
+              if (debug) console.warn(`[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`);
+            }
+            throw error;
+          }
+        }
+        try {
+          const result = await runWithContext(async () => {
+            const nextArgs = [...callArgs];
+            nextArgs[0] = argWithWrappedModel;
+            return await callOriginal(...nextArgs);
+          });
+          try {
+            await finalize(result);
+          } catch (err) {
+            if (debug) console.warn(`[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`);
+          }
+          return result;
+        } catch (error) {
+          try {
+            await finalize(void 0, error);
+          } catch (err) {
+            if (debug) console.warn(`[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`);
+          }
+          throw error;
+        }
+      };
+    }
+  });
+}
+function wrapAgentClass(AgentClass, aiSDK, deps, debug) {
+  return new Proxy(AgentClass, {
+    construct(target, args, newTarget) {
+      const instance = Reflect.construct(target, args, newTarget);
+      const agentSettings = args[0];
+      const className = (newTarget == null ? void 0 : newTarget.name) || target.name || "Agent";
+      if (debug) console.log(`[raindrop-ai/ai-sdk] Creating wrapped ${className} instance`);
+      return new Proxy(instance, {
+        get(instanceTarget, prop, instanceReceiver) {
+          const original = Reflect.get(instanceTarget, prop, instanceReceiver);
+          if (prop === "generate" && isFunction(original)) {
+            if (debug) console.log(`[raindrop-ai/ai-sdk] Wrapping ${className}.generate method`);
+            return wrapAgentGenerate(
+              original,
+              instanceTarget,
+              agentSettings,
+              className,
+              aiSDK,
+              deps,
+              debug
+            );
+          }
+          if (prop === "stream" && isFunction(original)) {
+            if (debug) console.log(`[raindrop-ai/ai-sdk] Wrapping ${className}.stream method`);
+            return wrapAgentStream(
+              original,
+              instanceTarget,
+              agentSettings,
+              className,
+              aiSDK,
+              deps,
+              debug
+            );
+          }
+          return original;
+        }
+      });
+    }
+  });
+}
+function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK, deps, debug) {
+  var _a, _b;
+  const sendEvents = ((_a = deps.options.send) == null ? void 0 : _a.events) !== false;
+  const sendTraces = ((_b = deps.options.send) == null ? void 0 : _b.traces) !== false;
+  return async (...callArgs) => {
+    var _a2, _b2, _c, _d;
+    const callParams = callArgs[0];
+    const mergedArgs = { ...agentSettings, ...callParams };
+    const operation = `${className}.generate`;
+    const wrapTimeCtx = resolveContext(deps.options.context, { operation, args: mergedArgs });
+    const telemetry = extractExperimentalTelemetry(mergedArgs);
+    const callTimeCtx = extractRaindropMetadata(telemetry == null ? void 0 : telemetry.metadata);
+    const mergedCtx = mergeContexts(wrapTimeCtx, callTimeCtx);
+    const inherited = await getCurrentParentSpanContext();
+    const eventId = (_c = (_b2 = (_a2 = callTimeCtx.eventId) != null ? _a2 : mergedCtx.eventId) != null ? _b2 : inherited == null ? void 0 : inherited.eventId) != null ? _c : randomUUID();
+    const ctx = { ...mergedCtx};
+    const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
+    const outerOperationId = `ai.${operation}`;
+    const { operationName, resourceName } = opName(outerOperationId, telemetry == null ? void 0 : telemetry.functionId);
+    const modelInfoFromArgs = extractModelInfo(mergedArgs["model"]);
+    const rootSpan = sendTraces ? deps.traceShipper.startSpan({
+      name: outerOperationId,
+      parent: inheritedParent,
+      eventId,
+      operationId: outerOperationId,
+      attributes: [
+        attrString("operation.name", operationName),
+        attrString("resource.name", resourceName),
+        attrString("ai.telemetry.functionId", telemetry == null ? void 0 : telemetry.functionId),
+        attrString("ai.model.provider", modelInfoFromArgs.provider),
+        attrString("ai.model.id", modelInfoFromArgs.modelId),
+        ...attrsFromTelemetryMetadata(telemetry == null ? void 0 : telemetry.metadata),
+        ...attrsFromHeaders(mergedArgs["headers"]),
+        ...attrsFromSettings(mergedArgs),
+        ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
+          attrString(
+            "ai.prompt",
+            safeJsonWithUint8({
+              system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"],
+              prompt: mergedArgs["prompt"],
+              messages: mergedArgs["messages"]
+            })
+          )
+        ]
+      ]
+    }) : void 0;
+    const rootParentForChildren = rootSpan ? { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64 } : inheritedParent;
+    const wrapCtx = { eventId, telemetry, sendTraces, traceShipper: deps.traceShipper, rootParentForChildren };
+    const toolCalls = [];
+    const callParamsWithWrappedTools = callParams ? wrapTools(callParams, wrapCtx, toolCalls) : callParams;
+    const finalize = async (result, error) => {
+      var _a3, _b3, _c2;
+      const usage = extractUsage(result);
+      const model = extractModel(result);
+      const baseMessages = coerceMessagesFromArgs(mergedArgs);
+      const responseMessages = extractResponseMessages(result);
+      const allMessages = [...baseMessages, ...responseMessages];
+      const outputText = extractTextOutput(result);
+      const defaultPatch = {
+        eventName: (_a3 = ctx.eventName) != null ? _a3 : operation,
+        input: (_b3 = lastUserMessageTextFromArgs(mergedArgs)) != null ? _b3 : extractInputFromArgs(mergedArgs),
+        output: outputText,
+        model,
+        properties: ctx.properties,
+        attachments: ctx.attachments
+      };
+      const built = await maybeBuildEvent(deps.options.buildEvent, allMessages);
+      const patch = mergeBuildEventPatch(defaultPatch, built);
+      const output = patch.output;
+      const finalModel = (_c2 = patch.model) != null ? _c2 : model;
+      if (rootSpan) {
+        const finishReason = extractFinishReason(result);
+        const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
+        const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
+        const usageRec = isRecord(result) && isRecord(result["totalUsage"]) ? result["totalUsage"] : isRecord(result) && isRecord(result["usage"]) ? result["usage"] : void 0;
+        const totalTokens = typeof (usageRec == null ? void 0 : usageRec["totalTokens"]) === "number" ? usageRec["totalTokens"] : void 0;
+        const reasoningTokens = typeof (usageRec == null ? void 0 : usageRec["reasoningTokens"]) === "number" ? usageRec["reasoningTokens"] : void 0;
+        const cachedInputTokens = typeof (usageRec == null ? void 0 : usageRec["cachedInputTokens"]) === "number" ? usageRec["cachedInputTokens"] : void 0;
+        deps.traceShipper.endSpan(rootSpan, {
+          attributes: [
+            ...(telemetry == null ? void 0 : telemetry.recordOutputs) === false ? [] : [
+              attrString("ai.response.finishReason", finishReason),
+              attrString("ai.response.text", output),
+              attrString("ai.response.toolCalls", resultToolCalls),
+              attrString("ai.response.providerMetadata", safeJsonWithUint8(providerMetadata))
+            ],
+            attrInt("ai.usage.promptTokens", usage == null ? void 0 : usage.inputTokens),
+            attrInt("ai.usage.completionTokens", usage == null ? void 0 : usage.outputTokens),
+            attrInt("ai.usage.inputTokens", usage == null ? void 0 : usage.inputTokens),
+            attrInt("ai.usage.outputTokens", usage == null ? void 0 : usage.outputTokens),
+            attrInt("ai.usage.totalTokens", totalTokens),
+            attrInt("ai.usage.reasoningTokens", reasoningTokens),
+            attrInt("ai.usage.cachedInputTokens", cachedInputTokens),
+            attrInt("ai.toolCall.count", toolCalls.length),
+            ...error ? [attrString("error.message", error instanceof Error ? error.message : String(error))] : []
+          ]
+        });
+      }
+      if (sendEvents) {
+        if (debug) {
+          console.log(`[raindrop-ai/ai-sdk] Agent ${operation} shipping event:`, {
+            eventId,
+            eventName: patch.eventName,
+            userId: ctx.userId,
+            hasOutput: !!output
+          });
+        }
+        void deps.eventShipper.patch(eventId, {
+          eventName: patch.eventName,
+          userId: ctx.userId,
+          convoId: ctx.convoId,
+          input: patch.input,
+          output,
+          model: finalModel,
+          properties: patch.properties,
+          attachments: patch.attachments,
+          isPending: false
+        }).catch((err) => {
+          if (debug) console.warn(`[raindrop-ai/ai-sdk] event patch failed: ${err instanceof Error ? err.message : err}`);
+        });
+      } else if (debug) {
+        console.log(`[raindrop-ai/ai-sdk] Agent ${operation} sendEvents=false, skipping event`);
+      }
+    };
+    const runWithContext = async (fn) => {
+      if (!rootSpan) return await fn();
+      return await runWithParentSpanContext(
+        { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64, eventId },
+        fn
+      );
+    };
+    if (debug) {
+      console.log(`[raindrop-ai/ai-sdk] Agent ${operation} starting with context:`, {
+        userId: ctx.userId,
+        eventId,
+        eventName: ctx.eventName
+      });
+    }
+    try {
+      const result = await runWithContext(async () => {
+        return await generate.call(instance, callParamsWithWrappedTools);
+      });
+      if (debug) {
+        console.log(`[raindrop-ai/ai-sdk] Agent ${operation} completed, finalizing...`);
+      }
+      try {
+        await finalize(result);
+      } catch (err) {
+        if (debug) console.warn(`[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`);
+      }
+      return result;
+    } catch (error) {
+      try {
+        await finalize(void 0, error);
+      } catch (err) {
+        if (debug) console.warn(`[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`);
+      }
+      throw error;
+    }
+  };
+}
+function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps, debug) {
+  var _a, _b;
+  const sendEvents = ((_a = deps.options.send) == null ? void 0 : _a.events) !== false;
+  const sendTraces = ((_b = deps.options.send) == null ? void 0 : _b.traces) !== false;
+  return async (...callArgs) => {
+    var _a2, _b2, _c, _d;
+    const callParams = callArgs[0];
+    const mergedArgs = { ...agentSettings, ...callParams };
+    const operation = `${className}.stream`;
+    const wrapTimeCtx = resolveContext(deps.options.context, { operation, args: mergedArgs });
+    const telemetry = extractExperimentalTelemetry(mergedArgs);
+    const callTimeCtx = extractRaindropMetadata(telemetry == null ? void 0 : telemetry.metadata);
+    const mergedCtx = mergeContexts(wrapTimeCtx, callTimeCtx);
+    const inherited = await getCurrentParentSpanContext();
+    const eventId = (_c = (_b2 = (_a2 = callTimeCtx.eventId) != null ? _a2 : mergedCtx.eventId) != null ? _b2 : inherited == null ? void 0 : inherited.eventId) != null ? _c : randomUUID();
+    const ctx = { ...mergedCtx};
+    const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
+    const outerOperationId = `ai.${operation}`;
+    const { operationName, resourceName } = opName(outerOperationId, telemetry == null ? void 0 : telemetry.functionId);
+    const modelInfoFromArgs = extractModelInfo(mergedArgs["model"]);
+    const rootSpan = sendTraces ? deps.traceShipper.startSpan({
+      name: outerOperationId,
+      parent: inheritedParent,
+      eventId,
+      operationId: outerOperationId,
+      attributes: [
+        attrString("operation.name", operationName),
+        attrString("resource.name", resourceName),
+        attrString("ai.telemetry.functionId", telemetry == null ? void 0 : telemetry.functionId),
+        attrString("ai.model.provider", modelInfoFromArgs.provider),
+        attrString("ai.model.id", modelInfoFromArgs.modelId),
+        ...attrsFromTelemetryMetadata(telemetry == null ? void 0 : telemetry.metadata),
+        ...attrsFromHeaders(mergedArgs["headers"]),
+        ...attrsFromSettings(mergedArgs),
+        ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
+          attrString(
+            "ai.prompt",
+            safeJsonWithUint8({
+              system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"],
+              prompt: mergedArgs["prompt"],
+              messages: mergedArgs["messages"]
+            })
+          )
+        ]
+      ]
+    }) : void 0;
+    const rootParentForChildren = rootSpan ? { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64 } : inheritedParent;
+    const wrapCtx = { eventId, telemetry, sendTraces, traceShipper: deps.traceShipper, rootParentForChildren };
+    const toolCalls = [];
+    const callParamsWithWrappedTools = callParams ? wrapTools(callParams, wrapCtx, toolCalls) : callParams;
+    const finalize = async (result, error) => {
+      var _a3, _b3, _c2;
+      const usage = extractUsage(result);
+      const model = extractModel(result);
+      const baseMessages = coerceMessagesFromArgs(mergedArgs);
+      const responseMessages = extractResponseMessages(result);
+      const allMessages = [...baseMessages, ...responseMessages];
+      const outputText = extractTextOutput(result);
+      const defaultPatch = {
+        eventName: (_a3 = ctx.eventName) != null ? _a3 : operation,
+        input: (_b3 = lastUserMessageTextFromArgs(mergedArgs)) != null ? _b3 : extractInputFromArgs(mergedArgs),
+        output: outputText,
+        model,
+        properties: ctx.properties,
+        attachments: ctx.attachments
+      };
+      const built = await maybeBuildEvent(deps.options.buildEvent, allMessages);
+      const patch = mergeBuildEventPatch(defaultPatch, built);
+      const output = patch.output;
+      const finalModel = (_c2 = patch.model) != null ? _c2 : model;
+      if (rootSpan) {
+        const finishReason = extractFinishReason(result);
+        const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
+        const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
+        const usageRec = isRecord(result) && isRecord(result["totalUsage"]) ? result["totalUsage"] : isRecord(result) && isRecord(result["usage"]) ? result["usage"] : void 0;
+        const totalTokens = typeof (usageRec == null ? void 0 : usageRec["totalTokens"]) === "number" ? usageRec["totalTokens"] : void 0;
+        const reasoningTokens = typeof (usageRec == null ? void 0 : usageRec["reasoningTokens"]) === "number" ? usageRec["reasoningTokens"] : void 0;
+        const cachedInputTokens = typeof (usageRec == null ? void 0 : usageRec["cachedInputTokens"]) === "number" ? usageRec["cachedInputTokens"] : void 0;
+        deps.traceShipper.endSpan(rootSpan, {
+          attributes: [
+            ...(telemetry == null ? void 0 : telemetry.recordOutputs) === false ? [] : [
+              attrString("ai.response.finishReason", finishReason),
+              attrString("ai.response.text", output),
+              attrString("ai.response.toolCalls", resultToolCalls),
+              attrString("ai.response.providerMetadata", safeJsonWithUint8(providerMetadata))
+            ],
+            attrInt("ai.usage.promptTokens", usage == null ? void 0 : usage.inputTokens),
+            attrInt("ai.usage.completionTokens", usage == null ? void 0 : usage.outputTokens),
+            attrInt("ai.usage.inputTokens", usage == null ? void 0 : usage.inputTokens),
+            attrInt("ai.usage.outputTokens", usage == null ? void 0 : usage.outputTokens),
+            attrInt("ai.usage.totalTokens", totalTokens),
+            attrInt("ai.usage.reasoningTokens", reasoningTokens),
+            attrInt("ai.usage.cachedInputTokens", cachedInputTokens),
+            attrInt("ai.toolCall.count", toolCalls.length),
+            ...error ? [attrString("error.message", error instanceof Error ? error.message : String(error))] : []
+          ]
+        });
+      }
+      if (sendEvents) {
+        if (debug) {
+          console.log(`[raindrop-ai/ai-sdk] Agent ${operation} shipping event:`, {
+            eventId,
+            eventName: patch.eventName,
+            userId: ctx.userId,
+            hasOutput: !!output
+          });
+        }
+        void deps.eventShipper.patch(eventId, {
+          eventName: patch.eventName,
+          userId: ctx.userId,
+          convoId: ctx.convoId,
+          input: patch.input,
+          output,
+          model: finalModel,
+          properties: patch.properties,
+          attachments: patch.attachments,
+          isPending: false
+        }).catch((err) => {
+          if (debug) console.warn(`[raindrop-ai/ai-sdk] event patch failed: ${err instanceof Error ? err.message : err}`);
+        });
+      } else if (debug) {
+        console.log(`[raindrop-ai/ai-sdk] Agent ${operation} sendEvents=false, skipping event`);
+      }
+    };
+    const runWithContext = async (fn) => {
+      if (!rootSpan) return await fn();
+      return await runWithParentSpanContext(
+        { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64, eventId },
+        fn
+      );
+    };
+    if (debug) {
+      console.log(`[raindrop-ai/ai-sdk] Agent ${operation} starting with context:`, {
+        userId: ctx.userId,
+        eventId,
+        eventName: ctx.eventName
+      });
+    }
+    const callParamsWithOnFinish = wrapOnFinish(callParamsWithWrappedTools != null ? callParamsWithWrappedTools : {}, async (result) => {
+      if (debug) {
+        console.log(`[raindrop-ai/ai-sdk] Agent ${operation} onFinish callback, finalizing...`);
+      }
+      try {
+        await finalize(result);
+      } catch (err) {
+        if (debug) console.warn(`[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`);
+      }
+    });
+    try {
+      const result = await runWithContext(async () => {
+        return await stream.call(instance, callParamsWithOnFinish);
+      });
+      return result;
+    } catch (error) {
+      try {
+        await finalize(void 0, error);
+      } catch (err) {
+        if (debug) console.warn(`[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`);
+      }
+      throw error;
+    }
+  };
+}
+function wrapTools(args, ctx, toolCalls) {
+  if (!isRecord(args) || !("tools" in args) || !isRecord(args["tools"])) return args;
+  const tools = args["tools"];
+  const wrapped = {};
+  for (const [name, tool] of Object.entries(tools)) {
+    wrapped[name] = wrapToolExecute(name, tool, ctx, toolCalls);
+  }
+  return { ...args, tools: wrapped };
+}
+function wrapToolExecute(name, tool, ctx, toolCalls) {
+  var _a;
+  if (!isRecord(tool) || !isFunction(tool["execute"])) return tool;
+  const originalExecute = tool["execute"];
+  const { operationName, resourceName } = opName("ai.toolCall", (_a = ctx.telemetry) == null ? void 0 : _a.functionId);
+  const createToolSpan = (toolCallId, toolArgs, parent) => {
+    var _a2, _b;
+    if (!ctx.sendTraces || !parent) return void 0;
+    return ctx.traceShipper.startSpan({
+      name: "ai.toolCall",
+      parent,
+      eventId: ctx.eventId,
+      operationId: "ai.toolCall",
+      attributes: [
+        attrString("operation.name", operationName),
+        attrString("resource.name", resourceName),
+        attrString("ai.telemetry.functionId", (_a2 = ctx.telemetry) == null ? void 0 : _a2.functionId),
+        attrString("ai.toolCall.name", name),
+        attrString("ai.toolCall.id", toolCallId),
+        ...((_b = ctx.telemetry) == null ? void 0 : _b.recordInputs) === false ? [] : [attrString("ai.toolCall.args", safeJsonWithUint8(toolArgs))]
+      ]
+    });
+  };
+  const endToolSpan = (span, result, error) => {
+    var _a2;
+    if (!span) return;
+    if (error) {
+      ctx.traceShipper.endSpan(span, {
+        attributes: [attrString("error.message", error instanceof Error ? error.message : String(error))]
+      });
+    } else {
+      ctx.traceShipper.endSpan(span, {
+        attributes: ((_a2 = ctx.telemetry) == null ? void 0 : _a2.recordOutputs) === false ? [] : [attrString("ai.toolCall.result", safeJsonWithUint8(result))]
+      });
+    }
+  };
+  const createContextSpan = (span) => ({
+    traceIdB64: span.ids.traceIdB64,
+    spanIdB64: span.ids.spanIdB64,
+    eventId: ctx.eventId
+  });
+  const wrappedExecute = (...execArgs) => {
+    const toolArgs = execArgs[0];
+    const execOptions = execArgs.length > 1 ? execArgs[1] : void 0;
+    const toolCallId = isRecord(execOptions) && typeof execOptions["toolCallId"] === "string" ? execOptions["toolCallId"] : randomUUID();
+    const result = originalExecute(...execArgs);
+    if (isAsyncGenerator(result)) {
+      return (async function* () {
+        const parentCtx = await getCurrentParentSpanContext();
+        const parent = parentCtx && parentCtx.eventId === ctx.eventId ? { traceIdB64: parentCtx.traceIdB64, spanIdB64: parentCtx.spanIdB64 } : ctx.rootParentForChildren;
+        const toolSpan = createToolSpan(toolCallId, toolArgs, parent);
+        try {
+          let lastValue;
+          const wrappedGen = toolSpan ? asyncGeneratorWithCurrent(createContextSpan(toolSpan), result) : result;
+          for await (const value of wrappedGen) {
+            lastValue = value;
+            yield value;
+          }
+          toolCalls.push({ name, args: toolArgs, result: lastValue, status: "OK" });
+          endToolSpan(toolSpan, lastValue);
+        } catch (error) {
+          toolCalls.push({ name, args: toolArgs, status: "ERROR" });
+          endToolSpan(toolSpan, void 0, error);
+          throw error;
+        }
+      })();
+    }
+    return (async () => {
+      const parentCtx = await getCurrentParentSpanContext();
+      const parent = parentCtx && parentCtx.eventId === ctx.eventId ? { traceIdB64: parentCtx.traceIdB64, spanIdB64: parentCtx.spanIdB64 } : ctx.rootParentForChildren;
+      const toolSpan = createToolSpan(toolCallId, toolArgs, parent);
+      const run = async () => {
+        try {
+          const awaitedResult = await result;
+          toolCalls.push({ name, args: toolArgs, result: awaitedResult, status: "OK" });
+          endToolSpan(toolSpan, awaitedResult);
+          return awaitedResult;
+        } catch (error) {
+          toolCalls.push({ name, args: toolArgs, status: "ERROR" });
+          endToolSpan(toolSpan, void 0, error);
+          throw error;
+        }
+      };
+      if (!toolSpan) return await run();
+      return await runWithParentSpanContext(
+        { traceIdB64: toolSpan.ids.traceIdB64, spanIdB64: toolSpan.ids.spanIdB64, eventId: ctx.eventId },
+        run
+      );
+    })();
+  };
+  return { ...tool, execute: wrappedExecute };
+}
+function wrapModel(args, aiSDK, outerOperationId, ctx) {
+  if (!isRecord(args) || !("model" in args)) return args;
+  let model = args["model"];
+  if (typeof model === "string") {
+    const maybeProvider = globalThis.AI_SDK_DEFAULT_PROVIDER;
+    const gateway = isRecord(aiSDK) ? aiSDK["gateway"] : void 0;
+    const provider = maybeProvider != null ? maybeProvider : gateway;
+    if (isRecord(provider) && isFunction(provider["languageModel"])) {
+      try {
+        model = provider["languageModel"](model);
+      } catch (e) {
+      }
+    }
+  }
+  if (!isRecord(model)) return args;
+  const modelInfo = extractModelInfo(model);
+  const doGenerateOpId = `${outerOperationId}.doGenerate`;
+  const doStreamOpId = `${outerOperationId}.doStream`;
+  const wrappedModel = new Proxy(model, {
+    get(target, prop, receiver) {
+      const original = Reflect.get(target, prop, receiver);
+      if (prop === "doGenerate" && isFunction(original)) {
+        return async (...callArgs) => {
+          const options = callArgs[0];
+          const parentCtx = await getCurrentParentSpanContext();
+          const parent = parentCtx && parentCtx.eventId === ctx.eventId ? { traceIdB64: parentCtx.traceIdB64, spanIdB64: parentCtx.spanIdB64 } : ctx.rootParentForChildren;
+          const span = ctx.sendTraces && parent ? startDoGenerateSpan(doGenerateOpId, options, modelInfo, parent, ctx) : void 0;
+          try {
+            const result = await original.apply(target, callArgs);
+            if (span) endDoGenerateSpan(span, result, modelInfo, ctx);
+            return result;
+          } catch (error) {
+            if (span) ctx.traceShipper.endSpan(span, { attributes: [attrString("error.message", error instanceof Error ? error.message : String(error))] });
+            throw error;
+          }
+        };
+      }
+      if (prop === "doStream" && isFunction(original)) {
+        return async (...callArgs) => {
+          const options = callArgs[0];
+          const parentCtx = await getCurrentParentSpanContext();
+          const parent = parentCtx && parentCtx.eventId === ctx.eventId ? { traceIdB64: parentCtx.traceIdB64, spanIdB64: parentCtx.spanIdB64 } : ctx.rootParentForChildren;
+          const span = ctx.sendTraces && parent ? startDoStreamSpan(doStreamOpId, options, modelInfo, parent, ctx) : void 0;
+          const startMs = Date.now();
+          let firstChunkMs;
+          let finishMs;
+          let finishReason;
+          let responseId;
+          let responseModelId;
+          let responseTimestampIso;
+          let providerMetadata;
+          let usage;
+          let activeText = "";
+          const toolCallsLocal = [];
+          let result;
+          try {
+            result = await original.apply(target, callArgs);
+          } catch (error) {
+            if (span)
+              ctx.traceShipper.endSpan(span, {
+                attributes: [attrString("error.message", error instanceof Error ? error.message : String(error))]
+              });
+            throw error;
+          }
+          const stream = isRecord(result) ? result["stream"] : void 0;
+          const RS = globalThis.ReadableStream;
+          if (!RS || !(stream instanceof RS)) {
+            if (span) ctx.traceShipper.endSpan(span);
+            return result;
+          }
+          const reader = stream.getReader();
+          let ended = false;
+          const endSpan = (error) => {
+            var _a;
+            if (ended || !span) return;
+            ended = true;
+            const msToFirstChunk = firstChunkMs !== void 0 ? firstChunkMs - startMs : void 0;
+            const msToFinish = finishMs !== void 0 ? finishMs - startMs : void 0;
+            const inputTokens = extractNestedTokens(usage, "inputTokens");
+            const outputTokens = extractNestedTokens(usage, "outputTokens");
+            const avgOutTokensPerSecond = msToFinish && outputTokens !== void 0 && msToFinish > 0 ? 1e3 * outputTokens / msToFinish : void 0;
+            ctx.traceShipper.endSpan(span, {
+              attributes: [
+                ...((_a = ctx.telemetry) == null ? void 0 : _a.recordOutputs) === false ? [] : [
+                  attrString("ai.response.finishReason", finishReason),
+                  attrString("ai.response.text", activeText.length ? activeText : void 0),
+                  attrString("ai.response.toolCalls", safeJsonWithUint8(toolCallsLocal.length ? toolCallsLocal : void 0)),
+                  attrString("ai.response.id", responseId),
+                  attrString("ai.response.model", responseModelId),
+                  attrString("ai.response.timestamp", responseTimestampIso),
+                  attrString("ai.response.providerMetadata", safeJsonWithUint8(providerMetadata))
+                ],
+                attrInt("ai.usage.inputTokens", inputTokens),
+                attrInt("ai.usage.outputTokens", outputTokens),
+                ...finishReason ? [attrStringArray("gen_ai.response.finish_reasons", [finishReason])] : [],
+                attrString("gen_ai.response.id", responseId),
+                attrString("gen_ai.response.model", responseModelId),
+                attrInt("gen_ai.usage.input_tokens", inputTokens),
+                attrInt("gen_ai.usage.output_tokens", outputTokens),
+                ...msToFirstChunk !== void 0 ? [attrInt("ai.stream.msToFirstChunk", msToFirstChunk)] : [],
+                ...msToFinish !== void 0 ? [attrInt("ai.stream.msToFinish", msToFinish)] : [],
+                ...avgOutTokensPerSecond !== void 0 ? [attrDouble("ai.stream.avgOutputTokensPerSecond", avgOutTokensPerSecond)] : [],
+                ...error ? [attrString("error.message", error instanceof Error ? error.message : String(error))] : []
+              ]
+            });
+          };
+          const wrappedStream = new RS({
+            async pull(controller) {
+              try {
+                const { done, value } = await reader.read();
+                if (done) {
+                  finishMs = Date.now();
+                  endSpan();
+                  controller.close();
+                  return;
+                }
+                if (firstChunkMs === void 0) firstChunkMs = Date.now();
+                if (isRecord(value)) {
+                  const type = value["type"];
+                  if (type === "text-delta" && typeof value["textDelta"] === "string") activeText += value["textDelta"];
+                  if (type === "finish" && typeof value["finishReason"] === "string") finishReason = value["finishReason"];
+                  if (type === "tool-call") toolCallsLocal.push(value);
+                  if ("response" in value && isRecord(value["response"])) {
+                    const response = value["response"];
+                    if (typeof response["id"] === "string") responseId = response["id"];
+                    if (typeof response["modelId"] === "string") responseModelId = response["modelId"];
+                    if (response["timestamp"] instanceof Date) responseTimestampIso = response["timestamp"].toISOString();
+                    else if (typeof response["timestamp"] === "string") responseTimestampIso = response["timestamp"];
+                  }
+                  if ("usage" in value) usage = value["usage"];
+                  if ("providerMetadata" in value) providerMetadata = value["providerMetadata"];
+                }
+                controller.enqueue(value);
+              } catch (error) {
+                endSpan(error);
+                controller.error(error);
+              }
+            },
+            cancel(reason) {
+              void reader.cancel(reason);
+              endSpan(reason);
+            }
+          });
+          return { ...result, stream: wrappedStream };
+        };
+      }
+      return original;
+    }
+  });
+  return { ...args, model: wrappedModel };
+}
+function startDoGenerateSpan(operationId, options, modelInfo, parent, ctx) {
+  var _a, _b, _c;
+  const { operationName, resourceName } = opName(operationId, (_a = ctx.telemetry) == null ? void 0 : _a.functionId);
+  const tools = isRecord(options) ? options["tools"] : void 0;
+  const toolsJson = Array.isArray(tools) && tools.length ? tools.map((tool) => safeJsonWithUint8(tool)).filter((json) => typeof json === "string" && json.length > 0) : void 0;
+  const toolChoiceJson = isRecord(options) ? safeJsonWithUint8(options["toolChoice"]) : void 0;
+  const promptJson = isRecord(options) ? safeJsonWithUint8(options["prompt"]) : safeJsonWithUint8(options);
+  return ctx.traceShipper.startSpan({
+    name: operationId,
+    parent,
+    eventId: ctx.eventId,
+    operationId,
+    attributes: [
+      attrString("operation.name", operationName),
+      attrString("resource.name", resourceName),
+      attrString("ai.telemetry.functionId", (_b = ctx.telemetry) == null ? void 0 : _b.functionId),
+      attrString("ai.model.provider", modelInfo.provider),
+      attrString("ai.model.id", modelInfo.modelId),
+      ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [attrString("ai.prompt.messages", promptJson), attrStringArray("ai.prompt.tools", toolsJson), attrString("ai.prompt.toolChoice", toolChoiceJson)],
+      attrString("gen_ai.system", modelInfo.provider),
+      attrString("gen_ai.request.model", modelInfo.modelId),
+      ...attrsFromGenAiRequest(options)
+    ]
+  });
+}
+function endDoGenerateSpan(span, result, modelInfo, ctx) {
+  var _a;
+  const finishReason = extractFinishReason(result);
+  const content = isRecord(result) ? result["content"] : void 0;
+  const response = isRecord(result) ? result["response"] : void 0;
+  const usage = isRecord(result) ? result["usage"] : void 0;
+  const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
+  let responseId;
+  if (isRecord(response) && typeof response["id"] === "string") {
+    responseId = response["id"];
+  } else {
+    responseId = randomUUID();
+  }
+  let responseModelId;
+  if (isRecord(response) && typeof response["modelId"] === "string") {
+    responseModelId = response["modelId"];
+  } else {
+    responseModelId = modelInfo.modelId;
+  }
+  let responseTimestampIso;
+  if (isRecord(response) && response["timestamp"] instanceof Date) {
+    responseTimestampIso = response["timestamp"].toISOString();
+  } else if (isRecord(response) && typeof response["timestamp"] === "string") {
+    responseTimestampIso = response["timestamp"];
+  } else {
+    responseTimestampIso = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const inputTokens = extractNestedTokens(usage, "inputTokens");
+  const outputTokens = extractNestedTokens(usage, "outputTokens");
+  ctx.traceShipper.endSpan(span, {
+    attributes: [
+      ...((_a = ctx.telemetry) == null ? void 0 : _a.recordOutputs) === false ? [] : [
+        attrString("ai.response.finishReason", finishReason),
+        attrString("ai.response.text", extractTextFromLmContent(content)),
+        attrString("ai.response.toolCalls", safeJsonWithUint8(extractToolCallsFromLmContent(content))),
+        attrString("ai.response.id", responseId),
+        attrString("ai.response.model", responseModelId),
+        attrString("ai.response.timestamp", responseTimestampIso),
+        attrString("ai.response.providerMetadata", safeJsonWithUint8(providerMetadata))
+      ],
+      attrInt("ai.usage.promptTokens", inputTokens),
+      attrInt("ai.usage.completionTokens", outputTokens),
+      ...finishReason ? [attrStringArray("gen_ai.response.finish_reasons", [finishReason])] : [],
+      attrString("gen_ai.response.id", responseId),
+      attrString("gen_ai.response.model", responseModelId),
+      attrInt("gen_ai.usage.input_tokens", inputTokens),
+      attrInt("gen_ai.usage.output_tokens", outputTokens)
+    ]
+  });
+}
+function startDoStreamSpan(operationId, options, modelInfo, parent, ctx) {
+  var _a, _b, _c;
+  const { operationName, resourceName } = opName(operationId, (_a = ctx.telemetry) == null ? void 0 : _a.functionId);
+  const tools = isRecord(options) ? options["tools"] : void 0;
+  const toolsJson = Array.isArray(tools) && tools.length ? tools.map((tool) => safeJsonWithUint8(tool)).filter((json) => typeof json === "string" && json.length > 0) : void 0;
+  const toolChoiceJson = isRecord(options) ? safeJsonWithUint8(options["toolChoice"]) : void 0;
+  const promptJson = isRecord(options) ? safeJsonWithUint8(options["prompt"]) : safeJsonWithUint8(options);
+  return ctx.traceShipper.startSpan({
+    name: operationId,
+    parent,
+    eventId: ctx.eventId,
+    operationId,
+    attributes: [
+      attrString("operation.name", operationName),
+      attrString("resource.name", resourceName),
+      attrString("ai.telemetry.functionId", (_b = ctx.telemetry) == null ? void 0 : _b.functionId),
+      attrString("ai.model.provider", modelInfo.provider),
+      attrString("ai.model.id", modelInfo.modelId),
+      ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [attrString("ai.prompt.messages", promptJson), attrStringArray("ai.prompt.tools", toolsJson), attrString("ai.prompt.toolChoice", toolChoiceJson)],
+      attrString("gen_ai.system", modelInfo.provider),
+      attrString("gen_ai.request.model", modelInfo.modelId),
+      ...attrsFromGenAiRequest(options)
+    ]
+  });
+}
+function resolveContext(context, info) {
+  return typeof context === "function" ? context(info) : context;
+}
+function wrapOnFinish(args, onFinish) {
+  if (!isRecord(args)) return args;
+  const existing = args["onFinish"];
+  if (existing === void 0) {
+    return { ...args, onFinish: async (result) => onFinish(result) };
+  }
+  if (!isFunction(existing)) return args;
+  return {
+    ...args,
+    onFinish: async (result) => {
+      try {
+        const maybePromise = existing(result);
+        if (maybePromise && typeof maybePromise.then === "function") {
+          await maybePromise;
+        }
+      } catch (e) {
+      }
+      await onFinish(result);
+    }
+  };
+}
+async function maybeBuildEvent(buildEvent, messages) {
+  if (!buildEvent) return void 0;
+  try {
+    const r = buildEvent(messages);
+    return r && typeof r === "object" ? r : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function mergeBuildEventPatch(defaults, override) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (!override) return defaults;
+  return {
+    eventName: (_a = override.eventName) != null ? _a : defaults.eventName,
+    input: (_b = override.input) != null ? _b : defaults.input,
+    output: (_c = override.output) != null ? _c : defaults.output,
+    model: (_d = override.model) != null ? _d : defaults.model,
+    properties: override.properties !== void 0 ? { ...(_e = defaults.properties) != null ? _e : {}, ...(_f = override.properties) != null ? _f : {} } : defaults.properties,
+    attachments: override.attachments !== void 0 ? [...(_g = defaults.attachments) != null ? _g : [], ...(_h = override.attachments) != null ? _h : []] : defaults.attachments
+  };
+}
+function extractNestedTokens(usage, key) {
+  if (!isRecord(usage)) return void 0;
+  const val = usage[key];
+  if (typeof val === "number") return val;
+  if (isRecord(val) && typeof val["total"] === "number") return val["total"];
+  return void 0;
+}
+
+// src/index.ts
+function eventMetadata(options) {
+  var _a;
+  const result = {};
+  result["raindrop.eventId"] = (_a = options.eventId) != null ? _a : randomUUID();
+  if (options.userId) result["raindrop.userId"] = options.userId;
+  if (options.convoId) result["raindrop.convoId"] = options.convoId;
+  if (options.eventName) result["raindrop.eventName"] = options.eventName;
+  if (options.properties) result["raindrop.properties"] = JSON.stringify(options.properties);
+  return result;
+}
+function createRaindropAISDK(opts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const eventsEnabled = ((_a = opts.events) == null ? void 0 : _a.enabled) !== false;
+  const tracesEnabled = ((_b = opts.traces) == null ? void 0 : _b.enabled) !== false;
+  const eventShipper = new EventShipper({
+    writeKey: opts.writeKey,
+    endpoint: opts.endpoint,
+    enabled: eventsEnabled,
+    debug: ((_c = opts.events) == null ? void 0 : _c.debug) === true,
+    partialFlushMs: (_d = opts.events) == null ? void 0 : _d.partialFlushMs
+  });
+  const traceShipper = new TraceShipper({
+    writeKey: opts.writeKey,
+    endpoint: opts.endpoint,
+    enabled: tracesEnabled,
+    debug: ((_e = opts.traces) == null ? void 0 : _e.debug) === true,
+    debugSpans: ((_f = opts.traces) == null ? void 0 : _f.debugSpans) === true,
+    flushIntervalMs: (_g = opts.traces) == null ? void 0 : _g.flushIntervalMs,
+    maxBatchSize: (_h = opts.traces) == null ? void 0 : _h.maxBatchSize,
+    maxQueueSize: (_i = opts.traces) == null ? void 0 : _i.maxQueueSize
+  });
+  return {
+    wrap(aiSDK, options) {
+      return wrapAISDK(aiSDK, {
+        options,
+        eventShipper,
+        traceShipper
+      });
+    },
+    events: {
+      async patch(eventId, patch) {
+        await eventShipper.patch(eventId, patch);
+      },
+      async addAttachments(eventId, attachments) {
+        await eventShipper.patch(eventId, { attachments });
+      },
+      async setProperties(eventId, properties) {
+        await eventShipper.patch(eventId, { properties });
+      },
+      async finish(eventId, patch) {
+        await eventShipper.finish(eventId, patch);
+      }
+    },
+    signals: {
+      async track(signal) {
+        await eventShipper.trackSignal(signal);
+      }
+    },
+    async flush() {
+      await Promise.all([eventShipper.flush(), traceShipper.flush()]);
+    },
+    async shutdown() {
+      await Promise.all([eventShipper.shutdown(), traceShipper.shutdown()]);
+    }
+  };
+}
+
+export { createRaindropAISDK, currentSpan, eventMetadata, getContextManager, withCurrent };