@raindrop-ai/eve 0.0.10 → 0.0.11

package/dist/index.js

@@ -0,0 +1,1089 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var api = require('@opentelemetry/api');
+var aiSdk = require('@raindrop-ai/ai-sdk');
+var module$1 = require('module');
+var async_hooks = require('async_hooks');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/index.ts
+function parseEveSessionParent(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const p = value;
+  if (typeof p.sessionId !== "string") return void 0;
+  if (typeof p.turn !== "object" || p.turn === null) return void 0;
+  const t = p.turn;
+  if (typeof t.id !== "string" || typeof t.sequence !== "number") return void 0;
+  const parent = {
+    sessionId: p.sessionId,
+    turn: { id: t.id, sequence: t.sequence },
+    ...typeof p.rootSessionId === "string" ? { rootSessionId: p.rootSessionId } : {}
+  };
+  return parent;
+}
+var cached = void 0;
+function loadGetSession() {
+  if (cached !== void 0) return cached;
+  try {
+    const requireFromHere = module$1.createRequire(
+      // `import.meta.url` is the ESM spelling; tsup polyfills it for CJS builds.
+      typeof __filename !== "undefined" ? __filename : (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href))
+    );
+    const mod = requireFromHere("eve/context");
+    cached = typeof mod.getSession === "function" ? mod.getSession : null;
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+function isEveSessionShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.sessionId !== "string") return false;
+  if (v.turn !== void 0) {
+    if (typeof v.turn !== "object" || v.turn === null) return false;
+    const t = v.turn;
+    if (typeof t.id !== "string" || typeof t.sequence !== "number") return false;
+  }
+  if (v.parent === void 0) return true;
+  return parseEveSessionParent(v.parent) !== void 0;
+}
+function getEveSessionLineage() {
+  const getSession = loadGetSession();
+  if (!getSession) return void 0;
+  let raw;
+  try {
+    raw = getSession();
+  } catch {
+    return void 0;
+  }
+  return isEveSessionShape(raw) ? raw : void 0;
+}
+
+// src/internal/eve-turn-registry.ts
+var EVE_TURN_SPAN_NAME = "ai.eve.turn";
+var EVE_CONTINUATION_TOKEN_ATTR = "eve.continuation_token";
+var EVE_SESSION_ID_ATTR = "eve.session.id";
+var EveTurnRegistry = class {
+  constructor() {
+    /**
+     * Per-trace stack of in-flight `ai.eve.turn` entries.
+     *
+     * The stack lets us handle multiple concurrent turns on the same
+     * `traceId` correctly — both the nested case (turn-within-turn,
+     * theoretically possible if Eve ever supports tool-calls-as-turns)
+     * and the parallel case (two `ai.eve.turn` spans opened on a shared
+     * trace via `Promise.all`, which Workshop's in-process executor can
+     * do when running sibling sub-agents under one sandbox).
+     *
+     * Lookup returns the top of the stack, which is the most-recently
+     * opened still-active turn. That's the right answer for both cases:
+     *   - Nested: the inner turn is the descendant of the active span
+     *     that fires `ai.streamText.onStart`.
+     *   - Parallel: tie-broken in favour of the most-recently-started
+     *     entry. Public OTel APIs don't expose which `ai.eve.turn` is
+     *     the ancestor of the active `step.execute`, so this is the
+     *     best we can do without walking parent spans.
+     *
+     * Empty stacks are deleted from the map so the registry stays small.
+     */
+    this.stacks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Record a turn's attributes. Called from the SpanProcessor's
+   * `onStart` callback whenever an `ai.eve.turn` span is created.
+   * Push onto the per-trace stack — see {@link stacks}.
+   */
+  record(traceId, spanId, entry) {
+    if (!traceId || !spanId) return;
+    let stack = this.stacks.get(traceId);
+    if (!stack) {
+      stack = [];
+      this.stacks.set(traceId, stack);
+    }
+    stack.push({ ...entry, spanId });
+  }
+  /**
+   * Look up the currently-active turn for a trace. Returns `undefined`
+   * if no `ai.eve.turn` span has been seen for this trace — for example
+   * when running outside Eve, or before the turn span has fired
+   * `onStart` (shouldn't happen because Eve opens the turn span before
+   * entering its context, but treated defensively).
+   */
+  lookup(traceId) {
+    if (!traceId) return void 0;
+    const stack = this.stacks.get(traceId);
+    if (!stack || stack.length === 0) return void 0;
+    return stack[stack.length - 1];
+  }
+  /**
+   * Release the entry for a specific `(traceId, spanId)`. Called from
+   * the SpanProcessor's `onEnd` callback. We schedule the removal on a
+   * microtask so any in-flight `ai.streamText` `onStart` (which can
+   * fire *after* `ai.eve.turn` ends if Eve's tool-loop is
+   * mid-finalization) still finds the entry. The grace window is short
+   * — we just need to outlive the synchronous AI SDK fan-out, not
+   * minutes of idle time.
+   *
+   * Targets the exact `spanId` rather than popping the top of the
+   * stack so that interleaved parallel turns release their own entries
+   * regardless of end order.
+   */
+  releaseAfterTick(traceId, spanId) {
+    if (!traceId || !spanId) return;
+    Promise.resolve().then(() => {
+      const stack = this.stacks.get(traceId);
+      if (!stack) return;
+      const idx = stack.findIndex((e) => e.spanId === spanId);
+      if (idx !== -1) {
+        stack.splice(idx, 1);
+      }
+      if (stack.length === 0) {
+        this.stacks.delete(traceId);
+      }
+    });
+  }
+  /**
+   * Drop all entries. Called from the SpanProcessor's `shutdown` hook
+   * during exporter teardown.
+   */
+  clear() {
+    this.stacks.clear();
+  }
+  /**
+   * Total number of in-flight entries across all traces. For tests +
+   * diagnostic logging.
+   */
+  get size() {
+    let total = 0;
+    for (const stack of this.stacks.values()) total += stack.length;
+    return total;
+  }
+};
+var registry = new EveTurnRegistry();
+function createEveTurnSpanProcessor() {
+  return {
+    onStart(span) {
+      if (span.name !== EVE_TURN_SPAN_NAME) return;
+      const attrs = span.attributes;
+      if (!attrs) return;
+      const ctx = span.spanContext();
+      const continuationToken = typeof attrs[EVE_CONTINUATION_TOKEN_ATTR] === "string" ? attrs[EVE_CONTINUATION_TOKEN_ATTR] : void 0;
+      const sessionId = typeof attrs[EVE_SESSION_ID_ATTR] === "string" ? attrs[EVE_SESSION_ID_ATTR] : void 0;
+      registry.record(ctx.traceId, ctx.spanId, {
+        continuationToken,
+        sessionId
+      });
+    },
+    onEnd(span) {
+      if (span.name !== EVE_TURN_SPAN_NAME) return;
+      const ctx = span.spanContext();
+      registry.releaseAfterTick(ctx.traceId, ctx.spanId);
+    },
+    forceFlush() {
+      return Promise.resolve();
+    },
+    shutdown() {
+      registry.clear();
+      return Promise.resolve();
+    }
+  };
+}
+function lookupEveTurn(traceId) {
+  return registry.lookup(traceId);
+}
+function installEveTurnSpanProcessor(traceApi) {
+  if (installState.installed) return true;
+  try {
+    let provider = traceApi.getTracerProvider();
+    const proxyProvider = provider;
+    if (typeof proxyProvider.getDelegate === "function") {
+      const delegate = proxyProvider.getDelegate();
+      if (delegate) provider = delegate;
+    }
+    const tp = provider;
+    if (typeof tp.addSpanProcessor !== "function") {
+      return false;
+    }
+    tp.addSpanProcessor(createEveTurnSpanProcessor());
+    installState.installed = true;
+    return true;
+  } catch {
+    return false;
+  }
+}
+var installState = { installed: false };
+
+// ../core/dist/chunk-SK6EJEO7.js
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_RETRY_DELAY_MS = 3e4;
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatEndpoint(endpoint) {
+  if (!endpoint) return void 0;
+  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
+}
+function redactUrlForLog(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch (e) {
+    return "<unparseable-url>";
+  }
+}
+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.min(Math.max(0, v), MAX_RETRY_DELAY_MS);
+  }
+  if (attemptNumber <= 1) return 0;
+  const base = 500;
+  const factor = Math.pow(2, attemptNumber - 2);
+  return Math.min(base * factor, MAX_RETRY_DELAY_MS);
+}
+async function withRetry(operation, opName, 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} ${opName} retry ${attemptNumber}/${opts.maxAttempts} in ${delay}ms`
+        );
+      }
+      if (delay > 0) await wait(delay);
+    } else if (opts.debug) {
+      console.log(`${prefix} ${opName} attempt ${attemptNumber}/${opts.maxAttempts}`);
+    }
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      if (opts.debug) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(
+          `${prefix} ${opName} 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) {
+  var _a;
+  const opName = `POST ${redactUrlForLog(url)}`;
+  const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
+  await withRetry(
+    async () => {
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        const err = new Error(
+          `HTTP ${resp.status} ${resp.statusText}${text ? `: ${text}` : ""}`
+        );
+        const retryAfterMs = parseRetryAfter(resp.headers);
+        if (typeof retryAfterMs === "number") err.retryAfterMs = retryAfterMs;
+        err.retryable = resp.status === 429 || resp.status >= 500;
+        throw err;
+      }
+    },
+    opName,
+    opts
+  );
+}
+var SpanStatusCode = {
+  UNSET: 0,
+  OK: 1,
+  ERROR: 2
+};
+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
+          }
+        ]
+      }
+    ]
+  };
+}
+var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
+var WORKSHOP_ENV_VAR = "RAINDROP_WORKSHOP";
+var DEFAULT_LOCAL_WORKSHOP_URL = "http://localhost:5899/v1/";
+function readEnvVar(name) {
+  var _a;
+  try {
+    const env = (_a = globalThis == null ? void 0 : globalThis.process) == null ? void 0 : _a.env;
+    if (env && typeof env[name] === "string" && env[name].length > 0) {
+      return env[name];
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function readWorkshopEnv() {
+  const raw = readEnvVar(WORKSHOP_ENV_VAR);
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  if (/^https?:\/\//i.test(trimmed)) return { url: trimmed };
+  if (/^(1|true|yes|on)$/i.test(trimmed)) return "enable";
+  if (/^(0|false|no|off)$/i.test(trimmed)) return "disable";
+  return void 0;
+}
+function isLocalDevHost(hostname) {
+  if (!hostname) return false;
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "::1") {
+    return true;
+  }
+  if (hostname.endsWith(".localhost")) return true;
+  return false;
+}
+function readRuntimeHostname() {
+  try {
+    const loc = globalThis == null ? void 0 : globalThis.location;
+    if (loc && typeof loc.hostname === "string" && loc.hostname.length > 0) {
+      return loc.hostname;
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function shouldAutoEnableLocalWorkshop() {
+  if (isLocalDevHost(readRuntimeHostname())) return true;
+  if (readEnvVar("NODE_ENV") === "development") return true;
+  return false;
+}
+function resolveLocalDebuggerBaseUrl(baseUrl) {
+  var _a, _b, _c;
+  if (baseUrl === null) return null;
+  if (typeof baseUrl === "string" && baseUrl.length > 0) {
+    return (_a = formatEndpoint(baseUrl)) != null ? _a : null;
+  }
+  const explicitUrlEnv = readEnvVar(LOCAL_DEBUGGER_ENV_VAR);
+  if (explicitUrlEnv) return (_b = formatEndpoint(explicitUrlEnv)) != null ? _b : null;
+  const workshopEnv = readWorkshopEnv();
+  if (workshopEnv === "disable") return null;
+  if (workshopEnv === "enable") return DEFAULT_LOCAL_WORKSHOP_URL;
+  if (workshopEnv && "url" in workshopEnv) return (_c = formatEndpoint(workshopEnv.url)) != null ? _c : null;
+  if (shouldAutoEnableLocalWorkshop()) return DEFAULT_LOCAL_WORKSHOP_URL;
+  return null;
+}
+function mirrorTraceExportToLocalDebugger(body, options = {}) {
+  var _a;
+  const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
+  if (!baseUrl) return;
+  void postJson(`${baseUrl}traces`, body, {}, {
+    maxAttempts: 1,
+    debug: (_a = options.debug) != null ? _a : false,
+    sdkName: options.sdkName
+  }).catch(() => {
+  });
+}
+var PROJECT_ID_HEADER = "X-Raindrop-Project-Id";
+var PROJECT_ID_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+function isValidProjectIdSlug(value) {
+  return PROJECT_ID_SLUG_PATTERN.test(value);
+}
+function normalizeProjectId(raw, opts) {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  if (!isValidProjectIdSlug(trimmed) && opts.debug) {
+    console.warn(
+      `${opts.prefix} projectId "${trimmed}" does not match slug ${PROJECT_ID_SLUG_PATTERN.source}; sending anyway \u2014 backend may reject with HTTP 400`
+    );
+  }
+  return trimmed;
+}
+function projectIdHeaders(projectId) {
+  return projectId ? { [PROJECT_ID_HEADER]: projectId } : {};
+}
+var DEFAULT_REDACT_ATTRIBUTE_KEYS = [
+  "ai.request.providerOptions",
+  "ai.response.providerMetadata"
+];
+new Set(DEFAULT_REDACT_ATTRIBUTE_KEYS);
+globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = async_hooks.AsyncLocalStorage;
+
+// src/internal/limits.ts
+var DEFAULT_MAX_TEXT_FIELD_CHARS2 = 1e6;
+var TRUNCATION_MARKER2 = "...[truncated by raindrop]";
+function effectiveAttributeLimit(configured) {
+  let limit = typeof configured === "number" && Number.isFinite(configured) && configured > 0 ? Math.floor(configured) : DEFAULT_MAX_TEXT_FIELD_CHARS2;
+  try {
+    const raw = globalThis?.process?.env?.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+    if (raw) {
+      const envLimit = Number.parseInt(raw, 10);
+      if (Number.isFinite(envLimit) && envLimit > 0) {
+        limit = Math.min(limit, envLimit);
+      }
+    }
+  } catch {
+  }
+  return limit;
+}
+function truncateText(value, limit) {
+  if (value.length <= limit) return value;
+  if (limit > TRUNCATION_MARKER2.length) {
+    return value.slice(0, limit - TRUNCATION_MARKER2.length) + TRUNCATION_MARKER2;
+  }
+  return value.slice(0, Math.max(0, limit));
+}
+
+// src/internal/exporter.ts
+function hexToBase64(hex) {
+  if (!hex) return void 0;
+  if (hex.length === 0 || /^0+$/.test(hex)) return void 0;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+  return globalThis.btoa(bin);
+}
+function hrTimeToNanoString(hr) {
+  const [s, ns] = hr;
+  return (BigInt(Math.trunc(s)) * 1000000000n + BigInt(Math.trunc(ns))).toString();
+}
+function attributeToKeyValue(key, value, maxChars) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return { key, value: { stringValue: truncateText(value, maxChars) } };
+  if (typeof value === "boolean") return { key, value: { boolValue: value } };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { key, value: { intValue: String(value) } } : { key, value: { doubleValue: value } };
+  }
+  if (Array.isArray(value)) {
+    return {
+      key,
+      value: {
+        arrayValue: {
+          values: value.map((v) => {
+            if (v === null || v === void 0) return void 0;
+            if (typeof v === "string") return { stringValue: truncateText(v, maxChars) };
+            if (typeof v === "boolean") return { boolValue: v };
+            if (typeof v === "number") {
+              return Number.isInteger(v) ? { intValue: String(v) } : { doubleValue: v };
+            }
+            return void 0;
+          }).filter((v) => v !== void 0)
+        }
+      }
+    };
+  }
+  return void 0;
+}
+function attributesToKeyValues(attrs, maxChars) {
+  if (!attrs) return [];
+  const out = [];
+  for (const [k, v] of Object.entries(attrs)) {
+    const kv = attributeToKeyValue(k, v, maxChars);
+    if (kv) out.push(kv);
+  }
+  return out;
+}
+function statusFromReadable(span) {
+  const code = span.status?.code;
+  if (code === void 0) return void 0;
+  if (code === 2) {
+    return { code: SpanStatusCode.ERROR, message: span.status.message };
+  }
+  if (code === 1) {
+    return { code: SpanStatusCode.OK };
+  }
+  return { code: SpanStatusCode.UNSET };
+}
+function readableSpanToOtlp(span, maxChars) {
+  const ctx = span.spanContext();
+  const parentSpanIdHex = span.parentSpanContext?.spanId ?? span.parentSpanId;
+  const traceId = hexToBase64(ctx.traceId);
+  const spanId = hexToBase64(ctx.spanId);
+  if (!traceId || !spanId) {
+    throw new Error(
+      `span has invalid context: traceId=${ctx.traceId} spanId=${ctx.spanId}`
+    );
+  }
+  const parentSpanId = hexToBase64(parentSpanIdHex);
+  const attrs = attributesToKeyValues(span.attributes, maxChars);
+  const otlp = {
+    traceId,
+    spanId,
+    name: span.name,
+    startTimeUnixNano: hrTimeToNanoString(span.startTime),
+    endTimeUnixNano: hrTimeToNanoString(span.endTime)
+  };
+  if (parentSpanId) otlp.parentSpanId = parentSpanId;
+  if (attrs.length) otlp.attributes = attrs;
+  const status = statusFromReadable(span);
+  if (status) otlp.status = status;
+  return otlp;
+}
+var RaindropEveSpanExporter = class {
+  constructor(opts = {}) {
+    this.inFlight = /* @__PURE__ */ new Set();
+    this.shuttingDown = false;
+    this.auxShutdowns = [];
+    this.writeKey = opts.writeKey?.trim();
+    this.baseUrl = formatEndpoint(opts.endpoint) ?? "https://api.raindrop.ai/v1/";
+    this.sdkName = opts.sdkName ?? "eve";
+    this.maxTextFieldChars = opts.maxTextFieldChars;
+    this.serviceName = opts.serviceName ?? "raindrop.eve";
+    this.serviceVersion = opts.serviceVersion ?? "0.0.0";
+    this.debug = opts.debug === true;
+    this.prefix = `[raindrop-ai/${this.sdkName}]`;
+    this.projectId = normalizeProjectId(opts.projectId, {
+      debug: this.debug,
+      prefix: this.prefix
+    });
+    const explicit = opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl;
+    this.localDebuggerUrl = resolveLocalDebuggerBaseUrl(explicit) ?? void 0;
+    if (this.debug) {
+      console.log(
+        `${this.prefix} Initialized`,
+        {
+          raindrop: this.writeKey ? this.baseUrl : "disabled (no writeKey)",
+          workshop: this.localDebuggerUrl ?? "disabled"
+        }
+      );
+    }
+  }
+  /** True when we have at least one destination (Raindrop or Workshop). */
+  hasDestinations() {
+    return Boolean(this.writeKey || this.localDebuggerUrl);
+  }
+  /**
+   * Update the OTLP `service.name` attribute. Called by Eve's
+   * `setup({ agentName })` so the resource attribute reflects the actual
+   * agent name when the caller didn't pin one via `opts.serviceName`.
+   */
+  setServiceName(serviceName) {
+    if (!serviceName || serviceName === this.serviceName) return;
+    this.serviceName = serviceName;
+    if (this.debug) {
+      console.log(`${this.prefix} serviceName updated \u2192 ${serviceName}`);
+    }
+  }
+  export(spans, resultCallback) {
+    if (this.shuttingDown) {
+      resultCallback({ code: 1, error: new Error("exporter shut down") });
+      return;
+    }
+    if (spans.length === 0) {
+      resultCallback({ code: 0 });
+      return;
+    }
+    const maxChars = effectiveAttributeLimit(this.maxTextFieldChars);
+    const otlpSpans = [];
+    for (const span of spans) {
+      try {
+        otlpSpans.push(readableSpanToOtlp(span, maxChars));
+      } catch (err) {
+        if (this.debug) {
+          console.warn(`${this.prefix} failed to convert span`, err);
+        }
+      }
+    }
+    if (otlpSpans.length === 0) {
+      resultCallback({ code: 0 });
+      return;
+    }
+    const body = buildExportTraceServiceRequest(otlpSpans, this.serviceName, this.serviceVersion);
+    if (this.localDebuggerUrl) {
+      mirrorTraceExportToLocalDebugger(body, {
+        baseUrl: this.localDebuggerUrl,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+    }
+    if (!this.writeKey) {
+      if (this.debug) {
+        console.log(`${this.prefix} exported ${otlpSpans.length} spans (workshop-only)`);
+      }
+      resultCallback({ code: 0 });
+      return;
+    }
+    const url = `${this.baseUrl}traces`;
+    if (this.debug) {
+      console.log(`${this.prefix} sending ${otlpSpans.length} spans -> ${url}`);
+    }
+    const p = postJson(
+      url,
+      body,
+      {
+        Authorization: `Bearer ${this.writeKey}`,
+        ...projectIdHeaders(this.projectId)
+      },
+      { maxAttempts: 3, debug: this.debug, sdkName: this.sdkName }
+    ).then(() => {
+      if (this.debug) console.log(`${this.prefix} sent ${otlpSpans.length} spans`);
+      resultCallback({ code: 0 });
+    }).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`${this.prefix} failed to send ${otlpSpans.length} spans: ${msg}`);
+      resultCallback({ code: 1, error: err instanceof Error ? err : new Error(msg) });
+    }).finally(() => {
+      this.inFlight.delete(p);
+    });
+    this.inFlight.add(p);
+  }
+  async forceFlush() {
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+  async shutdown() {
+    this.shuttingDown = true;
+    await this.forceFlush();
+    await Promise.all(
+      this.auxShutdowns.map((fn) => fn().catch(() => {
+      }))
+    );
+  }
+  /**
+   * Register an extra teardown hook to run during {@link shutdown}. Used to
+   * drain the AI SDK trace + event shippers that the `@raindrop-ai/eve`
+   * integration builds alongside this exporter — without this, pending
+   * `track_partial` events and AI SDK trace spans would be dropped on
+   * SIGINT / SIGTERM.
+   */
+  attachAuxShutdown(fn) {
+    this.auxShutdowns.push(fn);
+  }
+};
+
+// package.json
+var package_default = {
+  name: "@raindrop-ai/eve",
+  version: "0.0.10"};
+
+// src/internal/version.ts
+var libraryName = package_default.name;
+var libraryVersion = package_default.version;
+
+// src/index.ts
+var RAINDROP_EVE_SDK_NAME = libraryName;
+var RAINDROP_EVE_SDK_VERSION = libraryVersion;
+var canonicalTurnIdBySession = /* @__PURE__ */ new Map();
+var MAX_CANONICAL_TURN_SESSIONS = 1024;
+function _resetCanonicalTurnIds() {
+  canonicalTurnIdBySession.clear();
+}
+var RAINDROP_EVE_INTEGRATION = /* @__PURE__ */ Symbol.for("raindrop.eve.integration");
+var RAINDROP_EVE_OTEL_REGISTERED = /* @__PURE__ */ Symbol.for("raindrop.eve.otel.registered");
+function wrapWithDebugLogs(integration, prefix) {
+  const methodNames = [
+    "onStart",
+    "onStepStart",
+    "onLanguageModelCallStart",
+    "onLanguageModelCallEnd",
+    "onToolExecutionStart",
+    "onToolExecutionEnd",
+    "onToolCallStart",
+    "onToolCallFinish",
+    "onStepFinish",
+    "onObjectStepStart",
+    "onObjectStepFinish",
+    "onEmbedStart",
+    "onEmbedEnd",
+    "onRerankStart",
+    "onRerankEnd",
+    // `onFinish` is the v7-canary-and-earlier name; `onEnd` is the
+    // post-canary.144 name (see `injectEveCallContext` for the alias).
+    // Both are listed so the wrapper logs whichever the underlying
+    // integration / dispatcher actually invokes.
+    "onFinish",
+    "onEnd",
+    "onError",
+    // `onAbort` (v7 canary post-beta.116) fires when a streamText call is
+    // cancelled via its AbortSignal — neither `onEnd` nor `onError` runs then.
+    "onAbort"
+  ];
+  const wrapped = integration;
+  for (const name of methodNames) {
+    const original = wrapped[name];
+    if (typeof original !== "function") continue;
+    const fn = original;
+    wrapped[name] = function(event) {
+      try {
+        const ev = event;
+        const op = ev && (ev.operationId ?? ev["operation_id"]);
+        console.log(`${prefix} ai-sdk-tel ${name} op=${String(op ?? "?")}`);
+      } catch {
+      }
+      return fn.call(integration, event);
+    };
+  }
+  return integration;
+}
+function injectEveCallContext(integration, opts) {
+  const target = integration;
+  if (typeof target.onFinish === "function" && typeof target.onEnd !== "function") {
+    target.onEnd = target.onFinish;
+  }
+  const original = target.onStart;
+  if (typeof original !== "function") return integration;
+  const fn = original;
+  target.onStart = function(event) {
+    try {
+      const ev = event;
+      if (envDebug()) {
+        try {
+          const ctxAny = ev.runtimeContext;
+          const messages = ev.messages ?? [];
+          const firstMsgContent = messages[0]?.content;
+          const firstMsgPreview = typeof firstMsgContent === "string" ? firstMsgContent.slice(0, 220) : Array.isArray(firstMsgContent) ? JSON.stringify(firstMsgContent).slice(0, 220) : void 0;
+          const activeSpanForDebug = api.trace.getActiveSpan();
+          const traceIdForDebug = activeSpanForDebug?.spanContext?.()?.traceId;
+          const turnEntryForDebug = lookupEveTurn(traceIdForDebug);
+          const lineageForDebug = getEveSessionLineage();
+          console.log(
+            `[raindrop-ai/eve][probe] agentName=${opts.agentName} fn=${ev.functionId} traceId=${traceIdForDebug} activeSpan=${activeSpanForDebug?.name} runtimeContextKeys=${ctxAny ? Object.keys(ctxAny).join(",") : "<none>"} turnEntry=${JSON.stringify(turnEntryForDebug)} eveSession=${JSON.stringify(lineageForDebug)} firstMsg=${JSON.stringify(firstMsgPreview)}`
+          );
+        } catch (e) {
+          console.log(`[raindrop-ai/eve][probe] error: ${e.message}`);
+        }
+      }
+      const ctx = ev.runtimeContext;
+      const activeSpan = api.trace.getActiveSpan();
+      const spanAttrs = activeSpan?.attributes;
+      const traceId = activeSpan?.spanContext?.()?.traceId;
+      const turnEntry = lookupEveTurn(traceId);
+      const eveSession = getEveSessionLineage();
+      const sessionFromContext = eveSession?.sessionId ?? (typeof ctx?.["eve.session.id"] === "string" ? ctx["eve.session.id"] : void 0) ?? turnEntry?.sessionId ?? (typeof spanAttrs?.["eve.session.id"] === "string" ? spanAttrs["eve.session.id"] : void 0);
+      const convoFromContext = (typeof ctx?.["eve.continuation_token"] === "string" ? ctx["eve.continuation_token"] : void 0) ?? turnEntry?.continuationToken ?? (typeof spanAttrs?.["eve.continuation_token"] === "string" ? spanAttrs["eve.continuation_token"] : void 0) ?? // eve >= 0.45 stopped forwarding `eve.continuation_token`,
+      // the legacy convo key — leaving `raindrop.convoId` null so every
+      // multi-turn run un-grouped on the Conversations view. The session id is
+      // stable across a run's turns and distinct per run, so falling back to
+      // it restores turn-to-conversation grouping. An author-supplied
+      // `raindrop.convoId` (e.g. a durable Slack thread id mapped in the step
+      // hook) still wins: it is already on `meta` before this is applied.
+      sessionFromContext;
+      const ctxTurnId = typeof ctx?.["eve.turn.id"] === "string" ? ctx["eve.turn.id"] : void 0;
+      if (sessionFromContext && ctxTurnId) {
+        if (canonicalTurnIdBySession.size >= MAX_CANONICAL_TURN_SESSIONS && !canonicalTurnIdBySession.has(sessionFromContext)) {
+          const oldest = canonicalTurnIdBySession.keys().next().value;
+          if (oldest !== void 0) canonicalTurnIdBySession.delete(oldest);
+        }
+        canonicalTurnIdBySession.set(sessionFromContext, ctxTurnId);
+      }
+      const turnIdFromContext = ctxTurnId ?? (sessionFromContext ? canonicalTurnIdBySession.get(sessionFromContext) : void 0) ?? (typeof eveSession?.turn?.id === "string" ? eveSession.turn.id : void 0) ?? (typeof spanAttrs?.["eve.turn.id"] === "string" ? spanAttrs["eve.turn.id"] : void 0);
+      const meta = ev.metadata ?? {};
+      let userProps;
+      for (const k of Object.keys(meta)) {
+        if (k === "raindrop.properties") continue;
+        if (k.startsWith("raindrop.") || k.startsWith("eve.")) continue;
+        (userProps ?? (userProps = {}))[k] = meta[k];
+      }
+      if (ctx) {
+        for (const [k, v] of Object.entries(ctx)) {
+          if (typeof v !== "string") continue;
+          if (k.startsWith("eve.")) continue;
+          if (k.startsWith("raindrop.")) {
+            if (meta[k] === void 0) meta[k] = v;
+          } else if (!userProps || userProps[k] === void 0) {
+            (userProps ?? (userProps = {}))[k] = v;
+          }
+        }
+      }
+      if (opts.authoredMetadata) {
+        for (const [k, v] of Object.entries(opts.authoredMetadata)) {
+          if (k.startsWith("raindrop.") || k.startsWith("eve.")) {
+            if (meta[k] === void 0) meta[k] = v;
+          } else if (!userProps || userProps[k] === void 0) {
+            (userProps ?? (userProps = {}))[k] = v;
+          }
+        }
+      }
+      if (userProps) {
+        const existing = meta["raindrop.properties"];
+        const existingProps = existing && typeof existing === "object" ? existing : void 0;
+        meta["raindrop.properties"] = { ...userProps, ...existingProps };
+      }
+      const parentToolContext = aiSdk.getCurrentParentToolContext();
+      const crossSandboxParent = parentToolContext === void 0 ? eveSession?.parent : void 0;
+      const runtimeParentSessionId = parentToolContext === void 0 && crossSandboxParent === void 0 && typeof meta["raindrop.parent.sessionId"] === "string" ? meta["raindrop.parent.sessionId"] : void 0;
+      const crossSandboxAgentName = typeof ev.functionId === "string" && ev.functionId ? ev.functionId : opts.agentName;
+      const detected = parentToolContext?.toolName ?? (crossSandboxParent !== void 0 || runtimeParentSessionId !== void 0 ? crossSandboxAgentName : void 0);
+      const activeTraceId = parentToolContext ? void 0 : api.trace.getActiveSpan()?.spanContext()?.traceId;
+      const isSubAgent = parentToolContext !== void 0 || crossSandboxParent !== void 0 || runtimeParentSessionId !== void 0;
+      const rootTurnEventId = !isSubAgent && sessionFromContext && turnIdFromContext ? eveTurnEventId(sessionFromContext, turnIdFromContext) : void 0;
+      const eventId = rootTurnEventId ?? activeTraceId;
+      if (sessionFromContext && meta["raindrop.userId"] === void 0) {
+        meta["raindrop.userId"] = sessionFromContext;
+      }
+      if (meta["raindrop.convoId"] === void 0) {
+        const parentConvo = isSubAgent && typeof meta["raindrop.parent.rootSessionId"] === "string" ? meta["raindrop.parent.rootSessionId"] : isSubAgent && typeof meta["raindrop.parent.sessionId"] === "string" ? meta["raindrop.parent.sessionId"] : void 0;
+        const convo = parentConvo ?? convoFromContext;
+        if (convo) meta["raindrop.convoId"] = convo;
+      }
+      if (eventId && meta["raindrop.eventId"] === void 0) {
+        meta["raindrop.eventId"] = eventId;
+      }
+      if (detected && meta["eve.subagent.name"] === void 0) {
+        meta["eve.subagent.name"] = detected;
+      }
+      if (meta["eve.agent.role"] === void 0) {
+        meta["eve.agent.role"] = detected ? "subagent" : "root";
+      }
+      if (parentToolContext) {
+        if (meta["raindrop.parent.callId"] === void 0) {
+          meta["raindrop.parent.callId"] = parentToolContext.parentCallId;
+        }
+        if (meta["raindrop.parent.toolCallId"] === void 0) {
+          meta["raindrop.parent.toolCallId"] = parentToolContext.toolCallId;
+        }
+        if (meta["raindrop.parent.toolName"] === void 0) {
+          meta["raindrop.parent.toolName"] = parentToolContext.toolName;
+        }
+      } else if (crossSandboxParent) {
+        for (const [key, value] of Object.entries(parentLineageMetadata(crossSandboxParent))) {
+          if (meta[key] === void 0) meta[key] = value;
+        }
+      }
+      if (Object.keys(meta).length > 0) ev.metadata = meta;
+    } catch {
+    }
+    return fn.call(integration, event);
+  };
+  return integration;
+}
+function registerAISdkTelemetry(integration) {
+  const g = globalThis;
+  if (!Array.isArray(g.AI_SDK_TELEMETRY_INTEGRATIONS)) {
+    g.AI_SDK_TELEMETRY_INTEGRATIONS = [];
+  }
+  const tagged = integration;
+  tagged[RAINDROP_EVE_INTEGRATION] = true;
+  g.AI_SDK_TELEMETRY_INTEGRATIONS = g.AI_SDK_TELEMETRY_INTEGRATIONS.filter(
+    (e) => !e[RAINDROP_EVE_INTEGRATION]
+  );
+  g.AI_SDK_TELEMETRY_INTEGRATIONS.push(tagged);
+}
+function envWriteKey() {
+  if (typeof process === "undefined") return void 0;
+  const v = process.env?.RAINDROP_WRITE_KEY;
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function envProjectId() {
+  if (typeof process === "undefined") return void 0;
+  const v = process.env?.RAINDROP_PROJECT_ID;
+  return v && v.length > 0 ? v : void 0;
+}
+function envEndpoint() {
+  if (typeof process === "undefined") return void 0;
+  const v = process.env?.RAINDROP_ENDPOINT;
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function envDebug() {
+  if (typeof process === "undefined") return false;
+  const v = process.env?.RAINDROP_AI_DEBUG;
+  return v === "1" || v === "true";
+}
+function isEveMetadataConfig(m) {
+  return typeof m === "object" && m !== null && typeof m["step.started"] === "function";
+}
+function eveTurnEventId(sessionId, turnId) {
+  return `eve:${sessionId}:${turnId}`;
+}
+function parentLineageMetadata(parent) {
+  const out = {
+    "raindrop.parent.sessionId": parent.sessionId,
+    "raindrop.parent.eventId": eveTurnEventId(parent.sessionId, parent.turn.id),
+    "raindrop.parent.turnId": parent.turn.id,
+    "raindrop.parent.turnSequence": String(parent.turn.sequence)
+  };
+  if (parent.rootSessionId !== void 0) {
+    out["raindrop.parent.rootSessionId"] = parent.rootSessionId;
+  }
+  return out;
+}
+function resolveCrossSandboxParentMetadata(input) {
+  const parent = parseEveSessionParent(input.session.parent);
+  if (parent === void 0) return {};
+  return parentLineageMetadata(parent);
+}
+var RAINDROP_PARENT_PREFIX = "raindrop.parent.";
+function stripReservedParentMetadata(meta) {
+  if (meta == null) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(meta)) {
+    if (!key.startsWith(RAINDROP_PARENT_PREFIX)) out[key] = value;
+  }
+  return out;
+}
+function resolveStaticMetadata(opts) {
+  const legacyFlat = isEveMetadataConfig(opts.metadata) ? void 0 : opts.metadata;
+  if (opts.staticMetadata === void 0 && legacyFlat === void 0) return void 0;
+  return stripReservedParentMetadata({ ...legacyFlat, ...opts.staticMetadata });
+}
+function buildEveStepStartedResolver(opts, staticMetadata) {
+  const metadataConfig = isEveMetadataConfig(opts.metadata) ? opts.metadata : void 0;
+  const eventsConfig = opts.events;
+  const eventsStepStarted = eventsConfig?.["step.started"];
+  const metadataStepStarted = metadataConfig?.["step.started"];
+  return (input) => {
+    const userMetadata = eventsStepStarted ? (
+      // Invoke with the authored config as the receiver so callbacks defined
+      // as object methods (`{ "step.started"() { return this... } }`) keep
+      // their `this` binding. The 0.53 hook returns `{ runtimeContext }`.
+      eventsStepStarted.call(eventsConfig, input)?.runtimeContext ?? {}
+    ) : metadataStepStarted ? metadataStepStarted.call(metadataConfig, input) : {};
+    return {
+      ...staticMetadata,
+      ...stripReservedParentMetadata(userMetadata),
+      ...resolveCrossSandboxParentMetadata(input)
+    };
+  };
+}
+function buildEveMetadataConfig(opts, staticMetadata) {
+  const resolve = buildEveStepStartedResolver(opts, staticMetadata);
+  return { "step.started": (input) => resolve(input) };
+}
+function buildEveEventsConfig(opts, staticMetadata) {
+  const resolve = buildEveStepStartedResolver(opts, staticMetadata);
+  return { "step.started": (input) => ({ runtimeContext: resolve(input) }) };
+}
+function defineRaindropInstrumentation(opts = {}) {
+  const debug = opts.debug === true || envDebug();
+  const writeKey = opts.writeKey ?? envWriteKey();
+  const endpoint = opts.endpoint ?? envEndpoint();
+  const projectId = opts.projectId ?? envProjectId();
+  const exporter = new RaindropEveSpanExporter({
+    writeKey,
+    endpoint,
+    projectId,
+    localWorkshopUrl: opts.localWorkshopUrl,
+    serviceName: opts.serviceName,
+    serviceVersion: opts.serviceVersion ?? libraryVersion,
+    sdkName: "eve",
+    debug,
+    maxTextFieldChars: opts.maxTextFieldChars
+  });
+  const localWorkshopUrl = opts.localWorkshopUrl === false ? false : opts.localWorkshopUrl;
+  const raindrop = aiSdk.createRaindropAISDK({
+    writeKey,
+    endpoint,
+    projectId,
+    localWorkshopUrl,
+    events: { debug },
+    traces: { debug }
+  });
+  exporter.attachAuxShutdown(() => raindrop.shutdown());
+  const prefix = "[raindrop-ai/eve]";
+  const staticMetadata = resolveStaticMetadata(opts);
+  const eveMetadata = buildEveMetadataConfig(opts, staticMetadata);
+  const eveEvents = buildEveEventsConfig(opts, staticMetadata);
+  return {
+    functionId: opts.functionId,
+    metadata: eveMetadata,
+    events: eveEvents,
+    recordInputs: opts.recordInputs,
+    recordOutputs: opts.recordOutputs,
+    exporter,
+    raindrop,
+    setup({ agentName }) {
+      if (!exporter.hasDestinations()) {
+        console.warn(
+          `${prefix} no destinations configured \u2014 set RAINDROP_WRITE_KEY for hosted Raindrop, or run \`raindrop workshop\` for local mirroring.`
+        );
+      }
+      const serviceName = opts.serviceName ?? agentName;
+      exporter.setServiceName(serviceName);
+      if (opts.registerOTel) {
+        const g = globalThis;
+        const already = g[RAINDROP_EVE_OTEL_REGISTERED];
+        if (already === void 0) {
+          opts.registerOTel({
+            serviceName,
+            traceExporter: exporter
+          });
+          g[RAINDROP_EVE_OTEL_REGISTERED] = { exporter };
+          if (debug) {
+            console.log(`${prefix} registered OTel for serviceName=${serviceName}`);
+          }
+        } else if (debug) {
+          console.log(
+            `${prefix} skipping duplicate registerOTel \u2014 already registered (hot reload). Restart the process to re-register.`
+          );
+        }
+      } else {
+        console.warn(
+          `${prefix} no \`registerOTel\` passed \u2014 Eve's own OTel spans (workflow/step/fetch) will not be exported. Pass \`registerOTel\` from \`@vercel/otel\`.`
+        );
+      }
+      const installed = installEveTurnSpanProcessor(api.trace);
+      if (!installed && debug) {
+        console.log(
+          `${prefix} could not install ai.eve.turn SpanProcessor \u2014 cross-sandbox sub-agent detection will fall back to active-span attributes only. (Global tracer provider missing addSpanProcessor \u2014 register \`registerOTel\` from \`@vercel/otel\` before \`defineRaindropInstrumentation\`'s \`setup()\` runs.)`
+        );
+      }
+      const integration = raindrop.createTelemetryIntegration({
+        userId: opts.userId ?? agentName,
+        eventName: opts.eventName
+      });
+      injectEveCallContext(integration, {
+        agentName,
+        rootFunctionId: opts.functionId ?? agentName,
+        authoredMetadata: staticMetadata
+      });
+      const wrapped = debug ? wrapWithDebugLogs(integration, prefix) : integration;
+      registerAISdkTelemetry(wrapped);
+      if (debug) {
+        console.log(`${prefix} registered AI SDK telemetry integration (events + traces).`);
+        const g = globalThis;
+        console.log(
+          `${prefix} globalThis.AI_SDK_TELEMETRY_INTEGRATIONS length=${g.AI_SDK_TELEMETRY_INTEGRATIONS?.length ?? 0}`
+        );
+      }
+    }
+  };
+}
+var index_default = defineRaindropInstrumentation;
+
+exports.RAINDROP_EVE_SDK_NAME = RAINDROP_EVE_SDK_NAME;
+exports.RAINDROP_EVE_SDK_VERSION = RAINDROP_EVE_SDK_VERSION;
+exports.RaindropEveSpanExporter = RaindropEveSpanExporter;
+exports._resetCanonicalTurnIds = _resetCanonicalTurnIds;
+exports.default = index_default;
+exports.defineRaindropInstrumentation = defineRaindropInstrumentation;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map