@raindrop-ai/eve 0.0.22 → 0.0.24

package/dist/index.mjs

@@ -1,9 +1,792 @@
 import { trace } from '@opentelemetry/api';
 import { createRaindropAISDK, getCurrentParentToolContext } from '@raindrop-ai/ai-sdk';
-import { createRequire } from 'module';
 import { AsyncLocalStorage } from 'async_hooks';
+import { execFile } from 'child_process';
+import { resolve } from 'path';
+import { createRequire } from 'module';
 
 // src/index.ts
+
+// ../core/dist/chunk-WJOR6M7H.js
+function getAsyncLocalStorageCtor() {
+  return globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+}
+var MAX_BINDING_STACK = 128;
+var EMPTY_STACK = [];
+var ContextStackStorage = class {
+  /** Emitted once when this runtime cannot support an ambient push. */
+  constructor(noAmbientBindWarning) {
+    this.noAmbientBindWarning = noAmbientBindWarning;
+    this._als = null;
+    this._enterWithUsable = false;
+    this._syncStack = EMPTY_STACK;
+    this._adoptionChecked = false;
+    this._warnedNoAmbientBind = false;
+  }
+  maybeAdoptAsyncLocalStorage() {
+    if (this._adoptionChecked) return;
+    this._adoptionChecked = true;
+    const Ctor = getAsyncLocalStorageCtor();
+    if (!Ctor) return;
+    const als = new Ctor();
+    try {
+      als.run(EMPTY_STACK, () => {
+      });
+    } catch (e) {
+      return;
+    }
+    this._als = als;
+    if (typeof als.enterWith === "function") {
+      try {
+        als.enterWith(EMPTY_STACK);
+        this._enterWithUsable = true;
+      } catch (e) {
+        this._enterWithUsable = false;
+      }
+    }
+  }
+  getStack() {
+    var _a;
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return (_a = this._als.getStore()) != null ? _a : this._syncStack;
+    return this._syncStack;
+  }
+  /**
+   * Persist an ambient stack mutation. Returns false when an ALS is adopted but
+   * `enterWith` is unusable (workerd): callers must NOT fall back to the
+   * process-shared sync stack, since concurrent isolates would cross-stamp.
+   */
+  setAmbientStack(stack) {
+    if (this._als) {
+      if (!this._enterWithUsable) return false;
+      this._als.enterWith(stack);
+      return true;
+    }
+    this._syncStack = stack;
+    return true;
+  }
+  push(binding) {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als && !this._enterWithUsable) {
+      this.warnNoAmbientBindOnce();
+      return;
+    }
+    let stack = this.getStack();
+    if (stack.length >= MAX_BINDING_STACK) {
+      stack = stack.filter((b) => b.isLive());
+      if (stack.length >= MAX_BINDING_STACK) {
+        stack = stack.slice(stack.length - (MAX_BINDING_STACK - 1));
+      }
+    }
+    this.setAmbientStack([...stack, binding]);
+  }
+  remove(binding) {
+    binding.markDead();
+    const stack = this.getStack();
+    const pruned = stack.filter((b) => b !== binding && b.isLive());
+    if (pruned.length !== stack.length) {
+      this.setAmbientStack(pruned);
+    }
+  }
+  runWith(binding, callback) {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) {
+      return this._als.run([...this.getStack(), binding], callback);
+    }
+    const previous = this._syncStack;
+    this._syncStack = [...previous, binding];
+    try {
+      return callback();
+    } finally {
+      this._syncStack = previous;
+    }
+  }
+  current() {
+    const stack = this.getStack();
+    if (stack.length === 0) return void 0;
+    const top = stack[stack.length - 1];
+    if (top.isLive()) return top;
+    const pruned = stack.filter((b) => b.isLive());
+    this.setAmbientStack(pruned);
+    return pruned.length > 0 ? pruned[pruned.length - 1] : void 0;
+  }
+  warnNoAmbientBindOnce() {
+    if (this._warnedNoAmbientBind) return;
+    this._warnedNoAmbientBind = true;
+    console.warn(this.noAmbientBindWarning);
+  }
+};
+var NO_AMBIENT_ROUTING_BIND_WARNING = "[raindrop] This runtime's AsyncLocalStorage does not implement enterWith (e.g. Cloudflare Workers), so begin()/finish() cannot scope auto-instrumented spans to a project without cross-contaminating concurrent requests. Manual events and explicit span routing are unaffected; use asCurrent()/withSpan (run-based) to route auto-instrumented spans on this runtime.";
+var ROUTING_STORAGE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.routingContextStorage");
+function routingStorage() {
+  const holder = globalThis;
+  let storage = holder[ROUTING_STORAGE_KEY];
+  if (!storage) {
+    storage = new ContextStackStorage(NO_AMBIENT_ROUTING_BIND_WARNING);
+    holder[ROUTING_STORAGE_KEY] = storage;
+  }
+  return storage;
+}
+function currentRoutingBinding() {
+  const bound = routingStorage().current();
+  if (!bound) return void 0;
+  return {
+    projectId: bound.projectId,
+    authHint: bound.authHint,
+    ...bound.appGit ? { appGit: bound.appGit } : {},
+    ...bound.appGitSource ? { appGitSource: bound.appGitSource } : {}
+  };
+}
+var APP_COMMIT_SHA = "raindrop.app.commit_sha";
+var APP_COMMIT_DIRTY = "raindrop.app.commit_dirty";
+var APP_BRANCH = "raindrop.app.branch";
+var APP_GIT_KEYS = [APP_COMMIT_SHA, APP_COMMIT_DIRTY, APP_BRANCH];
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function appGitExplicitKeys(properties) {
+  const keys = /* @__PURE__ */ new Set();
+  if (!properties) return keys;
+  for (const key of APP_GIT_KEYS) {
+    if (own(properties, key)) keys.add(key);
+  }
+  return keys;
+}
+function mergeAppGitSnapshot(base, properties, explicitKeys = /* @__PURE__ */ new Set()) {
+  try {
+    const result = { ...base };
+    if (properties && own(properties, APP_COMMIT_SHA) && properties[APP_COMMIT_SHA] !== result[APP_COMMIT_SHA]) {
+      if (!explicitKeys.has(APP_COMMIT_DIRTY) && !own(properties, APP_COMMIT_DIRTY)) {
+        delete result[APP_COMMIT_DIRTY];
+      }
+      if (!explicitKeys.has(APP_BRANCH) && !own(properties, APP_BRANCH)) {
+        delete result[APP_BRANCH];
+      }
+    }
+    for (const key of APP_GIT_KEYS) {
+      if (properties && own(properties, key)) result[key] = properties[key];
+    }
+    return Object.freeze(result);
+  } catch (e) {
+    return Object.freeze({});
+  }
+}
+function validAppCommitSha(value) {
+  if (typeof value !== "string" || value.length > 128) return void 0;
+  const cleaned = value.trim();
+  return /^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(cleaned) ? cleaned.toLowerCase() : void 0;
+}
+function shortString(value) {
+  if (typeof value !== "string" || value.length > 1024) return void 0;
+  const cleaned = value.trim();
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function flag(value) {
+  if (value === true || value === "true" || value === "1") return true;
+  if (value === false || value === "false" || value === "0") return false;
+  return void 0;
+}
+function environment() {
+  try {
+    return typeof process === "undefined" ? {} : process.env;
+  } catch (e) {
+    return {};
+  }
+}
+var DEPLOYMENTS = [
+  ["VERCEL", "VERCEL_GIT_COMMIT_SHA", "VERCEL_GIT_COMMIT_REF"],
+  ["NETLIFY", "COMMIT_REF", "BRANCH"],
+  ["RAILWAY_ENVIRONMENT_NAME", "RAILWAY_GIT_COMMIT_SHA", "RAILWAY_GIT_BRANCH"],
+  ["RAILWAY_ENVIRONMENT", "RAILWAY_GIT_COMMIT_SHA", "RAILWAY_GIT_BRANCH"],
+  ["RENDER", "RENDER_GIT_COMMIT", "RENDER_GIT_BRANCH"],
+  ["DYNO", "HEROKU_BUILD_COMMIT", ""],
+  ["DYNO", "HEROKU_SLUG_COMMIT", ""],
+  ["AWS_APP_ID", "AWS_COMMIT_ID", "AWS_BRANCH"],
+  ["WORKERS_CI", "WORKERS_CI_COMMIT_SHA", "WORKERS_CI_BRANCH"]
+];
+var CI_SOURCES = [
+  ["GITHUB_ACTIONS", "GITHUB_SHA", "GITHUB_REF_NAME"],
+  ["GITLAB_CI", "CI_COMMIT_SHA", "CI_COMMIT_REF_NAME"],
+  ["CIRCLECI", "CIRCLE_SHA1", "CIRCLE_BRANCH"]
+];
+function detectedSource(env, table, detectBranch) {
+  for (const row of table) {
+    const [marker, shaKey, branchKey] = row;
+    if (!marker || !shaKey || !shortString(env[marker]) || flag(env[marker]) === false) continue;
+    const commitSha = validAppCommitSha(env[shaKey]);
+    if (commitSha)
+      return {
+        commitSha,
+        ...detectBranch && branchKey ? { branch: shortString(env[branchKey]) } : {}
+      };
+  }
+  return {};
+}
+var AppGitContextImpl = class {
+  constructor(options, runtime = {}) {
+    this.defaults = {};
+    this.explicit = {};
+    this.explicitKeys = /* @__PURE__ */ new Set();
+    this.disposed = false;
+    this.operations = /* @__PURE__ */ new Map();
+    this.operationOverflow = false;
+    this.detectBranch = false;
+    this.disabled = false;
+    var _a, _b, _c, _d, _e, _f;
+    try {
+      if (options === false) {
+        this.disabled = true;
+        return;
+      }
+      const opts = options != null ? options : {};
+      const env = (_a = runtime.env) != null ? _a : environment();
+      const detectBranch = (_c = (_b = flag(opts.detectBranch)) != null ? _b : flag(env.RAINDROP_GIT_DETECT_BRANCH)) != null ? _c : false;
+      this.detectBranch = detectBranch;
+      const collectBranch = detectBranch || runtime.captureLegacyReplayBranch === true;
+      const autoDetect = runtime.allowDiscovery === false ? false : (_e = (_d = flag(opts.autoDetect)) != null ? _d : flag(env.RAINDROP_GIT_AUTO_DETECT)) != null ? _e : true;
+      const configuredSha = opts.commitSha;
+      const explicitSha = configuredSha === void 0 ? env.RAINDROP_COMMIT_SHA : configuredSha;
+      if (explicitSha === null) this.explicit[APP_COMMIT_SHA] = null;
+      else if (typeof explicitSha === "string" && validAppCommitSha(explicitSha))
+        this.explicit[APP_COMMIT_SHA] = explicitSha;
+      const configuredDirty = opts.commitDirty;
+      const explicitDirty = configuredDirty === void 0 ? flag(env.RAINDROP_COMMIT_DIRTY) : configuredDirty;
+      if (explicitDirty === null || typeof explicitDirty === "boolean")
+        this.explicit[APP_COMMIT_DIRTY] = explicitDirty;
+      const configuredBranch = opts.branch;
+      const explicitBranch = configuredBranch === void 0 ? env.RAINDROP_BRANCH : configuredBranch;
+      if (explicitBranch === null) this.explicit[APP_BRANCH] = null;
+      else if (typeof explicitBranch === "string" && explicitBranch.length <= 1024)
+        this.explicit[APP_BRANCH] = explicitBranch;
+      this.explicitKeys = appGitExplicitKeys(this.explicit);
+      this.defaults = { ...this.explicit };
+      if (!autoDetect || explicitSha !== void 0) return;
+      const sourceDirectory = (_f = shortString(opts.sourceDirectory)) != null ? _f : shortString(env.RAINDROP_GIT_SOURCE_DIRECTORY);
+      if (runtime.allowLocalGit === false && !sourceDirectory) return;
+      const deploy = sourceDirectory ? {} : detectedSource(env, DEPLOYMENTS, collectBranch);
+      if (deploy.commitSha) {
+        this.accept(deploy);
+        return;
+      }
+      const fallback = sourceDirectory ? {} : detectedSource(env, CI_SOURCES, collectBranch);
+      if (runtime.resolveLocal && (runtime.allowLocalGit !== false || sourceDirectory)) {
+        this.cancel = runtime.resolveLocal(sourceDirectory, collectBranch, (result) => {
+          try {
+            if (!this.disposed) this.accept(result.commitSha ? result : fallback);
+          } catch (e) {
+          }
+        });
+      } else this.accept(fallback);
+    } catch (e) {
+    }
+  }
+  accept(result) {
+    const sha = validAppCommitSha(result.commitSha);
+    if (!sha) return;
+    this.replayBranch = shortString(result.branch);
+    this.defaults = {
+      [APP_COMMIT_SHA]: sha,
+      ...typeof result.commitDirty === "boolean" ? { [APP_COMMIT_DIRTY]: result.commitDirty } : {},
+      ...this.detectBranch && this.replayBranch ? { [APP_BRANCH]: this.replayBranch } : {},
+      ...this.explicit
+    };
+  }
+  snapshot(properties) {
+    var _a;
+    try {
+      const binding = currentRoutingBinding();
+      const base = this.disabled && (binding == null ? void 0 : binding.appGitSource) !== "replay-override" ? {} : (_a = binding == null ? void 0 : binding.appGit) != null ? _a : this.defaults;
+      return this.mergeSnapshot(base, properties);
+    } catch (e) {
+      return Object.freeze({});
+    }
+  }
+  /** Safe defaults when no operation/span start was observed; never infer identity. */
+  snapshotExplicit(properties, eventId) {
+    try {
+      const base = { ...this.explicit };
+      const operation = eventId ? this.operations.get(eventId) : void 0;
+      if (operation) {
+        for (const key of operation.explicitKeys) base[key] = operation.snapshot[key];
+      }
+      return this.mergeSnapshot(base, properties, new Set(Object.keys(base)));
+    } catch (e) {
+      return mergeAppGitSnapshot({}, properties);
+    }
+  }
+  /** Existing replay branch reporting stays separate from opt-in event properties. */
+  snapshotForReplay() {
+    const snapshot = this.snapshot();
+    if (this.replayBranch && !own(snapshot, APP_BRANCH) && snapshot[APP_COMMIT_SHA] === this.defaults[APP_COMMIT_SHA]) {
+      return Object.freeze({ ...snapshot, [APP_BRANCH]: this.replayBranch });
+    }
+    return snapshot;
+  }
+  /** Merge a frozen span snapshot without losing client-authored provenance. */
+  mergeSnapshot(base, properties, explicitKeys = this.explicitKeys) {
+    return mergeAppGitSnapshot(base, properties, /* @__PURE__ */ new Set([...this.explicitKeys, ...explicitKeys]));
+  }
+  /** Shippers belonging to one client share this bounded operation registry. */
+  forOperation(eventId, properties, owner) {
+    if (!eventId) return this.snapshot(properties);
+    let operation = this.operations.get(eventId);
+    if (!operation) {
+      if (this.operations.size >= 1e4) this.operationOverflow = true;
+      if (this.operationOverflow) return this.mergeSnapshot({}, properties);
+      operation = {
+        snapshot: this.snapshot(properties),
+        owners: /* @__PURE__ */ new Set(),
+        unowned: owner === void 0,
+        explicitKeys: appGitExplicitKeys(properties)
+      };
+      this.operations.set(eventId, operation);
+    } else if (properties && APP_GIT_KEYS.some((key) => own(properties, key))) {
+      const explicitKeys = /* @__PURE__ */ new Set([...this.explicitKeys, ...operation.explicitKeys]);
+      operation.snapshot = this.mergeSnapshot(operation.snapshot, properties, explicitKeys);
+      for (const key of appGitExplicitKeys(properties)) operation.explicitKeys.add(key);
+    }
+    if (!owner) operation.unowned = true;
+    if (owner) operation.owners.add(owner);
+    return operation.snapshot;
+  }
+  releaseOperation(eventId, owner) {
+    const operation = this.operations.get(eventId);
+    if (!operation) return;
+    operation.owners.delete(owner);
+    if (operation.owners.size === 0 && !operation.unowned) this.operations.delete(eventId);
+  }
+  finishOperation(eventId) {
+    this.operations.delete(eventId);
+  }
+  dispose() {
+    var _a;
+    this.disposed = true;
+    try {
+      (_a = this.cancel) == null ? void 0 : _a.call(this);
+    } catch (e) {
+    }
+  }
+};
+var AppGitContext = AppGitContextImpl;
+function withAppGitAttributes(attributes, snapshot) {
+  try {
+    const present = new Set(attributes.flatMap((attr) => attr ? [attr.key] : []));
+    const added = [];
+    for (const key of APP_GIT_KEYS) {
+      if (present.has(key) || present.has(`ai.telemetry.metadata.${key}`) || present.has(`traceloop.association.properties.${key}`))
+        continue;
+      const value = snapshot[key];
+      if (typeof value === "string") added.push({ key, value: { stringValue: value } });
+      else if (typeof value === "boolean") added.push({ key, value: { boolValue: value } });
+    }
+    return added.length ? [...attributes, ...added] : attributes;
+  } catch (e) {
+    return attributes;
+  }
+}
+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 runWithTracingSuppressed(fn) {
+  const hook = globalThis.RAINDROP_SUPPRESS_TRACING;
+  if (typeof hook !== "function") return fn();
+  let started = false;
+  try {
+    return hook(() => {
+      started = true;
+      return fn();
+    });
+  } catch (err) {
+    if (started) throw err;
+    return fn();
+  }
+}
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_RETRY_DELAY_MS = 3e4;
+function wait(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, 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 runWithTracingSuppressed(
+        () => fetch(url, {
+          method: "POST",
+          redirect: headers["X-Raindrop-Replay-Id"] !== void 0 ? "error" : "follow",
+          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;
+}
+var LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS = 2e3;
+function mirrorTraceExportToLocalDebugger(body, options = {}) {
+  var _a;
+  const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
+  if (!baseUrl) return Promise.resolve();
+  return postJson(`${baseUrl}traces`, body, {}, {
+    maxAttempts: 1,
+    debug: (_a = options.debug) != null ? _a : false,
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
+  }).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);
+var resolveLocal = (sourceDirectory, detectBranch, completed) => {
+  const cwd = sourceDirectory ? resolve(sourceDirectory) : process.cwd();
+  let cancelled = false;
+  let active;
+  let deadlineTimer;
+  const deadline = Date.now() + 1e3;
+  const run = (args, done) => {
+    if (cancelled) return;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      done(void 0);
+      return;
+    }
+    try {
+      active = execFile(
+        "git",
+        args,
+        {
+          cwd,
+          encoding: "utf8",
+          maxBuffer: 4096,
+          windowsHide: true,
+          env: {
+            ...process.env,
+            // The selected application cwd, not the invoking shell's Git plumbing, owns identity.
+            GIT_DIR: void 0,
+            GIT_WORK_TREE: void 0,
+            GIT_COMMON_DIR: void 0,
+            GIT_NAMESPACE: void 0,
+            GIT_INDEX_FILE: void 0,
+            GIT_OBJECT_DIRECTORY: void 0,
+            GIT_ALTERNATE_OBJECT_DIRECTORIES: void 0,
+            GIT_CONFIG_PARAMETERS: void 0,
+            GIT_CONFIG_COUNT: "0",
+            GIT_TERMINAL_PROMPT: "0",
+            GIT_OPTIONAL_LOCKS: "0"
+          }
+        },
+        (error, stdout) => {
+          clearTimeout(deadlineTimer);
+          deadlineTimer = void 0;
+          active = void 0;
+          if (!cancelled) {
+            try {
+              done(error ? void 0 : stdout.trim());
+            } catch (e) {
+            }
+          }
+        }
+      );
+      active.unref();
+      if (active.stdout && "unref" in active.stdout && typeof active.stdout.unref === "function")
+        active.stdout.unref();
+      if (active.stderr && "unref" in active.stderr && typeof active.stderr.unref === "function")
+        active.stderr.unref();
+      deadlineTimer = setTimeout(() => {
+        try {
+          active == null ? void 0 : active.kill("SIGKILL");
+        } catch (e) {
+        }
+      }, remaining);
+      deadlineTimer.unref();
+    } catch (e) {
+      try {
+        done(void 0);
+      } catch (e2) {
+      }
+    }
+  };
+  const scheduled = setTimeout(() => {
+    try {
+      run(["rev-parse", "HEAD"], (rawSha) => {
+        const commitSha = validAppCommitSha(rawSha);
+        if (!commitSha) {
+          completed({});
+          return;
+        }
+        run(["-c", "core.fsmonitor=false", "status", "--porcelain"], (status) => {
+          const finish = (branch) => {
+            run(["rev-parse", "HEAD"], (finalSha) => {
+              const coherent = validAppCommitSha(finalSha) === commitSha;
+              completed({
+                commitSha,
+                ...coherent && status !== void 0 ? { commitDirty: status !== "" } : {},
+                ...coherent && branch && branch !== "HEAD" ? { branch } : {}
+              });
+            });
+          };
+          if (detectBranch) run(["symbolic-ref", "--quiet", "--short", "HEAD"], finish);
+          else finish();
+        });
+      });
+    } catch (e) {
+      completed({});
+    }
+  }, 0);
+  scheduled.unref();
+  return () => {
+    cancelled = true;
+    clearTimeout(scheduled);
+    clearTimeout(deadlineTimer);
+    try {
+      active == null ? void 0 : active.kill("SIGKILL");
+    } catch (e) {
+    }
+  };
+};
+function createAppGitContext(options, runtime = {}) {
+  return new AppGitContext(options, { ...runtime, resolveLocal });
+}
+globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = AsyncLocalStorage;
+var SUPPRESS_TRACING_KEY = /* @__PURE__ */ Symbol.for(
+  "OpenTelemetry SDK Context Key SUPPRESS_TRACING"
+);
+function findOtelContextManager() {
+  var _a;
+  for (const sym of Object.getOwnPropertySymbols(globalThis)) {
+    if (!((_a = sym.description) == null ? void 0 : _a.startsWith("opentelemetry.js.api."))) continue;
+    const api = globalThis[sym];
+    const cm = api == null ? void 0 : api.context;
+    if (cm && typeof cm.with === "function" && typeof cm.active === "function") {
+      return cm;
+    }
+  }
+  return void 0;
+}
+function installTracingSuppressionHook() {
+  if (typeof globalThis.RAINDROP_SUPPRESS_TRACING === "function") return;
+  const hook = (fn) => {
+    const cm = findOtelContextManager();
+    if (!cm) return fn();
+    return cm.with(cm.active().setValue(SUPPRESS_TRACING_KEY, true), fn);
+  };
+  globalThis.RAINDROP_SUPPRESS_TRACING = hook;
+}
+installTracingSuppressionHook();
 function parseEveSessionParent(value) {
   if (typeof value !== "object" || value === null) return void 0;
   const p = value;
@@ -137,346 +920,79 @@ var EveTurnRegistry = class {
       }
       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 };
-function runWithTracingSuppressed(fn) {
-  const hook = globalThis.RAINDROP_SUPPRESS_TRACING;
-  if (typeof hook !== "function") return fn();
-  let started = false;
-  try {
-    return hook(() => {
-      started = true;
-      return fn();
-    });
-  } catch (err) {
-    if (started) throw err;
-    return fn();
-  }
-}
-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 runWithTracingSuppressed(
-        () => 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
+      }
+    });
+  }
+  /**
+   * 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;
+  }
 };
-function buildExportTraceServiceRequest(spans, serviceName = "raindrop.core", serviceVersion = "0.0.0") {
+var registry = new EveTurnRegistry();
+function createEveTurnSpanProcessor() {
   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];
+    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();
     }
-  } 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 lookupEveTurn(traceId) {
+  return registry.lookup(traceId);
 }
-function readRuntimeHostname() {
+function installEveTurnSpanProcessor(traceApi) {
+  if (installState.installed) return true;
   try {
-    const loc = globalThis == null ? void 0 : globalThis.location;
-    if (loc && typeof loc.hostname === "string" && loc.hostname.length > 0) {
-      return loc.hostname;
+    let provider = traceApi.getTracerProvider();
+    const proxyProvider = provider;
+    if (typeof proxyProvider.getDelegate === "function") {
+      const delegate = proxyProvider.getDelegate();
+      if (delegate) provider = delegate;
     }
-  } 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 = AsyncLocalStorage;
-var SUPPRESS_TRACING_KEY = /* @__PURE__ */ Symbol.for(
-  "OpenTelemetry SDK Context Key SUPPRESS_TRACING"
-);
-function findOtelContextManager() {
-  var _a;
-  for (const sym of Object.getOwnPropertySymbols(globalThis)) {
-    if (!((_a = sym.description) == null ? void 0 : _a.startsWith("opentelemetry.js.api."))) continue;
-    const api = globalThis[sym];
-    const cm = api == null ? void 0 : api.context;
-    if (cm && typeof cm.with === "function" && typeof cm.active === "function") {
-      return cm;
+    const tp = provider;
+    if (typeof tp.addSpanProcessor !== "function") {
+      return false;
     }
+    tp.addSpanProcessor(createEveTurnSpanProcessor());
+    installState.installed = true;
+    return true;
+  } catch {
+    return false;
   }
-  return void 0;
-}
-function installTracingSuppressionHook() {
-  if (typeof globalThis.RAINDROP_SUPPRESS_TRACING === "function") return;
-  const hook = (fn) => {
-    const cm = findOtelContextManager();
-    if (!cm) return fn();
-    return cm.with(cm.active().setValue(SUPPRESS_TRACING_KEY, true), fn);
-  };
-  globalThis.RAINDROP_SUPPRESS_TRACING = hook;
 }
-installTracingSuppressionHook();
+var installState = { installed: false };
 
 // src/internal/limits.ts
 var DEFAULT_MAX_TEXT_FIELD_CHARS2 = 1e6;
@@ -504,6 +1020,13 @@ function truncateText(value, limit) {
 }
 
 // src/internal/exporter.ts
+var EVE_APP_GIT_OWNER_PREFIX = "eve-trace";
+var MAX_EVE_APP_GIT_ACTIVE_EVENTS = 1e4;
+var APP_GIT_KEYS2 = [
+  "raindrop.app.commit_sha",
+  "raindrop.app.commit_dirty",
+  "raindrop.app.branch"
+];
 function hexToBase64(hex) {
   if (!hex) return void 0;
   if (hex.length === 0 || /^0+$/.test(hex)) return void 0;
@@ -556,6 +1079,45 @@ function attributesToKeyValues(attrs, maxChars) {
   }
   return out;
 }
+function eventIdFromAttributes(attrs) {
+  if (!attrs) return void 0;
+  const value = attrs["raindrop.eventId"] ?? attrs["ai.telemetry.metadata.raindrop.eventId"] ?? attrs["traceloop.association.properties.event_id"];
+  return typeof value === "string" ? value : void 0;
+}
+function appGitPropertiesFromReadableAttributes(attrs) {
+  const properties = {};
+  if (!attrs) return properties;
+  for (const key of ["raindrop.app.commit_sha", "raindrop.app.commit_dirty", "raindrop.app.branch"]) {
+    for (const attributeKey of [key, `ai.telemetry.metadata.${key}`, `traceloop.association.properties.${key}`]) {
+      if (Object.prototype.hasOwnProperty.call(attrs, attributeKey)) {
+        properties[key] = attrs[attributeKey];
+        break;
+      }
+    }
+  }
+  return properties;
+}
+function appGitExplicitKeys2(properties) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const key of APP_GIT_KEYS2) {
+    if (Object.prototype.hasOwnProperty.call(properties, key)) keys.add(key);
+  }
+  return keys;
+}
+function appGitOwnerId(prefix) {
+  try {
+    return `${prefix}:${randomUUID()}`;
+  } catch {
+    return `${prefix}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+  }
+}
+function explicitAppGitSnapshot(context, properties, eventId) {
+  try {
+    return context.snapshotExplicit?.(properties, eventId) ?? properties;
+  } catch {
+    return properties;
+  }
+}
 function statusFromReadable(span) {
   const code = span.status?.code;
   if (code === void 0) return void 0;
@@ -567,7 +1129,7 @@ function statusFromReadable(span) {
   }
   return { code: SpanStatusCode.UNSET };
 }
-function readableSpanToOtlp(span, maxChars) {
+function readableSpanToOtlp(span, maxChars, appGitContext, operationEventId, appGitOwner, appGitExplicitOnly, startedAppGitSnapshot, startedAppGitExplicitKeys) {
   const ctx = span.spanContext();
   const parentSpanIdHex = span.parentSpanContext?.spanId ?? span.parentSpanId;
   const traceId = hexToBase64(ctx.traceId);
@@ -578,7 +1140,17 @@ function readableSpanToOtlp(span, maxChars) {
     );
   }
   const parentSpanId = hexToBase64(parentSpanIdHex);
-  const attrs = attributesToKeyValues(span.attributes, maxChars);
+  eventIdFromAttributes(span.attributes);
+  const appProperties = appGitPropertiesFromReadableAttributes(span.attributes);
+  const appGitSnapshot = startedAppGitSnapshot !== void 0 ? appGitContext.mergeSnapshot ? appGitContext.mergeSnapshot(startedAppGitSnapshot, appProperties, startedAppGitExplicitKeys) : mergeAppGitSnapshot(startedAppGitSnapshot, appProperties, startedAppGitExplicitKeys) : appGitExplicitOnly ? explicitAppGitSnapshot(appGitContext, appProperties, operationEventId) : appGitContext.forOperation(
+    operationEventId,
+    appProperties,
+    operationEventId ? appGitOwner : void 0
+  );
+  const attrs = withAppGitAttributes(
+    attributesToKeyValues(span.attributes, maxChars),
+    appGitSnapshot
+  ).filter((attribute) => attribute !== void 0);
   const otlp = {
     traceId,
     spanId,
@@ -593,7 +1165,10 @@ function readableSpanToOtlp(span, maxChars) {
   return otlp;
 }
 var RaindropEveSpanExporter = class {
-  constructor(opts = {}) {
+  constructor(opts = {}, appGitContext) {
+    this.startedAppGitSpans = /* @__PURE__ */ new WeakMap();
+    this.activeAppGitEvents = /* @__PURE__ */ new Map();
+    this.appGitOwner = appGitOwnerId(EVE_APP_GIT_OWNER_PREFIX);
     this.inFlight = /* @__PURE__ */ new Set();
     this.shuttingDown = false;
     this.auxShutdowns = [];
@@ -611,6 +1186,10 @@ var RaindropEveSpanExporter = class {
     });
     const explicit = opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl;
     this.localDebuggerUrl = resolveLocalDebuggerBaseUrl(explicit) ?? void 0;
+    this.appGitContext = appGitContext ?? createAppGitContext(
+      this.writeKey || this.localDebuggerUrl ? opts.appGit : false,
+      { allowLocalGit: false }
+    );
     if (this.debug) {
       console.log(
         `${this.prefix} Initialized`,
@@ -625,6 +1204,55 @@ var RaindropEveSpanExporter = class {
   hasDestinations() {
     return Boolean(this.writeKey || this.localDebuggerUrl);
   }
+  captureSpanStart(span) {
+    if (this.startedAppGitSpans.has(span)) return;
+    const eventId = eventIdFromAttributes(span.attributes);
+    const appProperties = appGitPropertiesFromReadableAttributes(span.attributes);
+    const snapshot = this.appGitContext.forOperation(
+      eventId,
+      appProperties,
+      eventId ? this.appGitOwner : void 0
+    );
+    if (!eventId) {
+      this.startedAppGitSpans.set(span, {
+        eventId: void 0,
+        snapshot,
+        explicitKeys: appGitExplicitKeys2(appProperties)
+      });
+      return;
+    }
+    const tracksAppGit = this.activeAppGitEvents.has(eventId) || this.activeAppGitEvents.size < MAX_EVE_APP_GIT_ACTIVE_EVENTS;
+    if (tracksAppGit) {
+      this.activeAppGitEvents.set(eventId, (this.activeAppGitEvents.get(eventId) ?? 0) + 1);
+      this.startedAppGitSpans.set(span, {
+        eventId,
+        snapshot,
+        explicitKeys: appGitExplicitKeys2(appProperties)
+      });
+    } else {
+      this.appGitContext.releaseOperation?.(eventId, this.appGitOwner);
+    }
+  }
+  releaseStartedAppGitSpan(span, eventId) {
+    const started = this.startedAppGitSpans.get(span);
+    const startedEventId = started?.eventId;
+    this.startedAppGitSpans.delete(span);
+    const trackedEventId = startedEventId ?? eventId;
+    if (!trackedEventId || !this.appGitContext.releaseOperation) return;
+    if (!startedEventId) {
+      if (!this.activeAppGitEvents.has(trackedEventId)) {
+        this.appGitContext.releaseOperation(trackedEventId, this.appGitOwner);
+      }
+      return;
+    }
+    const remaining = (this.activeAppGitEvents.get(startedEventId) ?? 1) - 1;
+    if (remaining > 0) {
+      this.activeAppGitEvents.set(startedEventId, remaining);
+      return;
+    }
+    this.activeAppGitEvents.delete(startedEventId);
+    this.appGitContext.releaseOperation(startedEventId, this.appGitOwner);
+  }
   /**
    * Update the OTLP `service.name` attribute. Called by Eve's
    * `setup({ agentName })` so the resource attribute reflects the actual
@@ -649,12 +1277,28 @@ var RaindropEveSpanExporter = class {
     const maxChars = effectiveAttributeLimit(this.maxTextFieldChars);
     const otlpSpans = [];
     for (const span of spans) {
+      const eventId = eventIdFromAttributes(span.attributes);
+      const startedAppGit = this.startedAppGitSpans.get(span);
+      const appGitExplicitOnly = startedAppGit === void 0;
       try {
-        otlpSpans.push(readableSpanToOtlp(span, maxChars));
+        otlpSpans.push(
+          readableSpanToOtlp(
+            span,
+            maxChars,
+            this.appGitContext,
+            startedAppGit?.eventId ?? eventId,
+            this.appGitOwner,
+            appGitExplicitOnly,
+            startedAppGit?.eventId ? void 0 : startedAppGit?.snapshot,
+            startedAppGit?.eventId ? void 0 : startedAppGit?.explicitKeys
+          )
+        );
       } catch (err) {
         if (this.debug) {
           console.warn(`${this.prefix} failed to convert span`, err);
         }
+      } finally {
+        this.releaseStartedAppGitSpan(span, eventId);
       }
     }
     if (otlpSpans.length === 0) {
@@ -706,11 +1350,18 @@ var RaindropEveSpanExporter = class {
   }
   async shutdown() {
     this.shuttingDown = true;
-    await this.forceFlush();
-    await Promise.all(
-      this.auxShutdowns.map((fn) => fn().catch(() => {
-      }))
-    );
+    try {
+      await this.forceFlush();
+      await Promise.all(
+        this.auxShutdowns.map((fn) => fn().catch(() => {
+        }))
+      );
+    } finally {
+      try {
+        this.appGitContext.dispose();
+      } catch {
+      }
+    }
   }
   /**
    * Register an extra teardown hook to run during {@link shutdown}. Used to
@@ -723,11 +1374,44 @@ var RaindropEveSpanExporter = class {
     this.auxShutdowns.push(fn);
   }
 };
+function installEveAppGitSpanProcessor(traceApi, exporter) {
+  try {
+    let provider = traceApi.getTracerProvider();
+    if (provider === null || typeof provider !== "object" && typeof provider !== "function") return false;
+    if ("getDelegate" in provider && typeof provider.getDelegate === "function") {
+      const delegate = provider.getDelegate();
+      if (delegate) provider = delegate;
+    }
+    if (provider === null || typeof provider !== "object" && typeof provider !== "function" || !("addSpanProcessor" in provider) || typeof provider.addSpanProcessor !== "function") return false;
+    provider.addSpanProcessor(createEveAppGitSpanProcessor(exporter));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createEveAppGitSpanProcessor(exporter) {
+  return {
+    onStart(span) {
+      try {
+        exporter.captureSpanStart(span);
+      } catch {
+      }
+    },
+    onEnd() {
+    },
+    forceFlush() {
+      return Promise.resolve();
+    },
+    shutdown() {
+      return Promise.resolve();
+    }
+  };
+}
 
 // package.json
 var package_default = {
   name: "@raindrop-ai/eve",
-  version: "0.0.22"};
+  version: "0.0.24"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -1009,18 +1693,21 @@ function buildEveStepStartedResolver(opts, staticMetadata) {
   };
 }
 function buildEveMetadataConfig(opts, staticMetadata) {
-  const resolve = buildEveStepStartedResolver(opts, staticMetadata);
-  return { "step.started": (input) => resolve(input) };
+  const resolve2 = buildEveStepStartedResolver(opts, staticMetadata);
+  return { "step.started": (input) => resolve2(input) };
 }
 function buildEveEventsConfig(opts, staticMetadata) {
-  const resolve = buildEveStepStartedResolver(opts, staticMetadata);
-  return { "step.started": (input) => ({ runtimeContext: resolve(input) }) };
+  const resolve2 = buildEveStepStartedResolver(opts, staticMetadata);
+  return { "step.started": (input) => ({ runtimeContext: resolve2(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 localWorkshopInput = opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl;
+  const hasDestination = Boolean(writeKey?.trim()) || Boolean(resolveLocalDebuggerBaseUrl(localWorkshopInput));
+  const appGitContext = createAppGitContext(hasDestination ? opts.appGit : false, { allowLocalGit: false });
   const exporter = new RaindropEveSpanExporter({
     writeKey,
     endpoint,
@@ -1031,7 +1718,7 @@ function defineRaindropInstrumentation(opts = {}) {
     sdkName: "eve",
     debug,
     maxTextFieldChars: opts.maxTextFieldChars
-  });
+  }, appGitContext);
   const localWorkshopUrl = opts.localWorkshopUrl === false ? false : opts.localWorkshopUrl;
   const raindrop = createRaindropAISDK({
     writeKey,
@@ -1039,7 +1726,8 @@ function defineRaindropInstrumentation(opts = {}) {
     projectId,
     localWorkshopUrl,
     events: { debug },
-    traces: { debug }
+    traces: { debug },
+    appGitContext
   });
   exporter.attachAuxShutdown(() => raindrop.shutdown());
   const prefix = "[raindrop-ai/eve]";
@@ -1068,8 +1756,13 @@ function defineRaindropInstrumentation(opts = {}) {
         if (already === void 0) {
           opts.registerOTel({
             serviceName,
-            traceExporter: exporter
+            traceExporter: exporter,
+            spanProcessors: [
+              "auto",
+              createEveAppGitSpanProcessor(exporter)
+            ]
           });
+          installEveAppGitSpanProcessor(trace, exporter);
           g[RAINDROP_EVE_OTEL_REGISTERED] = { exporter };
           if (debug) {
             console.log(`${prefix} registered OTel for serviceName=${serviceName}`);
@@ -1113,6 +1806,6 @@ function defineRaindropInstrumentation(opts = {}) {
 }
 var index_default = defineRaindropInstrumentation;
 
-export { RAINDROP_EVE_SDK_NAME, RAINDROP_EVE_SDK_VERSION, RaindropEveSpanExporter, _resetCanonicalTurnIds, index_default as default, defineRaindropInstrumentation };
+export { RAINDROP_EVE_SDK_NAME, RAINDROP_EVE_SDK_VERSION, RaindropEveSpanExporter, _resetCanonicalTurnIds, createEveAppGitSpanProcessor, index_default as default, defineRaindropInstrumentation };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map