@raindrop-ai/ai-sdk 0.0.19-beta.4 → 0.0.20

package/dist/index.browser.mjs

@@ -0,0 +1,3948 @@
+// ../core/dist/chunk-H6VSZSLN.js
+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;
+}
+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 (value.trim() !== "" && !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) {
+  const prefix = opts.sdkName ? `[raindrop-ai/${opts.sdkName}]` : "[raindrop-ai/core]";
+  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(
+          `${prefix} ${opName2} retry ${attemptNumber}/${opts.maxAttempts} in ${delay}ms`
+        );
+      }
+      if (delay > 0) await wait(delay);
+    } else if (opts.debug) {
+      console.log(`${prefix} ${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(
+          `${prefix} ${opName2} attempt ${attemptNumber} failed: ${msg}${attemptNumber === opts.maxAttempts ? " (no more retries)" : ""}`
+        );
+      }
+      if (lastError && typeof lastError === "object" && "retryable" in lastError && !lastError.retryable)
+        break;
+      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;
+        err.retryable = resp.status === 429 || resp.status >= 500;
+        throw err;
+      }
+    },
+    opName2,
+    opts
+  );
+}
+var SpanStatusCode = {
+  ERROR: 2
+};
+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 Date.now().toString() + "000000";
+}
+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;
+  if (args.status) span.status = args.status;
+  return span;
+}
+function buildExportTraceServiceRequest(spans, serviceName = "raindrop.core", serviceVersion = "0.0.0") {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [{ key: "service.name", value: { stringValue: serviceName } }]
+        },
+        scopeSpans: [
+          {
+            scope: { name: serviceName, version: serviceVersion },
+            spans
+          }
+        ]
+      }
+    ]
+  };
+}
+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, _c, _d, _e, _f, _g;
+    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
+    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    this.enabled = opts.enabled !== false;
+    this.debug = opts.debug;
+    this.partialFlushMs = (_c = opts.partialFlushMs) != null ? _c : 1e3;
+    this.sdkName = (_d = opts.sdkName) != null ? _d : "core";
+    this.prefix = `[raindrop-ai/${this.sdkName}]`;
+    this.defaultEventName = (_e = opts.defaultEventName) != null ? _e : "ai_generation";
+    const isNode = typeof process !== "undefined" && typeof process.version === "string";
+    this.context = {
+      library: {
+        name: (_f = opts.libraryName) != null ? _f : "@raindrop-ai/core",
+        version: (_g = opts.libraryVersion) != null ? _g : "0.0.0"
+      },
+      metadata: {
+        jsRuntime: isNode ? "node" : "web",
+        ...isNode ? { nodeVersion: process.version } : {}
+      }
+    };
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  authHeaders() {
+    return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
+  }
+  async patch(eventId, patch) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    if (!this.enabled) return;
+    if (!eventId || !eventId.trim()) return;
+    if (this.debug) {
+      console.log(`${this.prefix} queue patch`, {
+        eventId,
+        userId: patch.userId,
+        convoId: patch.convoId,
+        eventName: patch.eventName,
+        hasInput: typeof patch.input === "string" && patch.input.length > 0,
+        hasOutput: typeof patch.output === "string" && patch.output.length > 0,
+        attachments: (_b = (_a = patch.attachments) == null ? void 0 : _a.length) != null ? _b : 0,
+        isPending: patch.isPending
+      });
+    }
+    const sticky = (_c = this.sticky.get(eventId)) != null ? _c : {};
+    const existing = (_d = this.buffers.get(eventId)) != null ? _d : {};
+    const merged = mergePatches(existing, patch);
+    merged.isPending = (_g = (_f = (_e = patch.isPending) != null ? _e : existing.isPending) != null ? _f : sticky.isPending) != null ? _g : true;
+    this.buffers.set(eventId, merged);
+    this.sticky.set(eventId, {
+      userId: (_h = merged.userId) != null ? _h : sticky.userId,
+      convoId: (_i = merged.convoId) != null ? _i : sticky.convoId,
+      eventName: (_j = merged.eventName) != null ? _j : sticky.eventName,
+      isPending: (_k = merged.isPending) != null ? _k : 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, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`${this.prefix} failed to send signal (dropping): ${msg}`);
+    }
+  }
+  async identify(users) {
+    if (!this.enabled) return;
+    const list = Array.isArray(users) ? users : [users];
+    const body = list.filter((user) => {
+      if (!(user == null ? void 0 : user.userId) || !user.userId.trim()) {
+        if (this.debug) {
+          console.warn(`${this.prefix} skipping identify: missing userId`);
+        }
+        return false;
+      }
+      return true;
+    }).map((user) => {
+      var _a;
+      return {
+        user_id: user.userId,
+        traits: (_a = user.traits) != null ? _a : {}
+      };
+    });
+    if (body.length === 0) return;
+    const url = `${this.baseUrl}users/identify`;
+    try {
+      await postJson(url, body, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`${this.prefix} failed to send identify (dropping): ${msg}`);
+    }
+  }
+  async flushOne(eventId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    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 : this.defaultEventName;
+    const userId = (_d = accumulated.userId) != null ? _d : sticky.userId;
+    if (!userId) {
+      if (this.debug) {
+        console.warn(`${this.prefix} skipping track_partial for ${eventId}: missing userId`);
+      }
+      this.sticky.delete(eventId);
+      return;
+    }
+    const { wizardSession, ...restProperties } = (_e = accumulated.properties) != null ? _e : {};
+    const convoId = (_f = accumulated.convoId) != null ? _f : sticky.convoId;
+    const isPending = (_h = (_g = accumulated.isPending) != null ? _g : sticky.isPending) != null ? _h : true;
+    const payload = {
+      event_id: eventId,
+      user_id: userId,
+      event: eventName,
+      timestamp: (_i = accumulated.timestamp) != null ? _i : (/* @__PURE__ */ new Date()).toISOString(),
+      ai_data: {
+        input: accumulated.input,
+        output: accumulated.output,
+        model: accumulated.model,
+        convo_id: convoId
+      },
+      properties: {
+        ...restProperties,
+        ...wizardSession ? { "raindrop.wizardSession": wizardSession } : {},
+        $context: this.context
+      },
+      attachments: accumulated.attachments,
+      is_pending: isPending
+    };
+    const url = `${this.baseUrl}events/track_partial`;
+    if (this.debug) {
+      console.log(`${this.prefix} sending track_partial`, {
+        eventId,
+        eventName,
+        userId,
+        convoId,
+        isPending,
+        inputPreview: typeof accumulated.input === "string" ? accumulated.input.slice(0, 120) : void 0,
+        outputPreview: typeof accumulated.output === "string" ? accumulated.output.slice(0, 120) : void 0,
+        attachments: (_k = (_j = accumulated.attachments) == null ? void 0 : _j.length) != null ? _k : 0,
+        attachmentKinds: (_m = (_l = accumulated.attachments) == null ? void 0 : _l.map((a) => ({
+          type: a.type,
+          role: a.role,
+          name: a.name,
+          valuePreview: a.value.slice(0, 60)
+        }))) != null ? _m : [],
+        endpoint: url
+      });
+    }
+    const p = postJson(url, payload, this.authHeaders(), {
+      maxAttempts: 3,
+      debug: this.debug,
+      sdkName: this.sdkName
+    });
+    this.inFlight.add(p);
+    try {
+      try {
+        await p;
+        if (this.debug) {
+          console.log(`${this.prefix} sent track_partial ${eventId} (${eventName})`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`${this.prefix} failed to send track_partial (dropping): ${msg}`);
+      }
+    } finally {
+      this.inFlight.delete(p);
+    }
+    if (!isPending) {
+      this.sticky.delete(eventId);
+    }
+  }
+};
+var TraceShipper = class {
+  constructor(opts) {
+    this.queue = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
+    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    this.enabled = opts.enabled !== false;
+    this.debug = opts.debug;
+    this.debugSpans = opts.debugSpans === true;
+    this.flushIntervalMs = (_c = opts.flushIntervalMs) != null ? _c : 1e3;
+    this.maxBatchSize = (_d = opts.maxBatchSize) != null ? _d : 50;
+    this.maxQueueSize = (_e = opts.maxQueueSize) != null ? _e : 5e3;
+    this.sdkName = (_f = opts.sdkName) != null ? _f : "core";
+    this.prefix = `[raindrop-ai/${this.sdkName}]`;
+    this.serviceName = (_g = opts.serviceName) != null ? _g : "raindrop.core";
+    this.serviceVersion = (_h = opts.serviceVersion) != null ? _h : "0.0.0";
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  authHeaders() {
+    return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
+  }
+  startSpan(args) {
+    var _a, _b;
+    const ids = createSpanIds(args.parent);
+    const started = (_a = args.startTimeUnixNano) != null ? _a : nowUnixNanoString();
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
+      attrString("ai.operationId", args.operationId)
+    ];
+    if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
+    return { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
+  }
+  endSpan(span, extra) {
+    var _a, _b;
+    if (span.endTimeUnixNano) return;
+    span.endTimeUnixNano = (_a = extra == null ? void 0 : extra.endTimeUnixNano) != null ? _a : nowUnixNanoString();
+    if ((_b = extra == null ? void 0 : extra.attributes) == null ? void 0 : _b.length) {
+      span.attributes.push(...extra.attributes);
+    }
+    let status = extra == null ? void 0 : extra.status;
+    if (!status && (extra == null ? void 0 : extra.error) !== void 0) {
+      const message = extra.error instanceof Error ? extra.error.message : String(extra.error);
+      status = { code: SpanStatusCode.ERROR, message };
+    }
+    const otlp = buildOtlpSpan({
+      ids: span.ids,
+      name: span.name,
+      startTimeUnixNano: span.startTimeUnixNano,
+      endTimeUnixNano: span.endTimeUnixNano,
+      attributes: span.attributes,
+      status
+    });
+    this.enqueue(otlp);
+  }
+  createSpan(args) {
+    var _a;
+    const ids = createSpanIds(args.parent);
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId)
+    ];
+    if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
+    const otlp = buildOtlpSpan({
+      ids,
+      name: args.name,
+      startTimeUnixNano: args.startTimeUnixNano,
+      endTimeUnixNano: args.endTimeUnixNano,
+      attributes: attrs,
+      status: args.status
+    });
+    this.enqueue(otlp);
+  }
+  enqueue(span) {
+    if (!this.enabled) return;
+    if (this.debugSpans) {
+      const short = (s) => s ? s.slice(-8) : "none";
+      console.log(
+        `${this.prefix}[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, this.serviceName, this.serviceVersion);
+      const url = `${this.baseUrl}traces`;
+      if (this.debug) {
+        console.log(`${this.prefix} sending traces batch`, {
+          spans: batch.length,
+          endpoint: url
+        });
+      }
+      const p = postJson(url, body, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+      this.inFlight.add(p);
+      try {
+        try {
+          await p;
+          if (this.debug) console.log(`${this.prefix} sent ${batch.length} spans`);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.warn(`${this.prefix} failed to send ${batch.length} spans: ${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(() => {
+    })));
+  }
+};
+var NOOP_SPAN = {
+  traceIdB64: "",
+  spanIdB64: "",
+  eventId: "",
+  log() {
+  }
+};
+function getAsyncLocalStorageCtor() {
+  return globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+}
+var SynchronousContextStorage = class {
+  constructor() {
+    this._stack = [];
+  }
+  isEmpty() {
+    return this._stack.length === 0;
+  }
+  getStore() {
+    return this._stack[this._stack.length - 1];
+  }
+  run(store, callback) {
+    this._stack.push(store);
+    try {
+      return callback();
+    } finally {
+      this._stack.pop();
+    }
+  }
+};
+var ContextManager = class {
+};
+var RaindropContextManager = class extends ContextManager {
+  constructor() {
+    super();
+    this._fallback = null;
+    const Ctor = getAsyncLocalStorageCtor();
+    if (Ctor) {
+      this._storage = new Ctor();
+      return;
+    }
+    this._fallback = new SynchronousContextStorage();
+    this._storage = this._fallback;
+  }
+  maybeAdoptAsyncLocalStorage() {
+    if (!this._fallback || !this._fallback.isEmpty()) return;
+    const Ctor = getAsyncLocalStorageCtor();
+    if (!Ctor) return;
+    this._storage = new Ctor();
+    this._fallback = null;
+  }
+  isReady() {
+    return true;
+  }
+  getParentSpanIds() {
+    this.maybeAdoptAsyncLocalStorage();
+    const span = this._storage.getStore();
+    if (!span || span === NOOP_SPAN) return void 0;
+    return {
+      traceIdB64: span.traceIdB64,
+      spanIdB64: span.spanIdB64,
+      eventId: span.eventId
+    };
+  }
+  runInContext(span, callback) {
+    this.maybeAdoptAsyncLocalStorage();
+    return this._storage.run(span, callback);
+  }
+  getCurrentSpan() {
+    this.maybeAdoptAsyncLocalStorage();
+    return this._storage.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() {
+  return getContextManager().getParentSpanIds();
+}
+async function runWithParentSpanContext(ctx, fn) {
+  const cm = getContextManager();
+  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;
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@raindrop-ai/ai-sdk",
+  version: "0.0.20"};
+
+// src/internal/version.ts
+var libraryName = package_default.name;
+var libraryVersion = package_default.version;
+
+// src/internal/events.ts
+var EventShipper2 = class extends EventShipper {
+  constructor(opts) {
+    var _a, _b, _c;
+    super({
+      ...opts,
+      sdkName: (_a = opts.sdkName) != null ? _a : "ai-sdk",
+      libraryName: (_b = opts.libraryName) != null ? _b : libraryName,
+      libraryVersion: (_c = opts.libraryVersion) != null ? _c : libraryVersion
+    });
+  }
+};
+
+// 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 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"];
+  if (typeof model === "string" && model.length) return model;
+  const response = result["response"];
+  if (isRecord(response)) {
+    const modelId = response["modelId"];
+    if (typeof modelId === "string" && modelId.length) return modelId;
+  }
+  return 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 bytesToBase64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  if (typeof btoa === "function") return btoa(binary);
+  return "";
+}
+function asDataUrl(value, mediaType) {
+  if (value instanceof URL) return value.toString();
+  if (typeof value === "string") {
+    if (value.startsWith("data:")) return value;
+    if (value.startsWith("http://") || value.startsWith("https://")) return value;
+    return `data:${mediaType};base64,${value}`;
+  }
+  if (value instanceof Uint8Array) {
+    const base64 = bytesToBase64(value);
+    if (!base64) return void 0;
+    return `data:${mediaType};base64,${base64}`;
+  }
+  if (value instanceof ArrayBuffer) {
+    const base64 = bytesToBase64(new Uint8Array(value));
+    if (!base64) return void 0;
+    return `data:${mediaType};base64,${base64}`;
+  }
+  return void 0;
+}
+function dataPartToAttachmentValue(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof URL) return value.toString();
+  if (value instanceof Uint8Array) return `[binary:${value.byteLength} bytes]`;
+  if (value instanceof ArrayBuffer) return `[binary:${value.byteLength} bytes]`;
+  return void 0;
+}
+function attachmentMediaType(part) {
+  if (typeof part["mediaType"] === "string") return part["mediaType"];
+  if (typeof part["mimeType"] === "string") return part["mimeType"];
+  const file = part["file"];
+  if (isRecord(file)) {
+    if (typeof file["mediaType"] === "string") return file["mediaType"];
+    if (typeof file["mimeType"] === "string") return file["mimeType"];
+  }
+  return void 0;
+}
+function attachmentName(part) {
+  if (typeof part["filename"] === "string") return part["filename"];
+  if (typeof part["name"] === "string") return part["name"];
+  const file = part["file"];
+  if (isRecord(file)) {
+    if (typeof file["filename"] === "string") return file["filename"];
+    if (typeof file["name"] === "string") return file["name"];
+  }
+  return void 0;
+}
+function attachmentData(part) {
+  if ("data" in part) return part["data"];
+  const file = part["file"];
+  if (isRecord(file)) {
+    if ("file_data" in file) return file["file_data"];
+    if ("data" in file) return file["data"];
+  }
+  return void 0;
+}
+function contentPartToAttachment(part, role) {
+  var _a, _b, _c;
+  const partType = part["type"];
+  if (typeof partType !== "string") return void 0;
+  if (partType === "image") {
+    const mediaType = (_a = attachmentMediaType(part)) != null ? _a : "image/png";
+    const value = asDataUrl(part["image"], mediaType);
+    if (!value) return void 0;
+    return { type: "image", role, value };
+  }
+  if (partType === "image_url") {
+    const imageUrlPart = part["image_url"];
+    const imageUrlValue = isRecord(imageUrlPart) ? imageUrlPart["url"] : imageUrlPart;
+    const value = asDataUrl(imageUrlValue, "image/png");
+    if (!value) return void 0;
+    return { type: "image", role, value };
+  }
+  if (partType === "file") {
+    const mediaType = attachmentMediaType(part);
+    const data = attachmentData(part);
+    const isImage = (mediaType == null ? void 0 : mediaType.startsWith("image/")) === true;
+    const value = isImage && mediaType ? asDataUrl(data, mediaType) : dataPartToAttachmentValue(data);
+    if (!value) return void 0;
+    const name = (_c = (_b = attachmentName(part)) != null ? _b : mediaType) != null ? _c : "file";
+    return { type: isImage ? "image" : "text", role, name, value };
+  }
+  return void 0;
+}
+function attachmentsFromContent(content, role) {
+  if (!Array.isArray(content)) return void 0;
+  const attachments = [];
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    const attachment = contentPartToAttachment(part, role);
+    if (attachment) attachments.push(attachment);
+  }
+  return attachments.length ? attachments : void 0;
+}
+function generatedFileToAttachment(file) {
+  var _a, _b, _c, _d;
+  const mediaType = typeof file["mediaType"] === "string" ? file["mediaType"] : typeof file["mimeType"] === "string" ? file["mimeType"] : void 0;
+  const data = (_d = (_c = (_b = (_a = file["base64Data"]) != null ? _a : file["base64"]) != null ? _b : file["uint8ArrayData"]) != null ? _c : file["uint8Array"]) != null ? _d : file["data"];
+  const isImage = (mediaType == null ? void 0 : mediaType.startsWith("image/")) === true;
+  const value = isImage && mediaType ? asDataUrl(data, mediaType) : dataPartToAttachmentValue(data);
+  if (!value) return void 0;
+  const name = typeof file["filename"] === "string" ? file["filename"] : typeof file["name"] === "string" ? file["name"] : mediaType != null ? mediaType : "file";
+  return {
+    type: isImage ? "image" : "text",
+    role: "output",
+    name,
+    value
+  };
+}
+async function outputAttachmentsFromFiles(files) {
+  let resolvedFiles = files;
+  if (resolvedFiles && (typeof resolvedFiles === "object" || typeof resolvedFiles === "function") && typeof resolvedFiles.then === "function") {
+    try {
+      resolvedFiles = await resolvedFiles;
+    } catch (e) {
+      return void 0;
+    }
+  }
+  if (!Array.isArray(resolvedFiles)) return void 0;
+  const attachments = [];
+  for (const file of resolvedFiles) {
+    if (!isRecord(file)) continue;
+    const attachment = generatedFileToAttachment(file);
+    if (attachment) attachments.push(attachment);
+  }
+  return attachments.length ? attachments : void 0;
+}
+function extractTextFromMessageContent(content) {
+  if (typeof content === "string") return 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") continue;
+    result += part["text"];
+  }
+  return result.length ? result : void 0;
+}
+function messagesFromArgs(args) {
+  const messages = args["messages"];
+  if (Array.isArray(messages)) return messages;
+  const prompt = args["prompt"];
+  if (Array.isArray(prompt)) return prompt;
+  return void 0;
+}
+function lastUserMessageFromArgs(args) {
+  const messages = messagesFromArgs(args);
+  if (!messages) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (isRecord(message) && message["role"] === "user") {
+      return message;
+    }
+  }
+  return void 0;
+}
+function extractInputAttachmentsFromArgs(args) {
+  var _a;
+  if (!isRecord(args)) return void 0;
+  return attachmentsFromContent((_a = lastUserMessageFromArgs(args)) == null ? void 0 : _a["content"], "input");
+}
+async function extractOutputAttachmentsFromResult(result) {
+  if (!isRecord(result)) return void 0;
+  const fileAttachments = await outputAttachmentsFromFiles(result["files"]);
+  if (fileAttachments == null ? void 0 : fileAttachments.length) return fileAttachments;
+  const responseMessages = extractResponseMessages(result);
+  for (let i = responseMessages.length - 1; i >= 0; i--) {
+    const message = responseMessages[i];
+    if (!isRecord(message) || message["role"] !== "assistant") continue;
+    return attachmentsFromContent(message["content"], "output");
+  }
+  return attachmentsFromContent(result["content"], "output");
+}
+function lastUserMessageTextFromArgs(args) {
+  var _a, _b;
+  if (!isRecord(args)) return void 0;
+  const content = (_a = lastUserMessageFromArgs(args)) == null ? void 0 : _a["content"];
+  if (content === void 0) return void 0;
+  const text = extractTextFromMessageContent(content);
+  if (text !== void 0) return text;
+  return (_b = safeJsonWithUint8(content)) != null ? _b : String(content);
+}
+function extractInputFromArgs(args) {
+  var _a;
+  if (!isRecord(args)) return void 0;
+  const prompt = args["prompt"];
+  if (typeof prompt === "string") return prompt;
+  const messages = messagesFromArgs(args);
+  if (Array.isArray(messages) && messages.length > 0) {
+    const last = messages[messages.length - 1];
+    if (isRecord(last)) {
+      const content = last["content"];
+      const text = extractTextFromMessageContent(content);
+      if (text !== void 0) return text;
+      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 = messagesFromArgs(args);
+  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 buildToolCallMatchKey(info) {
+  if (typeof info.toolCallId === "string" && info.toolCallId.length > 0) {
+    return `id:${info.toolCallId}`;
+  }
+  if (typeof info.toolName === "string" && info.toolName.length > 0) {
+    const inputJson = safeJsonWithUint8(info.input);
+    return inputJson !== void 0 ? `name:${info.toolName}|input:${inputJson}` : `name:${info.toolName}`;
+  }
+  return void 0;
+}
+function isTranscriptToolResultError(part, result) {
+  if (part["isError"] === true || part["type"] === "tool-error") {
+    return true;
+  }
+  if (isRecord(result) && typeof result["type"] === "string") {
+    return result["type"].startsWith("error") || result["type"] === "execution-denied";
+  }
+  return false;
+}
+function getTranscriptToolErrorMessage(result) {
+  if (typeof result === "string" && result.length > 0) {
+    return result;
+  }
+  if (isRecord(result)) {
+    if (typeof result["value"] === "string" && result["value"].length > 0) {
+      return result["value"];
+    }
+    if (typeof result["reason"] === "string" && result["reason"].length > 0) {
+      return result["reason"];
+    }
+    if (typeof result["message"] === "string" && result["message"].length > 0) {
+      return result["message"];
+    }
+  }
+  return safeJsonWithUint8(result);
+}
+function getTranscriptMessageParts(message) {
+  if (!isRecord(message)) return [];
+  const content = message["content"];
+  if (Array.isArray(content)) {
+    return content.filter(isRecord);
+  }
+  return isRecord(content) ? [content] : [];
+}
+function getTranscriptToolCallInput(part) {
+  return "input" in part ? part["input"] : "args" in part ? part["args"] : void 0;
+}
+function getTranscriptToolCallId(part) {
+  const toolCallId = part["toolCallId"];
+  return typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
+}
+function getTranscriptToolResultValue(part) {
+  if ("output" in part) return part["output"];
+  if ("result" in part) return part["result"];
+  return part["error"];
+}
+function rememberPendingTranscriptToolCallKey(pendingKeysByToolName, toolName, key) {
+  var _a;
+  if (!toolName) return;
+  const pendingKeys = (_a = pendingKeysByToolName.get(toolName)) != null ? _a : [];
+  if (pendingKeys.includes(key)) return;
+  pendingKeys.push(key);
+  pendingKeysByToolName.set(toolName, pendingKeys);
+}
+function takePendingTranscriptToolCallKey(pendingKeysByToolName, toolName) {
+  if (!toolName) return void 0;
+  const pendingKeys = pendingKeysByToolName.get(toolName);
+  if (!pendingKeys || pendingKeys.length === 0) return void 0;
+  const key = pendingKeys.shift();
+  if (key === void 0) return void 0;
+  if (pendingKeys.length === 0) {
+    pendingKeysByToolName.delete(toolName);
+  }
+  return key;
+}
+function mergeTranscriptToolCallPart(params) {
+  var _a, _b, _c, _d;
+  const { spans, pendingKeysByToolName, part } = params;
+  const toolCallId = getTranscriptToolCallId(part);
+  const toolName = typeof part["toolName"] === "string" ? part["toolName"] : void 0;
+  const input = getTranscriptToolCallInput(part);
+  const key = buildToolCallMatchKey({ toolCallId, toolName, input });
+  if (!key) return;
+  const placeholderKey = toolCallId == null ? buildToolCallMatchKey({ toolCallId: void 0, toolName, input: void 0 }) : void 0;
+  const placeholder = placeholderKey && placeholderKey !== key ? spans.get(placeholderKey) : void 0;
+  const existing = (_a = spans.get(key)) != null ? _a : placeholder;
+  spans.set(key, {
+    key,
+    toolCallId: (_b = existing == null ? void 0 : existing.toolCallId) != null ? _b : toolCallId,
+    toolName: (_c = existing == null ? void 0 : existing.toolName) != null ? _c : toolName,
+    input: (_d = existing == null ? void 0 : existing.input) != null ? _d : input,
+    result: existing == null ? void 0 : existing.result,
+    status: existing == null ? void 0 : existing.status,
+    errorMessage: existing == null ? void 0 : existing.errorMessage
+  });
+  if (placeholderKey && placeholderKey !== key) {
+    spans.delete(placeholderKey);
+  }
+  if (!toolCallId && (existing == null ? void 0 : existing.result) === void 0) {
+    rememberPendingTranscriptToolCallKey(pendingKeysByToolName, toolName, key);
+  }
+}
+function mergeTranscriptToolResultPart(params) {
+  var _a, _b, _c;
+  const { spans, pendingKeysByToolName, part } = params;
+  const toolCallId = getTranscriptToolCallId(part);
+  const toolName = typeof part["toolName"] === "string" ? part["toolName"] : void 0;
+  const result = getTranscriptToolResultValue(part);
+  const fallbackKey = buildToolCallMatchKey({ toolCallId, toolName, input: void 0 });
+  const key = toolCallId != null ? fallbackKey : (_a = takePendingTranscriptToolCallKey(pendingKeysByToolName, toolName)) != null ? _a : fallbackKey;
+  if (!key) return;
+  const existing = spans.get(key);
+  const isError = isTranscriptToolResultError(part, result);
+  spans.set(key, {
+    key,
+    toolCallId: (_b = existing == null ? void 0 : existing.toolCallId) != null ? _b : toolCallId,
+    toolName: (_c = existing == null ? void 0 : existing.toolName) != null ? _c : toolName,
+    input: existing == null ? void 0 : existing.input,
+    result,
+    status: isError ? "ERROR" : "OK",
+    errorMessage: isError ? getTranscriptToolErrorMessage(result) : void 0
+  });
+}
+function extractToolSpansFromMessages(messages) {
+  const spans = /* @__PURE__ */ new Map();
+  const pendingKeysByToolName = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const part of getTranscriptMessageParts(message)) {
+      if (part["type"] === "tool-call") {
+        mergeTranscriptToolCallPart({ spans, pendingKeysByToolName, part });
+        continue;
+      }
+      if (part["type"] === "tool-result" || part["type"] === "tool-error") {
+        mergeTranscriptToolResultPart({ spans, pendingKeysByToolName, part });
+      }
+    }
+  }
+  return [...spans.values()];
+}
+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 = getTranscriptToolCallId(part);
+    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).filter(([k]) => !k.startsWith("raindrop.internal.")).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/raindrop-telemetry-integration.ts
+var RaindropTelemetryIntegration = class {
+  constructor(opts) {
+    this.callStates = /* @__PURE__ */ new Map();
+    // ── onStart ─────────────────────────────────────────────────────────────
+    this.onStart = (event) => {
+      var _a, _b, _c, _d;
+      if (event.isEnabled !== true) return;
+      const isEmbed = event.operationId === "ai.embed" || event.operationId === "ai.embedMany";
+      const recordInputs = event.recordInputs !== false;
+      const recordOutputs = event.recordOutputs !== false;
+      const functionId = event.functionId;
+      const metadata = event.metadata;
+      const callMeta = this.extractRaindropMetadata(metadata);
+      const inherited = getContextManager().getParentSpanIds();
+      const eventIdGenerated = (metadata == null ? void 0 : metadata["raindrop.internal.eventIdGenerated"]) === "true" || (metadata == null ? void 0 : metadata["raindrop.internal.eventIdGenerated"]) === true;
+      const explicitEventId = callMeta.eventId && !eventIdGenerated ? callMeta.eventId : void 0;
+      const eventId = (_d = (_c = (_b = explicitEventId != null ? explicitEventId : (_a = this.defaultContext) == null ? void 0 : _a.eventId) != null ? _b : inherited == null ? void 0 : inherited.eventId) != null ? _c : callMeta.eventId) != null ? _d : randomUUID();
+      const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
+      const { operationName, resourceName } = opName(
+        event.operationId,
+        functionId
+      );
+      let rootSpan;
+      if (this.sendTraces) {
+        const promptAttrs = !isEmbed && recordInputs ? [
+          attrString(
+            "ai.prompt",
+            safeJsonWithUint8({
+              system: event.system,
+              prompt: event.prompt,
+              messages: event.messages
+            })
+          )
+        ] : [];
+        const embedAttrs = isEmbed && recordInputs ? event.operationId === "ai.embedMany" ? [
+          attrString(
+            "ai.values",
+            safeJsonWithUint8(event.value)
+          )
+        ] : [attrString("ai.value", safeJsonWithUint8(event.value))] : [];
+        rootSpan = this.traceShipper.startSpan({
+          name: event.operationId,
+          parent: inheritedParent,
+          eventId,
+          operationId: event.operationId,
+          attributes: [
+            attrString("operation.name", operationName),
+            attrString("resource.name", resourceName),
+            attrString("ai.telemetry.functionId", functionId),
+            attrString("ai.model.provider", event.provider),
+            attrString("ai.model.id", event.modelId),
+            // Filter out raindrop.eventId from metadata attrs since TraceShipper
+            // already sets it via the eventId arg. Without this, eventMetadata()'s
+            // auto-generated ID would duplicate and override the resolved one.
+            ...attrsFromTelemetryMetadata(
+              metadata ? Object.fromEntries(
+                Object.entries(metadata).filter(
+                  ([k]) => k !== "raindrop.eventId" && k !== "raindrop.internal.eventIdGenerated"
+                )
+              ) : void 0
+            ),
+            ...promptAttrs,
+            ...embedAttrs
+          ]
+        });
+      }
+      this.callStates.set(event.callId, {
+        operationId: event.operationId,
+        eventId,
+        rootSpan,
+        rootParent: rootSpan ? this.spanParentRef(rootSpan) : inheritedParent,
+        stepSpan: void 0,
+        stepParent: void 0,
+        toolSpans: /* @__PURE__ */ new Map(),
+        embedSpans: /* @__PURE__ */ new Map(),
+        recordInputs,
+        recordOutputs,
+        functionId,
+        metadata,
+        accumulatedText: "",
+        inputText: isEmbed ? void 0 : this.extractInputText(event),
+        toolCallCount: 0
+      });
+    };
+    // ── onStepStart ─────────────────────────────────────────────────────────
+    this.onStepStart = (event) => {
+      const state = this.getState(event.callId);
+      if (!(state == null ? void 0 : state.rootSpan) || !state.rootParent) return;
+      const isStream = state.operationId === "ai.streamText" || state.operationId === "ai.streamObject";
+      const stepOperationId = isStream ? `${state.operationId}.doStream` : `${state.operationId}.doGenerate`;
+      const { operationName, resourceName } = opName(
+        stepOperationId,
+        state.functionId
+      );
+      const inputAttrs = [];
+      if (state.recordInputs) {
+        if (event.promptMessages) {
+          inputAttrs.push(
+            attrString(
+              "ai.prompt.messages",
+              safeJsonWithUint8(event.promptMessages)
+            )
+          );
+        }
+        if (event.stepTools) {
+          inputAttrs.push(
+            attrStringArray(
+              "ai.prompt.tools",
+              event.stepTools.map((t) => JSON.stringify(t))
+            )
+          );
+        }
+        if (event.stepToolChoice != null) {
+          inputAttrs.push(
+            attrString(
+              "ai.prompt.toolChoice",
+              JSON.stringify(event.stepToolChoice)
+            )
+          );
+        }
+      }
+      const stepSpan = this.traceShipper.startSpan({
+        name: stepOperationId,
+        parent: state.rootParent,
+        eventId: state.eventId,
+        operationId: stepOperationId,
+        attributes: [
+          attrString("operation.name", operationName),
+          attrString("resource.name", resourceName),
+          attrString("ai.telemetry.functionId", state.functionId),
+          attrString("ai.model.provider", event.provider),
+          attrString("ai.model.id", event.modelId),
+          attrString("gen_ai.system", event.provider),
+          attrString("gen_ai.request.model", event.modelId),
+          ...inputAttrs
+        ]
+      });
+      state.stepSpan = stepSpan;
+      state.stepParent = this.spanParentRef(stepSpan);
+    };
+    // ── onToolCallStart ─────────────────────────────────────────────────────
+    this.onToolCallStart = (event) => {
+      const state = this.getState(event.callId);
+      if (!(state == null ? void 0 : state.stepParent)) return;
+      const { toolCall } = event;
+      const { operationName, resourceName } = opName(
+        "ai.toolCall",
+        state.functionId
+      );
+      const inputAttrs = state.recordInputs ? [attrString("ai.toolCall.args", safeJsonWithUint8(toolCall.input))] : [];
+      const toolSpan = this.traceShipper.startSpan({
+        name: "ai.toolCall",
+        parent: state.stepParent,
+        eventId: state.eventId,
+        operationId: "ai.toolCall",
+        attributes: [
+          attrString("operation.name", operationName),
+          attrString("resource.name", resourceName),
+          attrString("ai.telemetry.functionId", state.functionId),
+          attrString("ai.toolCall.name", toolCall.toolName),
+          attrString("ai.toolCall.id", toolCall.toolCallId),
+          ...inputAttrs
+        ]
+      });
+      state.toolSpans.set(toolCall.toolCallId, toolSpan);
+    };
+    // ── onToolCallFinish ────────────────────────────────────────────────────
+    this.onToolCallFinish = (event) => {
+      const state = this.getState(event.callId);
+      if (!state) return;
+      const toolSpan = state.toolSpans.get(event.toolCall.toolCallId);
+      if (!toolSpan) return;
+      state.toolCallCount += 1;
+      if (event.success) {
+        const outputAttrs = state.recordOutputs ? [attrString("ai.toolCall.result", safeJsonWithUint8(event.output))] : [];
+        this.traceShipper.endSpan(toolSpan, { attributes: outputAttrs });
+      } else {
+        this.traceShipper.endSpan(toolSpan, { error: event.error });
+      }
+      state.toolSpans.delete(event.toolCall.toolCallId);
+    };
+    // ── onChunk (streaming) ─────────────────────────────────────────────────
+    this.onChunk = (event) => {
+      var _a, _b, _c;
+      const callId = (_b = event.callId) != null ? _b : (_a = event.chunk) == null ? void 0 : _a.callId;
+      if (!callId) return;
+      const state = this.getState(callId);
+      if (!state) return;
+      const chunk = event.chunk;
+      if (!chunk || typeof chunk !== "object") return;
+      if (chunk.type === "text-delta") {
+        const delta = (_c = chunk.textDelta) != null ? _c : chunk.delta;
+        if (typeof delta === "string") {
+          state.accumulatedText += delta;
+        }
+      }
+    };
+    // ── onStepFinish ────────────────────────────────────────────────────────
+    this.onStepFinish = (event) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      const state = this.getState(event.callId);
+      if (!(state == null ? void 0 : state.stepSpan)) return;
+      const outputAttrs = [];
+      if (state.recordOutputs) {
+        outputAttrs.push(
+          attrString("ai.response.finishReason", event.finishReason),
+          attrString("ai.response.text", (_a = event.text) != null ? _a : void 0),
+          attrString("ai.response.id", (_b = event.response) == null ? void 0 : _b.id),
+          attrString("ai.response.model", (_c = event.response) == null ? void 0 : _c.modelId),
+          attrString(
+            "ai.response.timestamp",
+            ((_d = event.response) == null ? void 0 : _d.timestamp) instanceof Date ? event.response.timestamp.toISOString() : (_e = event.response) == null ? void 0 : _e.timestamp
+          ),
+          attrString(
+            "ai.response.providerMetadata",
+            event.providerMetadata ? safeJsonWithUint8(event.providerMetadata) : void 0
+          )
+        );
+        if (((_f = event.toolCalls) == null ? void 0 : _f.length) > 0) {
+          outputAttrs.push(
+            attrString(
+              "ai.response.toolCalls",
+              JSON.stringify(
+                event.toolCalls.map((tc) => ({
+                  toolCallId: tc.toolCallId,
+                  toolName: tc.toolName,
+                  input: tc.input
+                }))
+              )
+            )
+          );
+        }
+        if (((_g = event.reasoning) == null ? void 0 : _g.length) > 0) {
+          const reasoningText = event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n");
+          if (reasoningText) {
+            outputAttrs.push(attrString("ai.response.reasoning", reasoningText));
+          }
+        }
+      }
+      outputAttrs.push(
+        attrStringArray("gen_ai.response.finish_reasons", [event.finishReason]),
+        attrString("gen_ai.response.id", (_h = event.response) == null ? void 0 : _h.id),
+        attrString("gen_ai.response.model", (_i = event.response) == null ? void 0 : _i.modelId)
+      );
+      const usage = event.usage;
+      if (usage) {
+        outputAttrs.push(
+          attrInt("ai.usage.inputTokens", usage.inputTokens),
+          attrInt("ai.usage.outputTokens", usage.outputTokens),
+          attrInt("ai.usage.totalTokens", usage.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usage.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usage.cachedInputTokens),
+          attrInt("gen_ai.usage.input_tokens", usage.inputTokens),
+          attrInt("gen_ai.usage.output_tokens", usage.outputTokens)
+        );
+      }
+      this.traceShipper.endSpan(state.stepSpan, { attributes: outputAttrs });
+      state.stepSpan = void 0;
+      state.stepParent = void 0;
+    };
+    // ── onEmbedStart ────────────────────────────────────────────────────────
+    this.onEmbedStart = (event) => {
+      const state = this.getState(event.callId);
+      if (!(state == null ? void 0 : state.rootSpan) || !state.rootParent) return;
+      const { operationName, resourceName } = opName(
+        event.operationId,
+        state.functionId
+      );
+      const inputAttrs = state.recordInputs ? [
+        attrString(
+          "ai.values",
+          safeJsonWithUint8(event.values)
+        )
+      ] : [];
+      const embedSpan = this.traceShipper.startSpan({
+        name: event.operationId,
+        parent: state.rootParent,
+        eventId: state.eventId,
+        operationId: event.operationId,
+        attributes: [
+          attrString("operation.name", operationName),
+          attrString("resource.name", resourceName),
+          attrString("ai.telemetry.functionId", state.functionId),
+          ...inputAttrs
+        ]
+      });
+      state.embedSpans.set(event.embedCallId, embedSpan);
+    };
+    // ── onEmbedFinish ───────────────────────────────────────────────────────
+    this.onEmbedFinish = (event) => {
+      var _a;
+      const state = this.getState(event.callId);
+      if (!state) return;
+      const embedSpan = state.embedSpans.get(event.embedCallId);
+      if (!embedSpan) return;
+      const outputAttrs = [];
+      if (state.recordOutputs) {
+        outputAttrs.push(
+          attrString(
+            "ai.embeddings",
+            safeJsonWithUint8(event.embeddings)
+          )
+        );
+      }
+      if (((_a = event.usage) == null ? void 0 : _a.tokens) != null) {
+        outputAttrs.push(attrInt("ai.usage.tokens", event.usage.tokens));
+      }
+      this.traceShipper.endSpan(embedSpan, { attributes: outputAttrs });
+      state.embedSpans.delete(event.embedCallId);
+    };
+    // ── onFinish ────────────────────────────────────────────────────────────
+    this.onFinish = (event) => {
+      const state = this.getState(event.callId);
+      if (!state) return;
+      const isEmbed = state.operationId === "ai.embed" || state.operationId === "ai.embedMany";
+      if (isEmbed) {
+        this.finishEmbed(event, state);
+      } else {
+        this.finishGenerate(event, state);
+      }
+      this.cleanup(event.callId);
+    };
+    // ── onError ─────────────────────────────────────────────────────────────
+    this.onError = (error) => {
+      var _a;
+      const event = error;
+      if (!(event == null ? void 0 : event.callId)) return;
+      const state = this.getState(event.callId);
+      if (!state) return;
+      const actualError = (_a = event.error) != null ? _a : error;
+      if (state.stepSpan) {
+        this.traceShipper.endSpan(state.stepSpan, { error: actualError });
+      }
+      for (const embedSpan of state.embedSpans.values()) {
+        this.traceShipper.endSpan(embedSpan, { error: actualError });
+      }
+      state.embedSpans.clear();
+      for (const toolSpan of state.toolSpans.values()) {
+        this.traceShipper.endSpan(toolSpan, { error: actualError });
+      }
+      state.toolSpans.clear();
+      if (state.rootSpan) {
+        this.traceShipper.endSpan(state.rootSpan, { error: actualError });
+      }
+      this.cleanup(event.callId);
+    };
+    // ── executeTool ─────────────────────────────────────────────────────────
+    this.executeTool = async ({
+      callId,
+      toolCallId,
+      execute
+    }) => {
+      const state = this.getState(callId);
+      const toolSpan = state == null ? void 0 : state.toolSpans.get(toolCallId);
+      if (!toolSpan) return execute();
+      return runWithParentSpanContext(
+        {
+          traceIdB64: toolSpan.ids.traceIdB64,
+          spanIdB64: toolSpan.ids.spanIdB64,
+          eventId: state.eventId
+        },
+        () => execute()
+      );
+    };
+    this.traceShipper = opts.traceShipper;
+    this.eventShipper = opts.eventShipper;
+    this.sendTraces = opts.sendTraces !== false;
+    this.sendEvents = opts.sendEvents !== false;
+    this.debug = opts.debug === true;
+    this.defaultContext = opts.context;
+  }
+  // ── helpers ──────────────────────────────────────────────────────────────
+  getState(callId) {
+    return this.callStates.get(callId);
+  }
+  cleanup(callId) {
+    this.callStates.delete(callId);
+  }
+  spanParentRef(span) {
+    return { traceIdB64: span.ids.traceIdB64, spanIdB64: span.ids.spanIdB64 };
+  }
+  extractRaindropMetadata(metadata) {
+    if (!metadata) 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;
+  }
+  /**
+   * Extract the user-facing input text from an onStart event.
+   * Mirrors the logic in the v4-v6 Proxy path (lastUserMessageTextFromArgs / extractInputFromArgs).
+   */
+  extractInputText(event) {
+    if (typeof event.prompt === "string") return event.prompt;
+    if (Array.isArray(event.messages)) {
+      for (let i = event.messages.length - 1; i >= 0; i--) {
+        const msg = event.messages[i];
+        if ((msg == null ? void 0 : msg.role) === "user") {
+          if (typeof msg.content === "string") return msg.content;
+          if (Array.isArray(msg.content)) {
+            const textPart = msg.content.find(
+              (p) => (p == null ? void 0 : p.type) === "text" && typeof p.text === "string"
+            );
+            if (textPart) return textPart.text;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  finishGenerate(event, state) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    if (state.rootSpan) {
+      const outputAttrs = [];
+      if (state.recordOutputs) {
+        outputAttrs.push(
+          attrString("ai.response.finishReason", event.finishReason),
+          attrString("ai.response.text", (_a = event.text) != null ? _a : void 0),
+          attrString(
+            "ai.response.providerMetadata",
+            event.providerMetadata ? safeJsonWithUint8(event.providerMetadata) : void 0
+          )
+        );
+        if (((_b = event.toolCalls) == null ? void 0 : _b.length) > 0) {
+          outputAttrs.push(
+            attrString(
+              "ai.response.toolCalls",
+              JSON.stringify(
+                event.toolCalls.map((tc) => ({
+                  toolCallId: tc.toolCallId,
+                  toolName: tc.toolName,
+                  input: tc.input
+                }))
+              )
+            )
+          );
+        }
+        if (((_c = event.reasoning) == null ? void 0 : _c.length) > 0) {
+          const reasoningText = event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n");
+          if (reasoningText) {
+            outputAttrs.push(attrString("ai.response.reasoning", reasoningText));
+          }
+        }
+      }
+      const usage = (_d = event.totalUsage) != null ? _d : event.usage;
+      if (usage) {
+        outputAttrs.push(
+          attrInt("ai.usage.inputTokens", usage.inputTokens),
+          attrInt("ai.usage.outputTokens", usage.outputTokens),
+          attrInt("ai.usage.totalTokens", usage.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usage.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usage.cachedInputTokens)
+        );
+      }
+      outputAttrs.push(
+        attrInt("ai.toolCall.count", state.toolCallCount)
+      );
+      this.traceShipper.endSpan(state.rootSpan, { attributes: outputAttrs });
+    }
+    if (this.sendEvents) {
+      const callMeta = this.extractRaindropMetadata(state.metadata);
+      const userId = (_f = callMeta.userId) != null ? _f : (_e = this.defaultContext) == null ? void 0 : _e.userId;
+      if (userId) {
+        const eventName = (_i = (_h = callMeta.eventName) != null ? _h : (_g = this.defaultContext) == null ? void 0 : _g.eventName) != null ? _i : state.operationId;
+        const output = (_j = event.text) != null ? _j : state.accumulatedText || void 0;
+        const input = state.inputText;
+        const model = (_k = event.response) == null ? void 0 : _k.modelId;
+        const properties = {
+          ...(_l = this.defaultContext) == null ? void 0 : _l.properties,
+          ...callMeta.properties
+        };
+        const convoId = (_n = callMeta.convoId) != null ? _n : (_m = this.defaultContext) == null ? void 0 : _m.convoId;
+        void this.eventShipper.patch(state.eventId, {
+          eventName,
+          userId,
+          convoId,
+          input,
+          output,
+          model,
+          properties: Object.keys(properties).length > 0 ? properties : void 0,
+          isPending: false
+        }).catch((err) => {
+          if (this.debug) {
+            console.warn(
+              `[raindrop-ai/ai-sdk] event patch failed: ${err instanceof Error ? err.message : err}`
+            );
+          }
+        });
+      }
+    }
+  }
+  finishEmbed(event, state) {
+    var _a;
+    if (!state.rootSpan) return;
+    const outputAttrs = [];
+    const isMany = state.operationId === "ai.embedMany";
+    if (state.recordOutputs) {
+      if (isMany) {
+        outputAttrs.push(
+          attrString("ai.embeddings", safeJsonWithUint8(event.embedding))
+        );
+      } else {
+        outputAttrs.push(
+          attrString("ai.embedding", safeJsonWithUint8(event.embedding))
+        );
+      }
+    }
+    if (((_a = event.usage) == null ? void 0 : _a.tokens) != null) {
+      outputAttrs.push(attrInt("ai.usage.tokens", event.usage.tokens));
+    }
+    this.traceShipper.endSpan(state.rootSpan, { attributes: outputAttrs });
+  }
+};
+
+// src/internal/traces.ts
+var TraceShipper2 = class extends TraceShipper {
+  constructor(opts) {
+    var _a, _b, _c;
+    super({
+      ...opts,
+      sdkName: (_a = opts.sdkName) != null ? _a : "ai-sdk",
+      serviceName: (_b = opts.serviceName) != null ? _b : "raindrop.ai-sdk",
+      serviceVersion: (_c = opts.serviceVersion) != null ? _c : libraryVersion
+    });
+  }
+};
+
+// src/internal/wrap/wrapAISDK.ts
+var AGENT_REPORTING_TOOL_NAME_DEFAULT = "__raindrop_report";
+var AGENT_REPORTING_SIGNALS_DEFAULT = {
+  missing_context: {
+    description: "You cannot complete the task because critical information, credentials, or access is missing and the user cannot provide it. Do NOT report this for normal clarifying questions \u2014 only when you are blocked.",
+    sentiment: "NEGATIVE"
+  },
+  repeatedly_broken_tool: {
+    description: "A tool has failed or not returned the expected response on multiple distinct attempts in this conversation, preventing task completion. A single tool error is NOT enough \u2014 the tool must be persistently broken or aberrantly behaving across retries.",
+    sentiment: "NEGATIVE"
+  },
+  capability_gap: {
+    description: "The task requires a tool, permission, or capability that you do not have. For example, the user asks you to perform an action but no suitable tool exists, or you lack the necessary access. Do NOT report this if you simply need more information from the user \u2014 only when the gap is in your own capabilities.",
+    sentiment: "NEGATIVE"
+  },
+  complete_task_failure: {
+    description: "You were unable to accomplish what the user asked despite making genuine attempts. This might be things like, you genuinely do not have the capabilities the user is asking for. You have tried but run into a persistent bug in the environment etc. This is NOT a refusal or policy block \u2014 you tried and failed to deliver the result.",
+    sentiment: "NEGATIVE"
+  }
+};
+var AGENT_REPORTING_TOOL_PREAMBLE = "You have a diagnostic tool for flagging serious failures for developer review. Only call this when you hit a significant, unrecoverable problem \u2014 not for minor hiccups or routine clarifications. If you can still help the user, do that instead of calling this tool. This tool is invisible to the user \u2014 never mention it or its output.";
+var pendingStoresByShipper = /* @__PURE__ */ new WeakMap();
+var PendingToolSpanStore = class _PendingToolSpanStore {
+  constructor() {
+    this.spans = /* @__PURE__ */ new Map();
+  }
+  static for(traceShipper, eventId) {
+    let byEvent = pendingStoresByShipper.get(traceShipper);
+    if (!byEvent) {
+      byEvent = /* @__PURE__ */ new Map();
+      pendingStoresByShipper.set(traceShipper, byEvent);
+    }
+    let store = byEvent.get(eventId);
+    if (!store) {
+      store = new _PendingToolSpanStore();
+      byEvent.set(eventId, store);
+    }
+    return store;
+  }
+  resolve(resolvedToolSpans, ctx) {
+    for (const [key, span] of this.spans) {
+      const toolCall = resolvedToolSpans.get(key);
+      if (!toolCall) continue;
+      finishToolSpan(toolCall, span, ctx, span.startTimeUnixNano);
+      this.spans.delete(key);
+    }
+  }
+  remember(toolCall, rootSpan, ctx, startTimeUnixNano) {
+    if (this.spans.has(toolCall.key)) return;
+    this.spans.set(toolCall.key, startToolSpan(toolCall, rootSpan, ctx, startTimeUnixNano));
+  }
+  closeAll(traceShipper) {
+    for (const [, span] of this.spans) {
+      traceShipper.endSpan(span, { endTimeUnixNano: span.startTimeUnixNano });
+    }
+    this.spans.clear();
+  }
+  cleanup(traceShipper, eventId) {
+    if (this.spans.size > 0) return;
+    const byEvent = pendingStoresByShipper.get(traceShipper);
+    if (!byEvent) return;
+    byEvent.delete(eventId);
+    if (byEvent.size === 0) pendingStoresByShipper.delete(traceShipper);
+  }
+};
+var warnedMissingUserId = false;
+function warnMissingUserIdOnce() {
+  if (warnedMissingUserId) return;
+  warnedMissingUserId = true;
+  console.warn(
+    "[raindrop-ai/ai-sdk] userId was not provided in wrap() context or via eventMetadata(). Events will be skipped unless a userId is provided."
+  );
+}
+function _resetWarnedMissingUserId() {
+  warnedMissingUserId = false;
+}
+function extractRaindropCallOptions(options) {
+  if (!isRecord(options)) return {};
+  const em = options["metadata"];
+  if (isRecord(em)) return extractRaindropMetadata(em);
+  const telemetry = extractExperimentalTelemetry(options);
+  if (telemetry == null ? void 0 : telemetry.metadata) return extractRaindropMetadata(telemetry.metadata);
+  return {};
+}
+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 eventIdGenerated = metadata["raindrop.internal.eventIdGenerated"];
+  if (eventIdGenerated === true || eventIdGenerated === "true" || eventIdGenerated === "1") {
+    result.eventIdGenerated = true;
+  }
+  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 normalizeSelfDiagnosticsSignals(signals) {
+  if (!signals) return AGENT_REPORTING_SIGNALS_DEFAULT;
+  const normalizedEntries = Object.entries(signals).map(([key, value]) => {
+    var _a;
+    const signalKey = key.trim();
+    if (!signalKey || !value || typeof value !== "object") return void 0;
+    const description = (_a = value.description) == null ? void 0 : _a.trim();
+    if (!description) return void 0;
+    const sentiment = value.sentiment;
+    return [
+      signalKey,
+      {
+        description,
+        ...sentiment === "POSITIVE" || sentiment === "NEGATIVE" ? { sentiment } : {}
+      }
+    ];
+  }).filter(
+    (entry) => entry !== void 0
+  );
+  if (normalizedEntries.length === 0) return AGENT_REPORTING_SIGNALS_DEFAULT;
+  return Object.fromEntries(normalizedEntries);
+}
+function normalizeSelfDiagnosticsConfig(options) {
+  var _a, _b;
+  if (!(options == null ? void 0 : options.enabled)) return void 0;
+  const signalDefinitions = normalizeSelfDiagnosticsSignals(options.signals);
+  const signalKeys = Object.keys(signalDefinitions);
+  const signalDescriptions = {};
+  const signalSentiments = {};
+  for (const signalKey of signalKeys) {
+    const def = signalDefinitions[signalKey];
+    if (!def) continue;
+    signalDescriptions[signalKey] = def.description;
+    signalSentiments[signalKey] = def.sentiment;
+  }
+  const customGuidanceText = ((_a = options.guidance) == null ? void 0 : _a.trim()) || "";
+  const toolName = ((_b = options.toolName) == null ? void 0 : _b.trim()) || AGENT_REPORTING_TOOL_NAME_DEFAULT;
+  const signalList = signalKeys.map((signalKey) => {
+    const sentiment = signalSentiments[signalKey];
+    const sentimentTag = sentiment ? ` [${sentiment.toLowerCase()}]` : "";
+    return `- ${signalKey}: ${signalDescriptions[signalKey]}${sentimentTag}`;
+  }).join("\n");
+  const guidanceBlock = customGuidanceText ? `
+Additional guidance: ${customGuidanceText}
+` : "";
+  const toolDescription = `${AGENT_REPORTING_TOOL_PREAMBLE}
+
+When to call:
+- You are blocked from completing the task due to missing information or access that the user cannot provide.
+- A tool is persistently failing across multiple attempts, not just a single transient error.
+- The task requires a tool, permission, or capability you do not have.
+- You genuinely cannot deliver what the user asked for despite trying.
+
+When NOT to call:
+- Normal clarifying questions or back-and-forth with the user.
+- A single tool error that you can recover from or retry.
+- You successfully completed the task, even if it was difficult.
+- Policy refusals or content filtering \u2014 those are working as intended.
+
+Rules:
+1. Pick the single best category.
+2. Do not fabricate issues. Only report what is evident from the conversation.
+3. Err on the side of NOT calling this tool. When in doubt, help the user instead.
+${guidanceBlock}
+Categories:
+${signalList}`;
+  return {
+    toolName,
+    toolDescription,
+    signalKeys,
+    signalKeySet: new Set(signalKeys),
+    signalDescriptions,
+    signalSentiments
+  };
+}
+function resolveJsonSchemaFactory(aiSDK) {
+  if (!isRecord(aiSDK) || !isFunction(aiSDK["jsonSchema"])) return void 0;
+  return aiSDK["jsonSchema"];
+}
+function detectAISDKVersion(aiSDK) {
+  if (!isRecord(aiSDK)) return "unknown";
+  if (isFunction(aiSDK["jsonSchema"])) return "6";
+  if (isFunction(aiSDK["tool"])) return "5";
+  return "4";
+}
+function hasStructuredTelemetryEvents(aiSDK) {
+  return isRecord(aiSDK) && isFunction(aiSDK["registerTelemetryIntegration"]) && isFunction(aiSDK["experimental_streamModelCall"]);
+}
+function asVercelSchema(jsonSchemaObj) {
+  const validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
+  const schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
+  return {
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: jsonSchemaObj,
+    validate: (value) => ({ success: true, value })
+  };
+}
+function createSelfDiagnosticsTool(ctx) {
+  const config = ctx.selfDiagnostics;
+  if (!config) return void 0;
+  const schema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      category: {
+        type: "string",
+        enum: config.signalKeys,
+        description: "The single best-matching category from the list above."
+      },
+      detail: {
+        type: "string",
+        description: "One sentence of factual context: what happened and why it matters. Do not include PII or secrets."
+      }
+    },
+    required: ["category", "detail"]
+  };
+  const parameters = asVercelSchema(schema);
+  let inputSchema = parameters;
+  if (ctx.jsonSchemaFactory) {
+    try {
+      inputSchema = ctx.jsonSchemaFactory(schema);
+    } catch (e) {
+      inputSchema = parameters;
+    }
+  }
+  const execute = async (rawInput) => {
+    var _a;
+    const input = isRecord(rawInput) ? rawInput : void 0;
+    const fallbackCategory = (_a = config.signalKeys[0]) != null ? _a : "unknown";
+    const categoryCandidate = typeof (input == null ? void 0 : input["category"]) === "string" ? input["category"].trim() : void 0;
+    const category = categoryCandidate && config.signalKeySet.has(categoryCandidate) ? categoryCandidate : fallbackCategory;
+    const detail = typeof (input == null ? void 0 : input["detail"]) === "string" ? input["detail"].trim() : "";
+    const signalDescription = config.signalDescriptions[category];
+    const signalSentiment = config.signalSentiments[category];
+    void ctx.eventShipper.trackSignal({
+      eventId: ctx.eventId,
+      name: `self diagnostics - ${category}`,
+      type: "agent",
+      sentiment: signalSentiment,
+      properties: {
+        source: "agent_reporting_tool",
+        category,
+        signal_description: signalDescription,
+        ai_sdk_version: ctx.aiSDKVersion,
+        ...detail ? { detail } : {}
+      }
+    }).catch((err) => {
+      if (ctx.debug) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[raindrop-ai/ai-sdk] selfDiagnostics signal dispatch failed: ${msg}`);
+      }
+    });
+    return { acknowledged: true, category };
+  };
+  return {
+    description: config.toolDescription,
+    execute,
+    parameters,
+    inputSchema
+  };
+}
+function getCurrentParentSpanContextSync() {
+  return getContextManager().getParentSpanIds();
+}
+function runWithParentSpanContextSync(ctx, fn) {
+  const cm = getContextManager();
+  const span = {
+    traceIdB64: ctx.traceIdB64,
+    spanIdB64: ctx.spanIdB64,
+    eventId: ctx.eventId
+  };
+  return cm.runInContext(span, fn);
+}
+function isAsyncIterable(value) {
+  return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
+}
+function firstFiniteNumber(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function resolveUsageRecord(result) {
+  if (!isRecord(result)) return void 0;
+  let usage;
+  try {
+    if (isRecord(result["totalUsage"])) {
+      usage = result["totalUsage"];
+    } else if (isRecord(result["usage"])) {
+      usage = result["usage"];
+    }
+  } catch (e) {
+    return void 0;
+  }
+  return isRecord(usage) ? usage : void 0;
+}
+function extractUsageMetrics(result) {
+  const usage = resolveUsageRecord(result);
+  if (!usage) return {};
+  const inputTokenValue = usage["inputTokens"];
+  const outputTokenValue = usage["outputTokens"];
+  const inputTokens = firstFiniteNumber(
+    isRecord(inputTokenValue) ? inputTokenValue["total"] : void 0,
+    inputTokenValue,
+    usage["promptTokens"],
+    usage["prompt_tokens"]
+  );
+  const outputTokens = firstFiniteNumber(
+    isRecord(outputTokenValue) ? outputTokenValue["total"] : void 0,
+    outputTokenValue,
+    usage["completionTokens"],
+    usage["completion_tokens"]
+  );
+  const totalTokens = firstFiniteNumber(
+    usage["totalTokens"],
+    usage["tokens"],
+    usage["total_tokens"],
+    inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0
+  );
+  const reasoningTokens = firstFiniteNumber(
+    isRecord(outputTokenValue) ? outputTokenValue["reasoning"] : void 0,
+    usage["reasoningTokens"],
+    usage["completionReasoningTokens"],
+    usage["completion_reasoning_tokens"],
+    usage["reasoning_tokens"],
+    usage["thinkingTokens"],
+    usage["thinking_tokens"]
+  );
+  const cachedInputTokens = firstFiniteNumber(
+    isRecord(inputTokenValue) ? inputTokenValue["cacheRead"] : void 0,
+    usage["cachedInputTokens"],
+    usage["promptCachedTokens"],
+    usage["prompt_cached_tokens"]
+  );
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    reasoningTokens,
+    cachedInputTokens
+  };
+}
+function isObjectOperation(operation) {
+  return operation === "generateObject" || operation === "streamObject";
+}
+function logFinalizeError(debug, err) {
+  if (debug) {
+    console.warn(
+      `[raindrop-ai/ai-sdk] finalize failed: ${err instanceof Error ? err.message : err}`
+    );
+  }
+}
+function shouldKeepEventPending(params) {
+  if (params.error != null || !params.canKeepEventPending) return false;
+  return params.finishReason === "tool-calls" || params.finishReason === "tool_calls";
+}
+async function safeFinalize(finalize, debug, result, error) {
+  try {
+    await finalize(result, error);
+  } catch (finalizeErr) {
+    logFinalizeError(debug, finalizeErr);
+  }
+}
+function runWithRootContextSync(rootSpan, eventId, fn) {
+  if (!rootSpan) return fn();
+  return runWithParentSpanContextSync(
+    { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64, eventId },
+    fn
+  );
+}
+async function runWithRootContextAsync(rootSpan, eventId, fn) {
+  if (!rootSpan) return await fn();
+  return await runWithParentSpanContext(
+    { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64, eventId },
+    fn
+  );
+}
+function teeStreamObjectBaseStream(result) {
+  if (!result || !isRecord(result)) return;
+  const baseStream = result["baseStream"];
+  if (!(baseStream && typeof baseStream === "object" && "tee" in baseStream)) return;
+  try {
+    const [consumeStream, userStream] = baseStream.tee();
+    result["baseStream"] = userStream;
+    consumeStream.pipeTo(new WritableStream({ write() {
+    } })).catch(() => {
+    });
+  } catch (e) {
+  }
+}
+function setupOperation(params) {
+  var _a, _b, _c;
+  const {
+    operation,
+    arg,
+    inherited,
+    aiSDK,
+    options,
+    eventShipper,
+    traceShipper,
+    debug,
+    selfDiagnostics,
+    sendTraces
+  } = params;
+  const wrapTimeCtx = resolveContext(options.context, { operation, args: arg });
+  const telemetry = extractExperimentalTelemetry(arg);
+  const callTimeCtx = extractRaindropMetadata(telemetry == null ? void 0 : telemetry.metadata);
+  const mergedCtx = mergeContexts(wrapTimeCtx, callTimeCtx);
+  if (!mergedCtx.userId) warnMissingUserIdOnce();
+  const hasCallTimeEventId = callTimeCtx.eventId != null;
+  const hasWrapTimeEventId = wrapTimeCtx.eventId != null;
+  const eventId = (_c = (_b = (_a = callTimeCtx.eventId) != null ? _a : wrapTimeCtx.eventId) != null ? _b : inherited == null ? void 0 : inherited.eventId) != null ? _c : randomUUID();
+  const ctx = { ...mergedCtx, eventId };
+  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 ? 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 operationSelfDiagnostics = isObjectOperation(operation) ? void 0 : selfDiagnostics;
+  const wrapCtx = {
+    eventId,
+    telemetry,
+    sendTraces,
+    debug,
+    eventShipper,
+    traceShipper,
+    rootParentForChildren,
+    jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
+    selfDiagnostics: operationSelfDiagnostics,
+    aiSDKVersion: detectAISDKVersion(aiSDK)
+  };
+  const toolCalls = [];
+  const argsWithWrappedTools = wrapTools(arg, wrapCtx, toolCalls);
+  const wrappedArgs = wrapModel(argsWithWrappedTools, aiSDK, outerOperationId, wrapCtx);
+  return {
+    eventId,
+    ctx,
+    canKeepEventPending: hasCallTimeEventId ? callTimeCtx.eventIdGenerated !== true : hasWrapTimeEventId,
+    telemetry,
+    rootSpan,
+    wrappedArgs,
+    toolCalls
+  };
+}
+function createFinalize(params) {
+  const {
+    operation,
+    arg,
+    setup,
+    autoAttachmentEnabled,
+    sendEvents,
+    debug,
+    options,
+    eventShipper,
+    traceShipper
+  } = params;
+  return async (result, error) => {
+    var _a, _b, _c, _d;
+    const usage = extractUsageMetrics(result);
+    const model = extractModel(result);
+    const finishReason = extractFinishReason(result);
+    const keepEventPending = shouldKeepEventPending({
+      finishReason,
+      error,
+      canKeepEventPending: setup.canKeepEventPending
+    });
+    const inputAttachments = autoAttachmentEnabled ? extractInputAttachmentsFromArgs(arg) : void 0;
+    const outputAttachments = autoAttachmentEnabled ? await extractOutputAttachmentsFromResult(result) : void 0;
+    const baseMessages = coerceMessagesFromArgs(arg);
+    const responseMessages = extractResponseMessages(result);
+    const allMessages = [...baseMessages, ...responseMessages];
+    const outputText = extractTextOutput(result);
+    const outputObjectJson = extractObjectOutput(result);
+    const defaultOutput = isObjectOperation(operation) ? outputObjectJson : outputText;
+    const defaultPatch = {
+      eventName: (_a = setup.ctx.eventName) != null ? _a : operation,
+      input: (_b = lastUserMessageTextFromArgs(arg)) != null ? _b : extractInputFromArgs(arg),
+      output: defaultOutput,
+      model,
+      properties: setup.ctx.properties,
+      attachments: mergeAttachments(setup.ctx.attachments, inputAttachments, outputAttachments)
+    };
+    const built = await maybeBuildEvent(options.buildEvent, allMessages);
+    const patch = mergeBuildEventPatch(defaultPatch, built);
+    const output = patch.output;
+    const finalModel = (_c = patch.model) != null ? _c : model;
+    if (setup.rootSpan) {
+      const spanEndTimeUnixNano = nowUnixNanoString();
+      const syntheticToolCallCount = emitTranscriptToolCallSpans({
+        baseMessages,
+        responseMessages,
+        rootSpan: setup.rootSpan,
+        eventId: setup.eventId,
+        telemetry: setup.telemetry,
+        toolCalls: setup.toolCalls,
+        traceShipper,
+        endTimeUnixNano: spanEndTimeUnixNano,
+        keepEventPending
+      });
+      const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
+      const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : setup.toolCalls.length ? safeJsonWithUint8(setup.toolCalls) : void 0;
+      traceShipper.endSpan(setup.rootSpan, {
+        attributes: [
+          ...((_d = setup.telemetry) == null ? void 0 : _d.recordOutputs) === false ? [] : [
+            attrString("ai.response.finishReason", finishReason),
+            isObjectOperation(operation) ? 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", usage == null ? void 0 : usage.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usage == null ? void 0 : usage.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usage == null ? void 0 : usage.cachedInputTokens),
+          attrInt("ai.toolCall.count", setup.toolCalls.length + syntheticToolCallCount),
+          ...error ? [attrString("error.message", error instanceof Error ? error.message : String(error))] : []
+        ],
+        error,
+        endTimeUnixNano: spanEndTimeUnixNano
+      });
+    }
+    if (sendEvents) {
+      void eventShipper.patch(setup.eventId, {
+        eventName: patch.eventName,
+        userId: setup.ctx.userId,
+        convoId: setup.ctx.convoId,
+        input: patch.input,
+        output,
+        model: finalModel,
+        properties: patch.properties,
+        attachments: patch.attachments,
+        isPending: keepEventPending
+      }).catch((err) => {
+        if (debug) {
+          console.warn(
+            `[raindrop-ai/ai-sdk] event patch failed: ${err instanceof Error ? err.message : err}`
+          );
+        }
+      });
+    }
+  };
+}
+function hasToolResult(toolCall) {
+  return toolCall.result !== void 0 || toolCall.status === "ERROR";
+}
+function getExecutedToolCallKeys(toolCalls) {
+  return new Set(
+    toolCalls.map((tc) => buildToolCallMatchKey({ toolCallId: tc.id, toolName: tc.name, input: tc.args })).filter((key) => typeof key === "string" && key.length > 0)
+  );
+}
+function getResolvedToolSpans(messages, executedKeys) {
+  return new Map(
+    extractToolSpansFromMessages(messages).filter((tc) => hasToolResult(tc) && !executedKeys.has(tc.key)).map((tc) => [tc.key, tc])
+  );
+}
+function startToolSpan(toolCall, rootSpan, ctx, startTimeUnixNano) {
+  var _a, _b, _c;
+  const { operationName, resourceName } = opName("ai.toolCall", (_a = ctx.telemetry) == null ? void 0 : _a.functionId);
+  return ctx.traceShipper.startSpan({
+    name: "ai.toolCall",
+    parent: { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64 },
+    eventId: ctx.eventId,
+    operationId: "ai.toolCall",
+    attributes: [
+      attrString("operation.name", operationName),
+      attrString("resource.name", resourceName),
+      attrString("ai.telemetry.functionId", (_b = ctx.telemetry) == null ? void 0 : _b.functionId),
+      attrString("ai.toolCall.name", toolCall.toolName),
+      attrString("ai.toolCall.id", toolCall.toolCallId),
+      ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [attrString("ai.toolCall.args", safeJsonWithUint8(toolCall.input))]
+    ],
+    startTimeUnixNano
+  });
+}
+function finishToolSpan(toolCall, span, ctx, endTimeUnixNano) {
+  var _a, _b, _c;
+  const endAttributes = toolCall.status === "ERROR" ? [attrString("error.message", (_a = toolCall.errorMessage) != null ? _a : "Tool call failed")] : ((_b = ctx.telemetry) == null ? void 0 : _b.recordOutputs) === false ? [] : [attrString("ai.toolCall.result", safeJsonWithUint8(toolCall.result))];
+  ctx.traceShipper.endSpan(span, {
+    attributes: endAttributes,
+    ...toolCall.status === "ERROR" ? { error: new Error((_c = toolCall.errorMessage) != null ? _c : "Tool call failed") } : {},
+    endTimeUnixNano
+  });
+}
+function emitToolSpan(toolCall, rootSpan, ctx, timeUnixNano) {
+  const span = startToolSpan(toolCall, rootSpan, ctx, timeUnixNano);
+  finishToolSpan(toolCall, span, ctx, timeUnixNano);
+}
+function emitTranscriptToolCallSpans(params) {
+  const store = PendingToolSpanStore.for(params.traceShipper, params.eventId);
+  const responseToolSpans = extractToolSpansFromMessages(params.responseMessages);
+  if (responseToolSpans.length === 0 && params.baseMessages.length === 0) {
+    if (!params.keepEventPending) {
+      store.closeAll(params.traceShipper);
+    }
+    store.cleanup(params.traceShipper, params.eventId);
+    return 0;
+  }
+  const ctx = {
+    eventId: params.eventId,
+    telemetry: params.telemetry,
+    traceShipper: params.traceShipper
+  };
+  const executedKeys = getExecutedToolCallKeys(params.toolCalls);
+  const resolvedSpans = getResolvedToolSpans(
+    [...params.baseMessages, ...params.responseMessages],
+    executedKeys
+  );
+  store.resolve(resolvedSpans, ctx);
+  let syntheticToolCallCount = 0;
+  for (const toolCall of responseToolSpans) {
+    if (executedKeys.has(toolCall.key)) continue;
+    executedKeys.add(toolCall.key);
+    syntheticToolCallCount += 1;
+    if (hasToolResult(toolCall) || !params.keepEventPending) {
+      emitToolSpan(toolCall, params.rootSpan, ctx, params.endTimeUnixNano);
+    } else {
+      store.remember(toolCall, params.rootSpan, ctx, params.endTimeUnixNano);
+    }
+  }
+  if (!params.keepEventPending) {
+    store.closeAll(params.traceShipper);
+  }
+  store.cleanup(params.traceShipper, params.eventId);
+  return syntheticToolCallCount;
+}
+function executeStreamingOperation(params) {
+  const {
+    operation,
+    arg,
+    callArgs,
+    aiSDK,
+    original,
+    deps,
+    sendEvents,
+    sendTraces,
+    selfDiagnostics,
+    autoAttachmentEnabled,
+    debug
+  } = params;
+  const setup = setupOperation({
+    operation,
+    arg,
+    inherited: getCurrentParentSpanContextSync(),
+    aiSDK,
+    options: deps.options,
+    eventShipper: deps.eventShipper,
+    traceShipper: deps.traceShipper,
+    debug,
+    selfDiagnostics,
+    sendTraces
+  });
+  const finalize = createFinalize({
+    operation,
+    arg,
+    setup,
+    autoAttachmentEnabled,
+    sendEvents,
+    debug,
+    options: deps.options,
+    eventShipper: deps.eventShipper,
+    traceShipper: deps.traceShipper
+  });
+  const argWithOnFinish = wrapOnFinish(setup.wrappedArgs, async (result) => {
+    await safeFinalize(finalize, debug, result);
+  });
+  const callOriginal = (...args) => {
+    return original.call(aiSDK, ...args);
+  };
+  try {
+    const result = runWithRootContextSync(setup.rootSpan, setup.eventId, () => {
+      const nextArgs = [...callArgs];
+      nextArgs[0] = argWithOnFinish;
+      return callOriginal(...nextArgs);
+    });
+    if (operation === "streamObject") {
+      teeStreamObjectBaseStream(result);
+    }
+    return result;
+  } catch (error) {
+    void safeFinalize(finalize, debug, void 0, error);
+    throw error;
+  }
+}
+async function executeNonStreamingOperation(params) {
+  const {
+    operation,
+    arg,
+    callArgs,
+    aiSDK,
+    original,
+    deps,
+    sendEvents,
+    sendTraces,
+    selfDiagnostics,
+    autoAttachmentEnabled,
+    debug
+  } = params;
+  const inherited = await getCurrentParentSpanContext();
+  const setup = setupOperation({
+    operation,
+    arg,
+    inherited,
+    aiSDK,
+    options: deps.options,
+    eventShipper: deps.eventShipper,
+    traceShipper: deps.traceShipper,
+    debug,
+    selfDiagnostics,
+    sendTraces
+  });
+  const finalize = createFinalize({
+    operation,
+    arg,
+    setup,
+    autoAttachmentEnabled,
+    sendEvents,
+    debug,
+    options: deps.options,
+    eventShipper: deps.eventShipper,
+    traceShipper: deps.traceShipper
+  });
+  const callOriginal = async (...args) => {
+    return await original.call(aiSDK, ...args);
+  };
+  try {
+    const result = await runWithRootContextAsync(setup.rootSpan, setup.eventId, async () => {
+      const nextArgs = [...callArgs];
+      nextArgs[0] = setup.wrappedArgs;
+      return await callOriginal(...nextArgs);
+    });
+    await safeFinalize(finalize, debug, result);
+    return result;
+  } catch (error) {
+    await safeFinalize(finalize, debug, void 0, error);
+    throw error;
+  }
+}
+function wrapAISDK(aiSDK, deps) {
+  var _a, _b, _c, _d;
+  const debug = deps.eventShipper.isDebugEnabled() || deps.traceShipper.isDebugEnabled();
+  if (deps.options.nativeTelemetry === true) {
+    if (!hasStructuredTelemetryEvents(aiSDK)) {
+      throw new Error(
+        "[raindrop-ai/ai-sdk] nativeTelemetry requires AI SDK v7+. The AI SDK module passed to wrap() does not support structured telemetry events. Remove nativeTelemetry or upgrade to AI SDK v7."
+      );
+    }
+  }
+  const useNative = deps.options.nativeTelemetry === true;
+  if (useNative) {
+    const wrapTimeCtx = resolveContext(deps.options.context, { operation: "wrap", args: void 0 });
+    const integration = new RaindropTelemetryIntegration({
+      traceShipper: deps.traceShipper,
+      eventShipper: deps.eventShipper,
+      sendTraces: ((_a = deps.options.send) == null ? void 0 : _a.traces) !== false,
+      sendEvents: ((_b = deps.options.send) == null ? void 0 : _b.events) !== false,
+      debug,
+      context: {
+        userId: wrapTimeCtx.userId,
+        eventId: wrapTimeCtx.eventId,
+        eventName: wrapTimeCtx.eventName,
+        convoId: wrapTimeCtx.convoId,
+        properties: wrapTimeCtx.properties
+      }
+    });
+    const registerFn = aiSDK["registerTelemetryIntegration"];
+    if (isFunction(registerFn)) {
+      registerFn(integration);
+    }
+    if (debug) {
+      console.log("[raindrop-ai/ai-sdk] nativeTelemetry: registered RaindropTelemetryIntegration (no Proxy)");
+    }
+    const selfDiagnostics2 = normalizeSelfDiagnosticsConfig(deps.options.selfDiagnostics);
+    if (selfDiagnostics2) {
+      const textOps = /* @__PURE__ */ new Set(["generateText", "streamText"]);
+      const jsonSchemaFactory = resolveJsonSchemaFactory(aiSDK);
+      const proxyTarget2 = isModuleNamespace(aiSDK) ? Object.setPrototypeOf({}, aiSDK) : aiSDK;
+      return new Proxy(proxyTarget2, {
+        get(target, prop, receiver) {
+          const original = Reflect.get(target, prop, receiver);
+          if (typeof prop !== "string" || !textOps.has(prop) || !isFunction(original)) {
+            return original;
+          }
+          return (...callArgs) => {
+            var _a2;
+            const arg = callArgs[0];
+            if (!isRecord(arg)) return original.call(aiSDK, ...callArgs);
+            const telemetry = extractExperimentalTelemetry(arg);
+            const callMeta = (telemetry == null ? void 0 : telemetry.metadata) ? extractRaindropMetadata(telemetry.metadata) : {};
+            const perCallEventIdExplicit = (_a2 = callMeta.eventId) != null ? _a2 : wrapTimeCtx.eventId;
+            const perCallEventId = perCallEventIdExplicit != null ? perCallEventIdExplicit : randomUUID();
+            const perCallEventIdGenerated = !perCallEventIdExplicit;
+            const perCallCtx = {
+              eventId: perCallEventId,
+              telemetry,
+              sendTraces: false,
+              debug,
+              eventShipper: deps.eventShipper,
+              traceShipper: deps.traceShipper,
+              rootParentForChildren: void 0,
+              jsonSchemaFactory,
+              selfDiagnostics: selfDiagnostics2,
+              aiSDKVersion: "7"
+            };
+            const tools = isRecord(arg["tools"]) ? { ...arg["tools"] } : {};
+            const toolName = selfDiagnostics2.toolName;
+            if (!(toolName in tools)) {
+              const reportTool = createSelfDiagnosticsTool(perCallCtx);
+              if (reportTool) tools[toolName] = reportTool;
+            }
+            const existingTelemetry = isRecord(arg["experimental_telemetry"]) ? arg["experimental_telemetry"] : {};
+            const existingMetadata = isRecord(existingTelemetry["metadata"]) ? existingTelemetry["metadata"] : {};
+            const mergedMetadata = existingMetadata["raindrop.eventId"] ? existingMetadata : {
+              ...existingMetadata,
+              "raindrop.eventId": perCallEventId,
+              ...perCallEventIdGenerated ? { "raindrop.internal.eventIdGenerated": "true" } : {}
+            };
+            callArgs[0] = {
+              ...arg,
+              tools,
+              experimental_telemetry: {
+                ...existingTelemetry,
+                metadata: mergedMetadata
+              }
+            };
+            return original.call(aiSDK, ...callArgs);
+          };
+        }
+      });
+    }
+    return aiSDK;
+  }
+  const instrumentedOps = /* @__PURE__ */ new Set([
+    "generateText",
+    "streamText",
+    "generateObject",
+    "streamObject"
+  ]);
+  const agentClasses = /* @__PURE__ */ new Set(["Agent", "Experimental_Agent", "ToolLoopAgent"]);
+  const sendEvents = ((_c = deps.options.send) == null ? void 0 : _c.events) !== false;
+  const sendTraces = ((_d = deps.options.send) == null ? void 0 : _d.traces) !== false;
+  const autoAttachmentEnabled = deps.options.autoAttachment !== false;
+  const selfDiagnostics = normalizeSelfDiagnosticsConfig(deps.options.selfDiagnostics);
+  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, selfDiagnostics);
+      }
+      if (typeof prop !== "string" || !instrumentedOps.has(prop) || !isFunction(original)) {
+        return original;
+      }
+      return (...callArgs) => {
+        const operation = prop;
+        const arg = callArgs[0];
+        if (operation === "streamText" || operation === "streamObject") {
+          return executeStreamingOperation({
+            operation,
+            arg,
+            callArgs,
+            aiSDK,
+            original,
+            deps,
+            sendEvents,
+            sendTraces,
+            selfDiagnostics,
+            autoAttachmentEnabled,
+            debug
+          });
+        }
+        return executeNonStreamingOperation({
+          operation,
+          arg,
+          callArgs,
+          aiSDK,
+          original,
+          deps,
+          sendEvents,
+          sendTraces,
+          selfDiagnostics,
+          autoAttachmentEnabled,
+          debug
+        });
+      };
+    }
+  });
+}
+function wrapAgentClass(AgentClass, aiSDK, deps, debug, selfDiagnostics) {
+  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,
+              selfDiagnostics
+            );
+          }
+          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,
+              selfDiagnostics
+            );
+          }
+          return original;
+        }
+      });
+    }
+  });
+}
+function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK, deps, debug, selfDiagnostics) {
+  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;
+  const autoAttachmentEnabled = deps.options.autoAttachment !== 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 = extractRaindropCallOptions(mergedArgs);
+    const mergedCtx = mergeContexts(wrapTimeCtx, callTimeCtx);
+    if (!mergedCtx.userId) warnMissingUserIdOnce();
+    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,
+      debug,
+      eventShipper: deps.eventShipper,
+      traceShipper: deps.traceShipper,
+      rootParentForChildren,
+      jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
+      selfDiagnostics,
+      aiSDKVersion: detectAISDKVersion(aiSDK)
+    };
+    const toolCalls = [];
+    const mergedArgsWithWrappedTools = wrapTools(mergedArgs, wrapCtx, toolCalls);
+    const mergedArgsWithWrappedModel = wrapModel(
+      mergedArgsWithWrappedTools,
+      aiSDK,
+      outerOperationId,
+      wrapCtx
+    );
+    const callParamsWithWrappedToolsAndModel = mergedArgsWithWrappedModel != null ? mergedArgsWithWrappedModel : {};
+    const finalize = async (result, error) => {
+      var _a3, _b3, _c2;
+      const usage = extractUsageMetrics(result);
+      const model = extractModel(result);
+      const inputAttachments = autoAttachmentEnabled ? extractInputAttachmentsFromArgs(mergedArgs) : void 0;
+      const outputAttachments = autoAttachmentEnabled ? await extractOutputAttachmentsFromResult(result) : void 0;
+      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: mergeAttachments(ctx.attachments, inputAttachments, outputAttachments)
+      };
+      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 spanEndTimeUnixNano = nowUnixNanoString();
+        const syntheticToolCallCount = emitTranscriptToolCallSpans({
+          baseMessages,
+          responseMessages,
+          rootSpan,
+          eventId,
+          telemetry,
+          toolCalls,
+          traceShipper: deps.traceShipper,
+          endTimeUnixNano: spanEndTimeUnixNano,
+          keepEventPending: false
+        });
+        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;
+        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", usage == null ? void 0 : usage.totalTokens),
+            attrInt("ai.usage.reasoningTokens", usage == null ? void 0 : usage.reasoningTokens),
+            attrInt("ai.usage.cachedInputTokens", usage == null ? void 0 : usage.cachedInputTokens),
+            attrInt("ai.toolCall.count", toolCalls.length + syntheticToolCallCount),
+            ...error ? [
+              attrString(
+                "error.message",
+                error instanceof Error ? error.message : String(error)
+              )
+            ] : []
+          ],
+          error,
+          endTimeUnixNano: spanEndTimeUnixNano
+        });
+      }
+      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, callParamsWithWrappedToolsAndModel);
+      });
+      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, selfDiagnostics) {
+  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;
+  const autoAttachmentEnabled = deps.options.autoAttachment !== 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 = extractRaindropCallOptions(mergedArgs);
+    const mergedCtx = mergeContexts(wrapTimeCtx, callTimeCtx);
+    if (!mergedCtx.userId) warnMissingUserIdOnce();
+    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,
+      debug,
+      eventShipper: deps.eventShipper,
+      traceShipper: deps.traceShipper,
+      rootParentForChildren,
+      jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
+      selfDiagnostics,
+      aiSDKVersion: detectAISDKVersion(aiSDK)
+    };
+    const toolCalls = [];
+    const mergedArgsWithWrappedTools = wrapTools(mergedArgs, wrapCtx, toolCalls);
+    const mergedArgsWithWrappedModel = wrapModel(
+      mergedArgsWithWrappedTools,
+      aiSDK,
+      outerOperationId,
+      wrapCtx
+    );
+    const callParamsWithWrappedToolsAndModel = mergedArgsWithWrappedModel != null ? mergedArgsWithWrappedModel : {};
+    const finalize = async (result, error) => {
+      var _a3, _b3, _c2;
+      const usage = extractUsageMetrics(result);
+      const model = extractModel(result);
+      const inputAttachments = autoAttachmentEnabled ? extractInputAttachmentsFromArgs(mergedArgs) : void 0;
+      const outputAttachments = autoAttachmentEnabled ? await extractOutputAttachmentsFromResult(result) : void 0;
+      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: mergeAttachments(ctx.attachments, inputAttachments, outputAttachments)
+      };
+      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 spanEndTimeUnixNano = nowUnixNanoString();
+        const syntheticToolCallCount = emitTranscriptToolCallSpans({
+          baseMessages,
+          responseMessages,
+          rootSpan,
+          eventId,
+          telemetry,
+          toolCalls,
+          traceShipper: deps.traceShipper,
+          endTimeUnixNano: spanEndTimeUnixNano,
+          keepEventPending: false
+        });
+        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;
+        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", usage == null ? void 0 : usage.totalTokens),
+            attrInt("ai.usage.reasoningTokens", usage == null ? void 0 : usage.reasoningTokens),
+            attrInt("ai.usage.cachedInputTokens", usage == null ? void 0 : usage.cachedInputTokens),
+            attrInt("ai.toolCall.count", toolCalls.length + syntheticToolCallCount),
+            ...error ? [
+              attrString(
+                "error.message",
+                error instanceof Error ? error.message : String(error)
+              )
+            ] : []
+          ],
+          error,
+          endTimeUnixNano: spanEndTimeUnixNano
+        });
+      }
+      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(
+      callParamsWithWrappedToolsAndModel != null ? callParamsWithWrappedToolsAndModel : {},
+      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)) return args;
+  const tools = isRecord(args["tools"]) ? { ...args["tools"] } : {};
+  if (ctx.selfDiagnostics) {
+    const reportToolName = ctx.selfDiagnostics.toolName;
+    if (!(reportToolName in tools)) {
+      const reportTool = createSelfDiagnosticsTool(ctx);
+      if (reportTool !== void 0) {
+        tools[reportToolName] = reportTool;
+      }
+    } else if (ctx.debug) {
+      console.warn(
+        `[raindrop-ai/ai-sdk] selfDiagnostics skipped: tool name collision for "${reportToolName}"`
+      );
+    }
+  }
+  if (Object.keys(tools).length === 0) return args;
+  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))
+        ],
+        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 = function(...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.apply(this, execArgs);
+    if (isAsyncIterable(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 iterator = result[Symbol.asyncIterator]();
+          const wrappedIterable = toolSpan ? asyncGeneratorWithCurrent(
+            createContextSpan(toolSpan),
+            iterator
+          ) : {
+            [Symbol.asyncIterator]: () => iterator
+          };
+          for await (const value of wrappedIterable) {
+            lastValue = value;
+            yield value;
+          }
+          toolCalls.push({ id: toolCallId, name, args: toolArgs, result: lastValue, status: "OK" });
+          endToolSpan(toolSpan, lastValue);
+        } catch (error) {
+          toolCalls.push({ id: toolCallId, 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({
+            id: toolCallId,
+            name,
+            args: toolArgs,
+            result: awaitedResult,
+            status: "OK"
+          });
+          endToolSpan(toolSpan, awaitedResult);
+          return awaitedResult;
+        } catch (error) {
+          toolCalls.push({ id: toolCallId, 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)
+                  )
+                ],
+                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)
+                  )
+                ],
+                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)
+                  )
+                ] : []
+              ],
+              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") {
+                    let textDelta;
+                    if (typeof value["delta"] === "string") {
+                      textDelta = value["delta"];
+                    } else if (typeof value["textDelta"] === "string") {
+                      textDelta = value["textDelta"];
+                    }
+                    if (typeof textDelta === "string") activeText += textDelta;
+                  }
+                  if (type === "finish") finishReason = extractFinishReason(value);
+                  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) {
+  if (context === void 0) return {};
+  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) => {
+      let userError;
+      try {
+        const maybePromise = existing(result);
+        if (maybePromise && typeof maybePromise.then === "function") {
+          await maybePromise;
+        }
+      } catch (error) {
+        userError = error;
+      }
+      await onFinish(result);
+      if (userError !== void 0) {
+        throw userError;
+      }
+    }
+  };
+}
+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 mergeAttachments(...groups) {
+  const merged = [];
+  for (const group of groups) {
+    if (group == null ? void 0 : group.length) merged.push(...group);
+  }
+  return merged.length ? merged : void 0;
+}
+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) {
+  const result = {};
+  if (options.eventId) {
+    result["raindrop.eventId"] = options.eventId;
+  } else {
+    result["raindrop.eventId"] = randomUUID();
+    result["raindrop.internal.eventIdGenerated"] = "true";
+  }
+  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 deriveChatTurnMessageId(request) {
+  const messages = Array.isArray(request.messages) ? request.messages : [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if ((message == null ? void 0 : message.role) === "user" && typeof message.id === "string" && message.id.length > 0) {
+      return message.id;
+    }
+  }
+  if (typeof request.messageId === "string" && request.messageId.length > 0) {
+    return request.messageId;
+  }
+  return void 0;
+}
+function eventMetadataFromChatRequest(options) {
+  var _a, _b;
+  const { request, ...rest } = options;
+  const convoId = (_a = rest.convoId) != null ? _a : typeof request.id === "string" && request.id.length > 0 ? request.id : void 0;
+  const turnMessageId = deriveChatTurnMessageId(request);
+  const eventId = (_b = rest.eventId) != null ? _b : turnMessageId ? convoId ? `chat:${convoId}:${turnMessageId}` : `chat:${turnMessageId}` : void 0;
+  return eventMetadata({
+    ...rest,
+    ...convoId ? { convoId } : {},
+    ...eventId ? { eventId } : {}
+  });
+}
+function envDebugEnabled() {
+  var _a;
+  if (typeof process === "undefined") return false;
+  const flag = (_a = process.env) == null ? void 0 : _a.RAINDROP_AI_DEBUG;
+  return flag === "1" || flag === "true";
+}
+function createRaindropAISDK(opts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const writeKey = opts.writeKey;
+  const eventsRequested = ((_a = opts.events) == null ? void 0 : _a.enabled) !== false;
+  const tracesRequested = ((_b = opts.traces) == null ? void 0 : _b.enabled) !== false;
+  const eventsEnabled = eventsRequested && !!writeKey;
+  const tracesEnabled = tracesRequested && !!writeKey;
+  const envDebug = envDebugEnabled();
+  if (!writeKey && (eventsRequested || tracesRequested)) {
+    console.warn(
+      "[raindrop-ai/ai-sdk] writeKey not provided; telemetry shipping is disabled"
+    );
+  }
+  const eventShipper = new EventShipper2({
+    writeKey,
+    endpoint: opts.endpoint,
+    enabled: eventsEnabled,
+    debug: ((_c = opts.events) == null ? void 0 : _c.debug) === true || envDebug,
+    partialFlushMs: (_d = opts.events) == null ? void 0 : _d.partialFlushMs
+  });
+  const traceShipper = new TraceShipper2({
+    writeKey,
+    endpoint: opts.endpoint,
+    enabled: tracesEnabled,
+    debug: ((_e = opts.traces) == null ? void 0 : _e.debug) === true || envDebug,
+    debugSpans: ((_f = opts.traces) == null ? void 0 : _f.debugSpans) === true || envDebug,
+    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: options != null ? options : {},
+        eventShipper,
+        traceShipper
+      });
+    },
+    createTelemetryIntegration(context) {
+      return new RaindropTelemetryIntegration({
+        traceShipper,
+        eventShipper,
+        sendTraces: tracesEnabled,
+        sendEvents: eventsEnabled,
+        debug: envDebug,
+        context
+      });
+    },
+    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);
+      }
+    },
+    users: {
+      async identify(users) {
+        await eventShipper.identify(users);
+      }
+    },
+    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 { RaindropTelemetryIntegration, _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, withCurrent };