@raindrop-ai/deep-agents 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -63,7 +63,459 @@ function evalScopeAttributes() {
   return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
 }
 
-// ../core/dist/chunk-T53LQAH7.js
+// ../core/dist/chunk-WJOR6M7H.js
+var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
+function state() {
+  const holder = globalThis;
+  let current = holder[STATE_KEY];
+  if (!current) {
+    let storage = null;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (Ctor) storage = new Ctor();
+    } catch (e) {
+      storage = null;
+    }
+    current = {
+      storage,
+      syncDestination: void 0,
+      spanDestinations: /* @__PURE__ */ new WeakMap()
+    };
+    holder[STATE_KEY] = current;
+  }
+  return current;
+}
+function currentReplayTraceDestination() {
+  var _a, _b;
+  const routing = state();
+  return (_b = (_a = routing.storage) == null ? void 0 : _a.getStore()) != null ? _b : routing.syncDestination;
+}
+function rememberReplayTraceDestination(span) {
+  const destination = currentReplayTraceDestination();
+  if (destination) state().spanDestinations.set(span, destination);
+}
+function copyReplayTraceDestination(source, target) {
+  const destination = state().spanDestinations.get(source);
+  if (destination) state().spanDestinations.set(target, destination);
+}
+function replayTraceDestinationFor(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return void 0;
+  }
+  return state().spanDestinations.get(value);
+}
+function recordReplayExportedSpan(destination, spanId, traceId) {
+  var _a, _b;
+  if (!destination || !spanId || !traceId) return;
+  (_a = destination.exportedSpanIds) == null ? void 0 : _a.add(spanId);
+  (_b = destination.exportedTraceIds) == null ? void 0 : _b.add(traceId);
+}
+function replayTraceUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
+}
+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 createAppGitContext(options, runtime = {}) {
+  return new AppGitContext(options, runtime);
+}
+function withAppGitProperties(properties, snapshot) {
+  try {
+    const merged = { ...properties };
+    for (const key of APP_GIT_KEYS)
+      if (!own(merged, key) && own(snapshot, key)) merged[key] = snapshot[key];
+    return merged;
+  } catch (e) {
+    return properties != null ? properties : {};
+  }
+}
+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 appGitPropertiesFromAttributes(attributes) {
+  var _a, _b, _c;
+  const properties = {};
+  try {
+    for (const attr of attributes) {
+      if (!attr) continue;
+      for (const key of APP_GIT_KEYS) {
+        if (attr.key === key || attr.key === `ai.telemetry.metadata.${key}` || attr.key === `traceloop.association.properties.${key}`) {
+          properties[key] = (_c = (_b = (_a = attr.value.stringValue) != null ? _a : attr.value.boolValue) != null ? _b : attr.value.intValue) != null ? _c : null;
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return properties;
+}
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -168,7 +620,7 @@ function runWithTracingSuppressed(fn) {
 var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 var MAX_RETRY_DELAY_MS = 3e4;
 function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function formatEndpoint(endpoint) {
   if (!endpoint) return void 0;
@@ -205,9 +657,9 @@ async function raceWithTimeout(promise, timeoutMs) {
       () => true,
       () => true
     ),
-    new Promise((resolve) => {
+    new Promise((resolve2) => {
       var _a;
-      timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+      timer = setTimeout(() => resolve2(false), Math.max(0, timeoutMs));
       (_a = timer.unref) == null ? void 0 : _a.call(timer);
     })
   ]);
@@ -380,55 +832,6 @@ function buildExportTraceServiceRequest(spans, serviceName = "raindrop.core", se
     ]
   };
 }
-var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
-function state() {
-  const holder = globalThis;
-  let current = holder[STATE_KEY];
-  if (!current) {
-    let storage = null;
-    try {
-      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
-      if (Ctor) storage = new Ctor();
-    } catch (e) {
-      storage = null;
-    }
-    current = {
-      storage,
-      syncDestination: void 0,
-      spanDestinations: /* @__PURE__ */ new WeakMap()
-    };
-    holder[STATE_KEY] = current;
-  }
-  return current;
-}
-function currentReplayTraceDestination() {
-  var _a, _b;
-  const routing = state();
-  return (_b = (_a = routing.storage) == null ? void 0 : _a.getStore()) != null ? _b : routing.syncDestination;
-}
-function rememberReplayTraceDestination(span) {
-  const destination = currentReplayTraceDestination();
-  if (destination) state().spanDestinations.set(span, destination);
-}
-function copyReplayTraceDestination(source, target) {
-  const destination = state().spanDestinations.get(source);
-  if (destination) state().spanDestinations.set(target, destination);
-}
-function replayTraceDestinationFor(value) {
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return void 0;
-  }
-  return state().spanDestinations.get(value);
-}
-function recordReplayExportedSpan(destination, spanId, traceId) {
-  var _a, _b;
-  if (!destination || !spanId || !traceId) return;
-  (_a = destination.exportedSpanIds) == null ? void 0 : _a.add(spanId);
-  (_b = destination.exportedTraceIds) == null ? void 0 : _b.add(traceId);
-}
-function replayTraceUrl(baseUrl) {
-  return `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
-}
 var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
 var WORKSHOP_ENV_VAR = "RAINDROP_WORKSHOP";
 var DEFAULT_LOCAL_WORKSHOP_URL = "http://localhost:5899/v1/";
@@ -538,6 +941,13 @@ function projectIdHeaders(projectId) {
 }
 var SHUTDOWN_DEADLINE_MS = 1e4;
 var POST_SHUTDOWN_TIMEOUT_MS = 5e3;
+function appGitOwnerId(prefix) {
+  try {
+    return `${prefix}:${randomUUID()}`;
+  } catch (e) {
+    return `${prefix}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+  }
+}
 function mergePatches(target, source) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const out = { ...target, ...source };
@@ -587,22 +997,25 @@ function eventTelemetryProperties(patch) {
 }
 var EventShipper = class {
   constructor(opts) {
+    this.appGitOwner = appGitOwnerId("event");
     this.buffers = /* @__PURE__ */ new Map();
     this.sticky = /* @__PURE__ */ new Map();
     this.timers = /* @__PURE__ */ new Map();
     this.inFlight = /* @__PURE__ */ new Set();
     this.hasShutdown = false;
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
-    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    this.appGitContext = (_a = opts.appGitContext) != null ? _a : createAppGitContext(opts.appGit);
+    this.ownsAppGitContext = opts.appGitContext === void 0;
+    this.writeKey = (_b = opts.writeKey) == null ? void 0 : _b.trim();
+    this.baseUrl = (_c = formatEndpoint(opts.endpoint)) != null ? _c : "https://api.raindrop.ai/v1/";
     this.enabled = opts.enabled !== false;
     this.debug = opts.debug;
-    this.partialFlushMs = (_c = opts.partialFlushMs) != null ? _c : 1e3;
-    this.sdkName = (_d = opts.sdkName) != null ? _d : "core";
+    this.partialFlushMs = (_d = opts.partialFlushMs) != null ? _d : 1e3;
+    this.sdkName = (_e = opts.sdkName) != null ? _e : "core";
     this.prefix = `[raindrop-ai/${this.sdkName}]`;
-    this.defaultEventName = (_e = opts.defaultEventName) != null ? _e : "ai_generation";
+    this.defaultEventName = (_f = opts.defaultEventName) != null ? _f : "ai_generation";
     this.maxTextFieldCharsOpt = opts.maxTextFieldChars;
-    this.localDebuggerUrl = (_f = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _f : void 0;
+    this.localDebuggerUrl = (_g = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _g : void 0;
     if (this.debug && this.localDebuggerUrl) {
       console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
     }
@@ -613,8 +1026,8 @@ var EventShipper = class {
     const isNode = typeof process !== "undefined" && typeof process.version === "string";
     this.context = {
       library: {
-        name: (_g = opts.libraryName) != null ? _g : "@raindrop-ai/core",
-        version: (_h = opts.libraryVersion) != null ? _h : "0.0.0"
+        name: (_h = opts.libraryName) != null ? _h : "@raindrop-ai/core",
+        version: (_i = opts.libraryVersion) != null ? _i : "0.0.0"
       },
       metadata: {
         jsRuntime: isNode ? "node" : "web",
@@ -622,6 +1035,9 @@ var EventShipper = class {
       }
     };
   }
+  ownAppGitContextForShutdown() {
+    this.ownsAppGitContext = true;
+  }
   isDebugEnabled() {
     return this.debug;
   }
@@ -700,6 +1116,13 @@ var EventShipper = class {
     }
     const sticky = (_c = this.sticky.get(eventId)) != null ? _c : {};
     const existing = (_d = this.buffers.get(eventId)) != null ? _d : {};
+    patch = {
+      ...patch,
+      properties: withAppGitProperties(
+        patch.properties,
+        this.appGitContext.forOperation(eventId, patch.properties, this.appGitOwner)
+      )
+    };
     const merged = mergePatches(existing, patch);
     merged.isPending = (_g = (_f = (_e = patch.isPending) != null ? _e : existing.isPending) != null ? _f : sticky.isPending) != null ? _g : true;
     this.buffers.set(eventId, merged);
@@ -713,6 +1136,8 @@ var EventShipper = class {
     if (t) clearTimeout(t);
     if (merged.isPending === false) {
       await this.flushOne(eventId);
+      if (this.appGitContext.releaseOperation) this.appGitContext.releaseOperation(eventId, this.appGitOwner);
+      else this.appGitContext.finishOperation(eventId);
       return;
     }
     const timeout = setTimeout(() => {
@@ -744,6 +1169,7 @@ var EventShipper = class {
       if (!settled) this.warnShutdownDrop("in-flight request(s) at shutdown");
     } finally {
       this.shutdownDeadlineAt = void 0;
+      if (this.ownsAppGitContext) this.appGitContext.dispose();
     }
   }
   async trackSignal(signal) {
@@ -1171,6 +1597,13 @@ function redactJsonAttributeValue(key, value) {
   if (scrubbedJson === json) return void 0;
   return { stringValue: scrubbedJson };
 }
+function appGitOwnerId2(prefix) {
+  try {
+    return `${prefix}:${randomUUID()}`;
+  } catch (e) {
+    return `${prefix}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+  }
+}
 function identityAttrs(args) {
   return [
     attrString("ai.telemetry.metadata.raindrop.ai.userId", args.userId),
@@ -1193,23 +1626,30 @@ function applyOtelSpanAttributeLimit(limit) {
 }
 var TraceShipper = class {
   constructor(opts) {
+    this.appGitOwner = appGitOwnerId2("trace");
+    this.appGitEventIds = /* @__PURE__ */ new WeakMap();
+    this.appGitActiveSpans = /* @__PURE__ */ new Map();
+    this.appGitCaptured = /* @__PURE__ */ new WeakSet();
+    this.appGitAdded = /* @__PURE__ */ new WeakMap();
     this.queue = [];
     this.inFlight = /* @__PURE__ */ new Set();
     this.hasShutdown = false;
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
-    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    this.appGitContext = (_a = opts.appGitContext) != null ? _a : createAppGitContext(opts.appGit);
+    this.ownsAppGitContext = opts.appGitContext === void 0;
+    this.writeKey = (_b = opts.writeKey) == null ? void 0 : _b.trim();
+    this.baseUrl = (_c = formatEndpoint(opts.endpoint)) != null ? _c : "https://api.raindrop.ai/v1/";
     this.enabled = opts.enabled !== false;
     this.debug = opts.debug;
     this.debugSpans = opts.debugSpans === true;
-    this.flushIntervalMs = (_c = opts.flushIntervalMs) != null ? _c : 1e3;
-    this.maxBatchSize = (_d = opts.maxBatchSize) != null ? _d : 50;
-    this.maxQueueSize = (_e = opts.maxQueueSize) != null ? _e : 5e3;
-    this.sdkName = (_f = opts.sdkName) != null ? _f : "core";
+    this.flushIntervalMs = (_d = opts.flushIntervalMs) != null ? _d : 1e3;
+    this.maxBatchSize = (_e = opts.maxBatchSize) != null ? _e : 50;
+    this.maxQueueSize = (_f = opts.maxQueueSize) != null ? _f : 5e3;
+    this.sdkName = (_g = opts.sdkName) != null ? _g : "core";
     this.prefix = `[raindrop-ai/${this.sdkName}]`;
-    this.serviceName = (_g = opts.serviceName) != null ? _g : "raindrop.core";
-    this.serviceVersion = (_h = opts.serviceVersion) != null ? _h : "0.0.0";
-    this.localDebuggerUrl = (_i = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _i : void 0;
+    this.serviceName = (_h = opts.serviceName) != null ? _h : "raindrop.core";
+    this.serviceVersion = (_i = opts.serviceVersion) != null ? _i : "0.0.0";
+    this.localDebuggerUrl = (_j = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _j : void 0;
     if (this.debug && this.localDebuggerUrl) {
       console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
     }
@@ -1310,7 +1750,7 @@ var TraceShipper = class {
     return { ...this.authHeaders(), ...projectIdHeaders(this.projectId) };
   }
   startSpan(args) {
-    var _a, _b;
+    var _a, _b, _c;
     const ids = createSpanIds(args.parent);
     const started = (_a = args.startTimeUnixNano) != null ? _a : nowUnixNanoString();
     const attrs = [
@@ -1320,13 +1760,24 @@ var TraceShipper = class {
       ...Object.entries(evalScopeAttributes()).map(([key, value]) => attrString(key, value))
     ];
     if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
+    const tracksAppGit = this.appGitActiveSpans.has(args.eventId) || this.appGitActiveSpans.size < 1e4;
+    const appGitOverrides = appGitPropertiesFromAttributes(attrs);
     const span = {
       ids,
       name: args.name,
       startTimeUnixNano: started,
-      attributes: attrs
+      attributes: withAppGitAttributes(
+        attrs,
+        this.appGitContext.forOperation(args.eventId, appGitOverrides, this.appGitOwner)
+      )
     };
     rememberReplayTraceDestination(span);
+    this.appGitCaptured.add(span);
+    this.appGitEventIds.set(span, args.eventId);
+    if (tracksAppGit) {
+      this.appGitActiveSpans.set(args.eventId, ((_c = this.appGitActiveSpans.get(args.eventId)) != null ? _c : 0) + 1);
+    }
+    this.appGitAdded.set(span, new Set(span.attributes.filter((attr) => !attrs.includes(attr))));
     const openSpan = buildOtlpSpan({
       ids: span.ids,
       name: span.name,
@@ -1366,11 +1817,17 @@ var TraceShipper = class {
     });
   }
   endSpan(span, extra) {
-    var _a, _b;
+    var _a, _b, _c;
     if (span.endTimeUnixNano) return;
     span.endTimeUnixNano = (_a = extra == null ? void 0 : extra.endTimeUnixNano) != null ? _a : nowUnixNanoString();
     if ((_b = extra == null ? void 0 : extra.attributes) == null ? void 0 : _b.length) {
+      const overrides = appGitPropertiesFromAttributes(extra.attributes);
+      const eventId2 = this.appGitEventIds.get(span);
+      const snapshot = eventId2 ? this.appGitContext.forOperation(eventId2, overrides, this.appGitOwner) : overrides;
+      const added = this.appGitAdded.get(span);
+      span.attributes = span.attributes.filter((attr) => !(added == null ? void 0 : added.has(attr)) || !attr || !Object.prototype.hasOwnProperty.call(overrides, APP_COMMIT_SHA) && !Object.prototype.hasOwnProperty.call(overrides, attr.key));
       span.attributes.push(...extra.attributes);
+      span.attributes = withAppGitAttributes(span.attributes, snapshot);
     }
     let status = extra == null ? void 0 : extra.status;
     if (!status && (extra == null ? void 0 : extra.error) !== void 0) {
@@ -1386,8 +1843,19 @@ var TraceShipper = class {
       status
     });
     copyReplayTraceDestination(span, otlp);
+    this.appGitCaptured.add(otlp);
     this.enqueue(otlp);
     this.mirrorToLocalDebugger(otlp, true);
+    const eventId = this.appGitEventIds.get(span);
+    if (eventId && this.appGitActiveSpans.has(eventId)) {
+      const remaining = ((_c = this.appGitActiveSpans.get(eventId)) != null ? _c : 1) - 1;
+      if (remaining > 0) this.appGitActiveSpans.set(eventId, remaining);
+      else {
+        this.appGitActiveSpans.delete(eventId);
+        if (this.appGitContext.releaseOperation) this.appGitContext.releaseOperation(eventId, this.appGitOwner);
+        else if (this.ownsAppGitContext) this.appGitContext.finishOperation(eventId);
+      }
+    }
   }
   createSpan(args) {
     var _a;
@@ -1398,20 +1866,41 @@ var TraceShipper = class {
       ...Object.entries(evalScopeAttributes()).map(([key, value]) => attrString(key, value))
     ];
     if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
+    const tracksAppGit = !this.appGitActiveSpans.has(args.eventId);
     const otlp = buildOtlpSpan({
       ids,
       name: args.name,
       startTimeUnixNano: args.startTimeUnixNano,
       endTimeUnixNano: args.endTimeUnixNano,
-      attributes: attrs,
+      attributes: withAppGitAttributes(
+        attrs,
+        this.appGitContext.forOperation(
+          args.eventId,
+          appGitPropertiesFromAttributes(attrs),
+          this.appGitOwner
+        )
+      ),
       status: args.status
     });
     rememberReplayTraceDestination(otlp);
+    this.appGitCaptured.add(otlp);
+    if (tracksAppGit) {
+      if (this.appGitContext.releaseOperation) this.appGitContext.releaseOperation(args.eventId, this.appGitOwner);
+      else if (this.ownsAppGitContext) this.appGitContext.finishOperation(args.eventId);
+    }
     this.enqueue(otlp);
     this.mirrorToLocalDebugger(otlp, true);
   }
   enqueue(span) {
+    var _a;
     if (!this.enabled) return;
+    const attributes = (_a = span.attributes) != null ? _a : [];
+    const enriched = this.appGitCaptured.has(span) ? attributes : withAppGitAttributes(attributes, this.appGitContext.snapshot(appGitPropertiesFromAttributes(attributes)));
+    if (enriched !== attributes) {
+      const original = span;
+      span = { ...span, attributes: enriched.filter((attr) => attr !== void 0) };
+      copyReplayTraceDestination(original, span);
+    }
     if (this.debugSpans) {
       const short = (s) => s ? s.slice(-8) : "none";
       console.log(
@@ -1557,12 +2046,158 @@ var TraceShipper = class {
       }
     } finally {
       this.shutdownDeadlineAt = void 0;
+      if (this.ownsAppGitContext) this.appGitContext.dispose();
     }
   }
 };
 
 // ../core/dist/index.node.js
 import { AsyncLocalStorage } from "async_hooks";
+import { execFile } from "child_process";
+import { resolve } from "path";
+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 createAppGitContext2(options, runtime = {}) {
+  return new AppGitContext(options, { ...runtime, resolveLocal });
+}
+function hasDestination(options) {
+  var _a;
+  if (options.enabled === false) return false;
+  return Boolean(((_a = options.writeKey) == null ? void 0 : _a.trim()) || resolveLocalDebuggerBaseUrl(options.localDebuggerUrl));
+}
+var EventShipper2 = class extends EventShipper {
+  constructor(options) {
+    var _a;
+    const ownsAppGitContext = options.appGitContext === void 0;
+    const appGitContext = (_a = options.appGitContext) != null ? _a : createAppGitContext2(options.appGit, { allowDiscovery: hasDestination(options) });
+    try {
+      super({ ...options, appGitContext });
+    } catch (error) {
+      if (ownsAppGitContext) appGitContext.dispose();
+      throw error;
+    }
+    if (ownsAppGitContext) this.ownAppGitContextForShutdown();
+  }
+};
+var TraceShipper2 = class extends TraceShipper {
+  constructor(options) {
+    var _a;
+    const ownsAppGitContext = options.appGitContext === void 0;
+    const appGitContext = (_a = options.appGitContext) != null ? _a : createAppGitContext2(options.appGit, { allowDiscovery: hasDestination(options) });
+    try {
+      super({ ...options, appGitContext });
+    } catch (error) {
+      if (ownsAppGitContext) appGitContext.dispose();
+      throw error;
+    }
+    this.ownsAppGitContext = ownsAppGitContext;
+  }
+};
 globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = AsyncLocalStorage;
 var SUPPRESS_TRACING_KEY = /* @__PURE__ */ Symbol.for(
   "OpenTelemetry SDK Context Key SUPPRESS_TRACING"
@@ -1590,6 +2225,468 @@ function installTracingSuppressionHook() {
 }
 installTracingSuppressionHook();
 
+// src/conversation.ts
+import {
+  isAIMessage,
+  isBaseMessage,
+  isChatMessage,
+  isToolMessage
+} from "@langchain/core/messages";
+
+// src/truncation.ts
+var TRUNCATION_MARKER2 = "...[truncated by raindrop]";
+var DEFAULT_MAX_TEXT_FIELD_CHARS2 = 1e6;
+var MAX_DEPTH = 12;
+var configuredMaxTextFieldChars;
+function setMaxTextFieldChars(limit) {
+  if (limit === void 0) return;
+  if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) {
+    configuredMaxTextFieldChars = Math.floor(limit);
+  } else {
+    console.warn(`[raindrop-ai] maxTextFieldChars=${String(limit)} ignored; must be > 0`);
+  }
+}
+function otelEnvLimit() {
+  if (typeof process === "undefined") return void 0;
+  const raw = process.env?.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+  if (!raw) return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function eventMaxTextFieldChars() {
+  return configuredMaxTextFieldChars ?? DEFAULT_MAX_TEXT_FIELD_CHARS2;
+}
+function spanAttributeLimit(limit) {
+  const env = otelEnvLimit();
+  return env !== void 0 && env < limit ? env : limit;
+}
+function effectiveMaxTextFieldChars() {
+  return spanAttributeLimit(eventMaxTextFieldChars());
+}
+function truncateToLimit2(text, limit) {
+  if (limit > TRUNCATION_MARKER2.length) {
+    return text.slice(0, limit - TRUNCATION_MARKER2.length) + TRUNCATION_MARKER2;
+  }
+  return text.slice(0, limit);
+}
+function capText2(value, limit) {
+  if (typeof value !== "string") return value;
+  const max = limit ?? effectiveMaxTextFieldChars();
+  if (value.length <= max) return value;
+  return truncateToLimit2(value, max);
+}
+function boundedClone2(value, budget, depth) {
+  if (budget.remaining <= 0) return TRUNCATION_MARKER2;
+  if (typeof value === "string") {
+    if (value.length > budget.remaining) {
+      const taken = value.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      return taken;
+    }
+    budget.remaining -= Math.max(value.length, 1);
+    return value;
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    budget.remaining -= 8;
+    return value;
+  }
+  if (typeof value === "bigint") return boundedClone2(value.toString(), budget, depth);
+  if (typeof value !== "object") {
+    budget.remaining -= 1;
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    const maxBytes = Math.max(0, Math.ceil(budget.remaining * 3 / 4));
+    if (value.byteLength > maxBytes) {
+      const taken = base64Encode(value.subarray(0, maxBytes)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      return taken;
+    }
+    const encoded = base64Encode(value);
+    budget.remaining -= Math.max(encoded.length, 1);
+    return encoded;
+  }
+  if (depth >= MAX_DEPTH) {
+    budget.remaining -= 16;
+    const name = value.constructor?.name ?? "object";
+    return `<max depth: ${name}>`;
+  }
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function") {
+    budget.remaining -= 2;
+    return boundedClone2(toJSON.call(value), budget, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    budget.remaining -= 2;
+    const out2 = [];
+    for (const item of value) {
+      if (budget.remaining <= 0) {
+        out2.push(TRUNCATION_MARKER2);
+        break;
+      }
+      out2.push(boundedClone2(item, budget, depth + 1));
+    }
+    return out2;
+  }
+  budget.remaining -= 2;
+  const out = {};
+  for (const key in value) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+    if (budget.remaining <= 0) {
+      out["..."] = TRUNCATION_MARKER2;
+      break;
+    }
+    let cappedKey = key;
+    if (key.length > budget.remaining) {
+      cappedKey = key.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      out[cappedKey] = TRUNCATION_MARKER2;
+      break;
+    }
+    budget.remaining -= Math.max(key.length, 1);
+    out[cappedKey] = boundedClone2(value[key], budget, depth + 1);
+  }
+  return out;
+}
+function boundedStringify(value, limit) {
+  const max = limit ?? effectiveMaxTextFieldChars();
+  try {
+    if (typeof value === "string") {
+      const text2 = JSON.stringify(capText2(value, max));
+      return text2.length <= max ? text2 : truncateToLimit2(text2, max);
+    }
+    const pruned = boundedClone2(value, { remaining: max + TRUNCATION_MARKER2.length + 256 }, 0);
+    const text = JSON.stringify(pruned);
+    if (text === void 0) return void 0;
+    return text.length <= max ? text : truncateToLimit2(text, max);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/conversation.ts
+var CAPTURE_TRUNCATED_ROLE = "raindrop";
+var MESSAGE_OVERHEAD = 32;
+var PART_OVERHEAD = 24;
+var MAX_DEPTH2 = 12;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+function takeText(text, budget) {
+  if (text.length > budget.remaining) {
+    const kept = text.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
+    budget.remaining = 0;
+    budget.truncated = true;
+    return kept;
+  }
+  budget.remaining -= Math.max(text.length, 1);
+  return text;
+}
+function reserve(text, budget) {
+  if (text !== void 0) budget.remaining -= Math.max(text.length, 1);
+  return text;
+}
+function takeValue(value, budget, depth) {
+  if (typeof value === "string") return takeText(value, budget);
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    budget.remaining -= 8;
+    return value;
+  }
+  if (typeof value !== "object") {
+    budget.remaining -= 1;
+    return value;
+  }
+  if (depth >= MAX_DEPTH2) {
+    budget.remaining -= TRUNCATION_MARKER2.length;
+    budget.truncated = true;
+    return TRUNCATION_MARKER2;
+  }
+  if ("toJSON" in value && typeof value.toJSON === "function") {
+    return takeValue(value.toJSON(), budget, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    budget.remaining -= 2;
+    const out2 = [];
+    for (const item of value) {
+      if (budget.remaining <= 0) {
+        budget.truncated = true;
+        out2.push(TRUNCATION_MARKER2);
+        break;
+      }
+      out2.push(takeValue(item, budget, depth + 1));
+    }
+    return out2;
+  }
+  budget.remaining -= 2;
+  const out = {};
+  if (!isRecord(value)) return out;
+  for (const key in value) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+    if (budget.remaining <= 0) {
+      budget.truncated = true;
+      out["..."] = TRUNCATION_MARKER2;
+      break;
+    }
+    budget.remaining -= Math.max(key.length, 1);
+    out[key] = takeValue(value[key], budget, depth + 1);
+  }
+  return out;
+}
+function messageType(message) {
+  return typeof message._getType === "function" ? message._getType() : void 0;
+}
+function textPart(text, budget) {
+  return { type: "text", text: takeText(text, budget) };
+}
+function joinedText(content, budget) {
+  const texts = [];
+  for (const block of content) {
+    if (budget.remaining <= 0) {
+      budget.truncated = true;
+      texts.push(TRUNCATION_MARKER2);
+      break;
+    }
+    budget.remaining -= 1;
+    if (!isRecord(block)) continue;
+    const text = stringField(block, "text");
+    if (text !== void 0) texts.push(takeText(text, budget));
+  }
+  return texts.join("\n");
+}
+function contentPart(block, budget) {
+  budget.remaining -= PART_OVERHEAD;
+  if (!isRecord(block)) return takeValue(block, budget, 0);
+  const type = stringField(block, "type");
+  const text = stringField(block, "text");
+  if (type === "text" && text !== void 0) return textPart(text, budget);
+  if (type === "image_url") {
+    const imageUrl = block["image_url"];
+    const url = typeof imageUrl === "string" ? imageUrl : isRecord(imageUrl) ? stringField(imageUrl, "url") : void 0;
+    if (url !== void 0) return { type: "image", image: takeText(url, budget) };
+  }
+  if (type === "thinking") {
+    const thinking = stringField(block, "thinking");
+    if (thinking !== void 0) return { type: "reasoning", text: takeText(thinking, budget) };
+  }
+  if (type === "image" || type === "file" || type === "audio") {
+    const mediaType = stringField(block, "mime_type");
+    const sourceType = stringField(block, "source_type");
+    const source = block["source"];
+    if (sourceType === "text" && text !== void 0) return textPart(text, budget);
+    const data = sourceType === "url" ? stringField(block, "url") : sourceType === "base64" ? stringField(block, "data") : isRecord(source) ? stringField(source, "url") ?? stringField(source, "data") : void 0;
+    const sourceMediaType = mediaType ?? (isRecord(source) ? stringField(source, "media_type") : void 0);
+    if (data !== void 0) {
+      const filename = stringField(block, "filename");
+      return type === "image" ? { type: "image", image: takeText(data, budget), mediaType: reserve(sourceMediaType, budget) } : {
+        type: "file",
+        data: takeText(data, budget),
+        mediaType: reserve(sourceMediaType, budget),
+        filename: reserve(filename, budget)
+      };
+    }
+  }
+  return takeValue(block, budget, 0);
+}
+function contentParts(content, budget, skipToolUseIds) {
+  const parts = [];
+  for (const block of content) {
+    if (budget.remaining <= 0) {
+      budget.truncated = true;
+      parts.push({ type: "text", text: TRUNCATION_MARKER2 });
+      break;
+    }
+    if (isRecord(block) && (block["type"] === "tool_use" || block["type"] === "tool_call")) {
+      const id = stringField(block, "id");
+      if (id !== void 0 && skipToolUseIds.has(id)) continue;
+    }
+    parts.push(contentPart(block, budget));
+  }
+  return parts;
+}
+function assistantMessage(message, budget, toolNames) {
+  const toolCalls = isAIMessage(message) ? message.tool_calls ?? [] : [];
+  if (toolCalls.length === 0 && typeof message.content === "string") {
+    return { role: "assistant", content: takeText(message.content, budget) };
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const callParts = [];
+  for (const call of toolCalls) {
+    if (budget.remaining <= 0) {
+      budget.truncated = true;
+      callParts.push({ type: "text", text: TRUNCATION_MARKER2 });
+      break;
+    }
+    budget.remaining -= PART_OVERHEAD;
+    if (call.id !== void 0) {
+      ids.add(call.id);
+      toolNames.set(call.id, call.name);
+    }
+    callParts.push({
+      type: "tool-call",
+      toolCallId: reserve(call.id, budget),
+      toolName: reserve(call.name, budget),
+      input: takeValue(call.args, budget, 0)
+    });
+  }
+  const content = typeof message.content === "string" ? message.content.length > 0 ? [textPart(message.content, budget)] : [] : contentParts(message.content, budget, ids);
+  content.push(...callParts);
+  return { role: "assistant", content };
+}
+function toolResultOutput(message, budget) {
+  const failed = isToolMessage(message) && message.status === "error";
+  if (typeof message.content === "string") {
+    return { type: failed ? "error-text" : "text", value: takeText(message.content, budget) };
+  }
+  return { type: "content", value: contentParts(message.content, budget, /* @__PURE__ */ new Set()) };
+}
+function toolMessage(message, budget, toolNames) {
+  const toolCallId = isToolMessage(message) ? message.tool_call_id : void 0;
+  const toolName = message.name ?? (toolCallId !== void 0 ? toolNames.get(toolCallId) : void 0);
+  budget.remaining -= PART_OVERHEAD;
+  return {
+    role: "tool",
+    content: [{
+      type: "tool-result",
+      toolCallId: reserve(toolCallId, budget),
+      toolName: reserve(toolName, budget),
+      output: toolResultOutput(message, budget)
+    }]
+  };
+}
+function modelMessage(message, budget, toolNames) {
+  budget.remaining -= MESSAGE_OVERHEAD;
+  switch (messageType(message)) {
+    case "system":
+      return {
+        role: "system",
+        content: typeof message.content === "string" ? takeText(message.content, budget) : joinedText(message.content, budget)
+      };
+    case "ai":
+      return assistantMessage(message, budget, toolNames);
+    case "tool":
+    case "function":
+      return toolMessage(message, budget, toolNames);
+    case "generic": {
+      const role = isChatMessage(message) ? message.role : void 0;
+      if (role === "assistant" || role === "system") {
+        return {
+          role,
+          content: typeof message.content === "string" ? takeText(message.content, budget) : joinedText(message.content, budget)
+        };
+      }
+      return userMessage(message, budget);
+    }
+    default:
+      return userMessage(message, budget);
+  }
+}
+function userMessage(message, budget) {
+  return {
+    role: "user",
+    content: typeof message.content === "string" ? takeText(message.content, budget) : contentParts(message.content, budget, /* @__PURE__ */ new Set())
+  };
+}
+function truncationRecord(omittedMessages) {
+  return { role: CAPTURE_TRUNCATED_ROLE, truncated: true, marker: TRUNCATION_MARKER2, omittedMessages };
+}
+function encodeWithinLimit(items, limit, overflow, convert) {
+  let textBudget = limit;
+  for (let attempt = 0; attempt < 8 && textBudget >= 64; attempt++) {
+    const budget = { remaining: textBudget, truncated: false };
+    const out = [];
+    let omitted = 0;
+    for (let i = 0; i < items.length; i++) {
+      if (overflow === "omit" && budget.remaining <= 0) {
+        omitted = items.length - i;
+        break;
+      }
+      out.push(convert(items[i], budget));
+    }
+    const truncated = budget.truncated || omitted > 0;
+    if (truncated && overflow === "omit") out.push(truncationRecord(omitted));
+    const json2 = JSON.stringify(out);
+    if (json2.length <= limit) return { json: json2, truncated };
+    const excess = json2.length - limit + 128;
+    textBudget = Math.max(textBudget - excess, Math.floor(textBudget / 2));
+  }
+  if (overflow === "keep") return void 0;
+  const json = JSON.stringify([truncationRecord(items.length)]);
+  return json.length <= limit ? { json, truncated: true } : void 0;
+}
+function captureConversation(messages, limit) {
+  if (messages.length === 0) return void 0;
+  try {
+    const toolNames = /* @__PURE__ */ new Map();
+    return encodeWithinLimit(
+      messages,
+      limit,
+      "omit",
+      (message, budget) => modelMessage(message, budget, toolNames)
+    );
+  } catch {
+    return void 0;
+  }
+}
+function capturePrompt(prompt, limit) {
+  try {
+    return encodeWithinLimit([prompt], limit, "omit", (text, budget) => {
+      budget.remaining -= MESSAGE_OVERHEAD;
+      return { role: "user", content: takeText(text, budget) };
+    });
+  } catch {
+    return void 0;
+  }
+}
+function captureToolCalls(message, limit) {
+  if (!isRecord(message) || !Array.isArray(message["tool_calls"])) return void 0;
+  const calls = [];
+  let structural = 0;
+  for (const call of message["tool_calls"]) {
+    structural += PART_OVERHEAD;
+    if (isRecord(call)) {
+      structural += (stringField(call, "id")?.length ?? 0) + (stringField(call, "name")?.length ?? 0);
+      calls.push(call);
+    }
+    if (structural > limit) return void 0;
+  }
+  if (calls.length === 0) return void 0;
+  try {
+    return encodeWithinLimit(calls, limit, "keep", (call, budget) => {
+      budget.remaining -= PART_OVERHEAD;
+      return {
+        toolCallId: reserve(stringField(call, "id"), budget),
+        toolName: reserve(stringField(call, "name"), budget),
+        input: takeValue(call["args"], budget, 0)
+      };
+    });
+  } catch {
+    return void 0;
+  }
+}
+function parseToolCallInput(input) {
+  try {
+    const parsed = JSON.parse(input);
+    if (isRecord(parsed) && parsed["type"] === "tool_call" && "args" in parsed) {
+      return { id: stringField(parsed, "id"), args: JSON.stringify(parsed["args"]) };
+    }
+  } catch {
+  }
+  return { args: input };
+}
+function unwrapToolOutput(output) {
+  if (isBaseMessage(output)) {
+    return {
+      content: output.content,
+      toolCallId: isToolMessage(output) ? output.tool_call_id : void 0
+    };
+  }
+  return { content: output };
+}
+
 // src/callback-handler.ts
 function resolveEventId(source) {
   if (typeof source !== "function") return randomUUID();
@@ -1607,32 +2704,38 @@ function isInternalName(name) {
   if (name.startsWith("__") && name.endsWith("__")) return true;
   return false;
 }
-var CHAIN_TEXT_MAX_LEN = 8192;
-function extractTextFromContent(content) {
+function extractTextFromContent(content, limit) {
   if (content == null) return void 0;
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     const parts = [];
+    let length = 0;
     for (const part of content) {
+      if (length > limit) break;
+      length += 1;
+      let text;
       if (typeof part === "string") {
-        parts.push(part);
+        text = part;
       } else if (part && typeof part === "object") {
         const p = part;
         if (typeof p.text === "string") {
-          parts.push(p.text);
+          text = p.text;
         } else if (p.type === "text" && typeof p.content === "string") {
-          parts.push(p.content);
+          text = p.content;
         }
       }
+      if (text === void 0) continue;
+      parts.push(text.length > limit ? text.slice(0, limit + 1) : text);
+      length += Math.max(text.length, 1);
     }
     if (parts.length > 0) return parts.join("\n");
-    return safeStringify(content, CHAIN_TEXT_MAX_LEN);
+    return boundedStringify(content, limit);
   }
   if (typeof content === "object") {
     const c = content;
     if (typeof c.text === "string") return c.text;
     if (typeof c.content === "string") return c.content;
-    return safeStringify(content, CHAIN_TEXT_MAX_LEN);
+    return boundedStringify(content, limit);
   }
   return String(content);
 }
@@ -1651,6 +2754,11 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
     this.eventName = opts.eventName;
     this.eventIdSource = opts.eventId;
     this.traceChains = opts.traceChains ?? true;
+    this.configuredSpanMaxChars = opts.maxTextFieldChars ?? eventMaxTextFieldChars();
+    this.eventMaxChars = opts.eventMaxTextFieldChars ?? eventMaxTextFieldChars();
+  }
+  get spanMaxChars() {
+    return spanAttributeLimit(this.configuredSpanMaxChars);
   }
   getEventId(runId, parentRunId) {
     const rootId = parentRunId ? this.rootRunIds.get(parentRunId) ?? parentRunId : runId;
@@ -1716,13 +2824,21 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
       if (this.spans.has(runId)) return;
       const eventId = this.getEventId(runId, parentRunId);
       const modelId = getName(llm, runName);
+      const prompt = prompts[0] ?? "";
       const span = this.traceShipper.startSpan({
         name: "llm",
         parent: this.getParent(parentRunId),
         eventId,
+        // `ai.generateText` classifies the span as an LLM generation at ingest
+        // (a bare `llm`/`chat` operationId maps to INTERNAL and is skipped by
+        // the rich-interaction extractor). `ai.prompt.messages` carries the
+        // per-step trajectory so replay can see the history each step ran on.
+        // A batch is a list of independent prompts; the span describes the
+        // first one, whose response `handleLLMEnd` reports (`generations[0][0]`).
         attributes: [
           attrString("ai.model.provider", modelId),
-          attrString("ai.operationId", "llm")
+          attrString("ai.operationId", "ai.generateText"),
+          ...promptAttributes(capturePrompt(prompt, this.spanMaxChars))
         ]
       });
       this.spans.set(runId, span);
@@ -1730,7 +2846,7 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
         userId: this.userId,
         convoId: this.convoId,
         eventName: this.eventName,
-        input: truncate(prompts.join("\n"), CHAIN_TEXT_MAX_LEN),
+        input: capText2(prompt, this.eventMaxChars),
         properties: buildProperties(tags, metadata),
         isPending: true
       });
@@ -1742,24 +2858,31 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
       if (this.spans.has(runId)) return;
       const eventId = this.getEventId(runId, parentRunId);
       const modelId = getName(llm, runName);
+      const conversation = messages[0] ?? [];
       const span = this.traceShipper.startSpan({
         name: "llm",
         parent: this.getParent(parentRunId),
         eventId,
+        // See handleLLMStart: the full history (historical tool calls and
+        // their results included) goes on the span; the event `input` below
+        // stays the latest human message. LangChain batches are a list of
+        // independent conversations; the span describes the first one, the
+        // same member `handleLLMEnd` reports the response of
+        // (`generations[0][0]`), so history and response stay paired.
         attributes: [
           attrString("ai.model.provider", modelId),
-          attrString("ai.operationId", "chat")
+          attrString("ai.operationId", "ai.generateText"),
+          ...promptAttributes(captureConversation(conversation, this.spanMaxChars))
         ]
       });
       this.spans.set(runId, span);
-      const allMessages = messages.flat();
-      const userMessages = allMessages.filter((m) => {
+      const userMessages = conversation.filter((m) => {
         const role = m._getType?.() ?? "unknown";
         return role === "human";
       });
-      const lastMsg = userMessages.length > 0 ? userMessages[userMessages.length - 1] : allMessages[allMessages.length - 1];
-      const extracted = lastMsg ? extractTextFromContent(lastMsg.content) : void 0;
-      const inputText = extracted !== void 0 ? truncate(extracted, CHAIN_TEXT_MAX_LEN) : void 0;
+      const lastMsg = userMessages.length > 0 ? userMessages[userMessages.length - 1] : conversation[conversation.length - 1];
+      const extracted = lastMsg ? extractTextFromContent(lastMsg.content, this.eventMaxChars) : void 0;
+      const inputText = capText2(extracted, this.eventMaxChars);
       await this.eventShipper.patch(eventId, {
         userId: this.userId,
         convoId: this.convoId,
@@ -1782,7 +2905,7 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
         await this.finalizeEventIfRoot(runId);
         return;
       }
-      const meta = extractLLMMetadata(output);
+      const meta = extractLLMMetadata(output, this.spanMaxChars);
       const {
         model,
         promptTokens,
@@ -1790,11 +2913,17 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
         cachedTokens,
         reasoningTokens,
         finishReason,
-        outputText
+        outputText,
+        toolCalls
       } = meta;
       this.traceShipper.endSpan(span, {
         attributes: [
           attrString("ai.response.model", model),
+          attrString("ai.response.text", capText2(outputText, this.spanMaxChars)),
+          // Tool calls requested by this step, with the ids the matching
+          // `ai.toolCall` spans and the next step's history carry.
+          attrString("ai.response.toolCalls", toolCalls?.json),
+          attrString("ai.response.toolCalls.truncated", toolCalls?.truncated ? "true" : void 0),
           attrInt("ai.usage.prompt_tokens", promptTokens),
           attrInt("ai.usage.completion_tokens", completionTokens),
           attrInt("ai.usage.cached_tokens", cachedTokens),
@@ -1806,9 +2935,8 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
       if (cachedTokens != null) properties["ai.usage.cached_tokens"] = cachedTokens;
       if (reasoningTokens != null) properties["ai.usage.thoughts_tokens"] = reasoningTokens;
       if (finishReason != null) properties["ai.finish_reason"] = finishReason;
-      const cappedOutput = outputText !== void 0 ? truncate(outputText, CHAIN_TEXT_MAX_LEN) : void 0;
       await this.finalizeEventIfRoot(runId, {
-        output: cappedOutput,
+        output: capText2(outputText, this.eventMaxChars),
         model,
         usage: { promptTokens, completionTokens },
         properties: Object.keys(properties).length > 0 ? properties : void 0
@@ -1904,14 +3032,16 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
     try {
       const eventId = this.getEventId(runId, parentRunId);
       const toolName = getName(tool, runName);
+      const toolCall = parseToolCallInput(input);
       const span = this.traceShipper.startSpan({
         name: "tool",
         parent: this.getParent(parentRunId),
         eventId,
         operationId: "ai.toolCall",
         attributes: [
+          attrString("ai.toolCall.id", toolCall.id),
           attrString("ai.toolCall.name", toolName),
-          attrString("tool.input", truncate(input, 4096))
+          attrString("ai.toolCall.args", capText2(toolCall.args, this.spanMaxChars))
         ]
       });
       this.spans.set(runId, span);
@@ -1926,9 +3056,14 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
     try {
       const span = this.spans.get(runId);
       if (span) {
-        const outputStr = typeof output === "string" ? output : safeStringify(output, 4096);
+        const { content, toolCallId } = unwrapToolOutput(output);
+        const result = typeof content === "string" ? capText2(content, this.spanMaxChars) : boundedStringify(content, this.spanMaxChars);
+        const hasId = span.attributes.some((attr) => attr?.key === "ai.toolCall.id");
         this.traceShipper.endSpan(span, {
-          attributes: [attrString("tool.output", truncate(outputStr, 4096))]
+          attributes: [
+            attrString("ai.toolCall.id", hasId ? void 0 : toolCallId),
+            attrString("ai.toolCall.result", result)
+          ]
         });
       }
       await this.finalizeEventIfRoot(runId);
@@ -1964,10 +3099,10 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
         operationId: "ai.toolCall",
         attributes: [
           attrString("ai.toolCall.name", action.tool),
-          attrString("agent.tool_input", truncate(
-            typeof action.toolInput === "string" ? action.toolInput : safeStringify(action.toolInput, 4096),
-            4096
-          ))
+          attrString(
+            "agent.tool_input",
+            typeof action.toolInput === "string" ? capText2(action.toolInput, this.spanMaxChars) : boundedStringify(action.toolInput, this.spanMaxChars)
+          )
         ]
       });
       this.spans.set(`${runId}:agent_action`, span);
@@ -2000,75 +3135,13 @@ function buildProperties(tags, metadata) {
   if (metadata) Object.assign(props, metadata);
   return props;
 }
-var TRUNCATION_MARKER2 = "...[truncated by raindrop]";
-var MAX_TEXT_FIELD_CHARS = 1e6;
-var MAX_BOUNDED_DEPTH = 12;
-function boundedClone2(value, budget, depth) {
-  if (budget.remaining <= 0) return TRUNCATION_MARKER2;
-  if (typeof value === "string") {
-    if (value.length > budget.remaining) {
-      const taken = value.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
-      budget.remaining = 0;
-      return taken;
-    }
-    budget.remaining -= Math.max(value.length, 1);
-    return value;
-  }
-  if (value === null || typeof value === "number" || typeof value === "boolean") {
-    budget.remaining -= 8;
-    return value;
-  }
-  if (typeof value !== "object") {
-    budget.remaining -= 8;
-    return value;
-  }
-  if (depth >= MAX_BOUNDED_DEPTH) {
-    budget.remaining -= 16;
-    return `<max depth: ${TRUNCATION_MARKER2}>`;
-  }
-  const withToJson = value;
-  if (typeof withToJson.toJSON === "function") {
-    try {
-      return boundedClone2(withToJson.toJSON(), budget, depth + 1);
-    } catch {
-    }
-  }
-  if (Array.isArray(value)) {
-    const out2 = [];
-    for (const item of value) {
-      if (budget.remaining <= 0) {
-        out2.push(TRUNCATION_MARKER2);
-        break;
-      }
-      out2.push(boundedClone2(item, budget, depth + 1));
-    }
-    return out2;
-  }
-  const out = {};
-  for (const key of Object.keys(value)) {
-    if (budget.remaining <= 0) {
-      out["..."] = TRUNCATION_MARKER2;
-      break;
-    }
-    budget.remaining -= Math.max(key.length, 1);
-    out[key] = boundedClone2(value[key], budget, depth + 1);
-  }
-  return out;
-}
-function safeStringify(value, limit = MAX_TEXT_FIELD_CHARS) {
-  try {
-    const pruned = boundedClone2(value, { remaining: limit + TRUNCATION_MARKER2.length + 256 }, 0);
-    return JSON.stringify(pruned) ?? "";
-  } catch {
-    const fallback = String(value);
-    return fallback.length > limit ? fallback.slice(0, limit) : fallback;
-  }
-}
-function truncate(str, maxLen) {
-  if (str.length <= maxLen) return str;
-  return str.slice(0, maxLen - 3) + "...";
+function promptAttributes(capture) {
+  return [
+    attrString("ai.prompt.messages", capture?.json),
+    attrString("ai.prompt.messages.truncated", capture?.truncated ? "true" : void 0)
+  ];
 }
-function extractLLMMetadata(output) {
+function extractLLMMetadata(output, limit) {
   const gen = output.generations?.[0]?.[0];
   const message = gen?.message;
   const responseMeta = message?.response_metadata;
@@ -2094,7 +3167,7 @@ function extractLLMMetadata(output) {
     outputDetails?.reasoning ?? usage?.reasoning_tokens ?? usage?.thoughts_tokens
   );
   const finishReason = generationInfo?.finish_reason ?? responseMeta?.finish_reason ?? responseMeta?.stop_reason;
-  const outputText = gen?.text ?? (typeof message?.content === "string" ? message.content : void 0) ?? (message?.content ? extractTextFromContent(message.content) : void 0);
+  const outputText = gen?.text ?? (typeof message?.content === "string" ? message.content : void 0) ?? (message?.content ? extractTextFromContent(message.content, limit) : void 0);
   return {
     model,
     promptTokens,
@@ -2102,7 +3175,8 @@ function extractLLMMetadata(output) {
     cachedTokens,
     reasoningTokens,
     finishReason,
-    outputText
+    outputText,
+    toolCalls: captureToolCalls(message, limit)
   };
 }
 function asNumber(val) {
@@ -2111,20 +3185,91 @@ function asNumber(val) {
   return Number.isFinite(n) ? n : void 0;
 }
 
+// package.json
+var package_default = {
+  name: "@raindrop-ai/deep-agents",
+  version: "0.1.3",
+  description: "Raindrop integration for LangChain Deep Agents",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  license: "MIT",
+  homepage: "https://www.raindrop.ai/docs/integrations/deepagents/",
+  bugs: {
+    url: "https://www.raindrop.ai/docs/support/"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    }
+  },
+  sideEffects: false,
+  files: [
+    "dist/**"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    clean: "rm -rf dist",
+    test: "vitest run"
+  },
+  peerDependencies: {
+    "@langchain/core": ">=0.3.0",
+    deepagents: ">=0.5.0"
+  },
+  devDependencies: {
+    "@langchain/anthropic": "~0.3.34",
+    "@langchain/core": ">=0.3.0",
+    "@langchain/openai": "~0.3.17",
+    "@raindrop-ai/core": "workspace:*",
+    "@types/node": "^20.11.17",
+    deepagents: "1.0.0",
+    msw: "^2.12.7",
+    tsup: "^8.4.0",
+    typescript: "^5.3.3",
+    vitest: "^2.1.9",
+    zod: "^3.23.0"
+  },
+  tsup: {
+    entry: [
+      "src/index.ts"
+    ],
+    format: [
+      "cjs",
+      "esm"
+    ],
+    dts: {
+      resolve: true
+    },
+    clean: true,
+    noExternal: [
+      "@raindrop-ai/core"
+    ]
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
 // src/version.ts
-var libraryName = "@raindrop-ai/deep-agents";
-var libraryVersion = "0.0.1";
+var libraryName = package_default.name;
+var libraryVersion = package_default.version;
 
 // src/index.ts
 function createRaindropDeepAgents(opts) {
   const writeKey = opts.writeKey;
   const enabled = !!writeKey;
+  setMaxTextFieldChars(opts.maxTextFieldChars);
+  const maxChars = eventMaxTextFieldChars();
   if (!writeKey) {
     console.warn(
       "[raindrop-ai/deep-agents] writeKey not provided; telemetry shipping is disabled"
     );
   }
-  const eventShipper = new EventShipper({
+  const appGitContext = createAppGitContext2(writeKey?.trim() ? opts.appGit : false, { allowLocalGit: true });
+  const eventShipper = new EventShipper2({
     writeKey,
     endpoint: opts.endpoint,
     enabled,
@@ -2132,9 +3277,11 @@ function createRaindropDeepAgents(opts) {
     projectId: opts.projectId,
     sdkName: "deep-agents",
     libraryName,
-    libraryVersion
+    libraryVersion,
+    appGitContext,
+    maxTextFieldChars: maxChars
   });
-  const traceShipper = new TraceShipper({
+  const traceShipper = new TraceShipper2({
     writeKey,
     endpoint: opts.endpoint,
     enabled,
@@ -2142,7 +3289,9 @@ function createRaindropDeepAgents(opts) {
     projectId: opts.projectId,
     sdkName: "deep-agents",
     serviceName: "raindrop.deep-agents",
-    serviceVersion: libraryVersion
+    serviceVersion: libraryVersion,
+    appGitContext,
+    maxTextFieldChars: maxChars
   });
   const handler = new RaindropDeepAgentsHandler({
     eventShipper,
@@ -2151,7 +3300,9 @@ function createRaindropDeepAgents(opts) {
     convoId: opts.convoId,
     eventName: opts.eventName,
     eventId: opts.eventId,
-    traceChains: opts.traceChains
+    traceChains: opts.traceChains,
+    maxTextFieldChars: maxChars,
+    eventMaxTextFieldChars: maxChars
   });
   return {
     handler,
@@ -2162,7 +3313,14 @@ function createRaindropDeepAgents(opts) {
       await Promise.all([eventShipper.flush(), traceShipper.flush()]);
     },
     async shutdown() {
-      await Promise.all([eventShipper.shutdown(), traceShipper.shutdown()]);
+      try {
+        await Promise.all([eventShipper.shutdown(), traceShipper.shutdown()]);
+      } finally {
+        try {
+          appGitContext.dispose();
+        } catch {
+        }
+      }
     },
     events: {
       async patch(eventId, patch) {