@raindrop-ai/ai-sdk 0.3.2 → 0.3.4

package/dist/{chunk-VRVBVX6K.mjs → chunk-BS7SHOEE.mjs}

@@ -1,4 +1,6 @@
 import { AsyncLocalStorage } from 'async_hooks';
+import { execFile } from 'child_process';
+import { resolve } from 'path';
 
 // ../core/dist/chunk-BYBMRLZM.js
 var EVAL_CORRELATION_ID_ATTRIBUTE = "raindrop.eval_correlation_id";
@@ -62,7 +64,574 @@ function evalScopeAttributes() {
   return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
 }
 
-// ../core/dist/chunk-T53LQAH7.js
+// ../core/dist/chunk-I6TVJQEC.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`;
+}
+var NOOP_SPAN = {
+  traceIdB64: "",
+  spanIdB64: "",
+  eventId: "",
+  log() {
+  }
+};
+function getAsyncLocalStorageCtor() {
+  return globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+}
+var SynchronousContextStorage = class {
+  constructor() {
+    this._stack = [];
+  }
+  isEmpty() {
+    return this._stack.length === 0;
+  }
+  getStore() {
+    return this._stack[this._stack.length - 1];
+  }
+  run(store, callback) {
+    this._stack.push(store);
+    try {
+      return callback();
+    } finally {
+      this._stack.pop();
+    }
+  }
+};
+var ContextManager = class {
+};
+var RaindropContextManager = class extends ContextManager {
+  constructor() {
+    super();
+    this._fallback = null;
+    const Ctor = getAsyncLocalStorageCtor();
+    if (Ctor) {
+      this._storage = new Ctor();
+      return;
+    }
+    this._fallback = new SynchronousContextStorage();
+    this._storage = this._fallback;
+  }
+  maybeAdoptAsyncLocalStorage() {
+    if (!this._fallback || !this._fallback.isEmpty()) return;
+    const Ctor = getAsyncLocalStorageCtor();
+    if (!Ctor) return;
+    this._storage = new Ctor();
+    this._fallback = null;
+  }
+  isReady() {
+    return true;
+  }
+  getParentSpanIds() {
+    this.maybeAdoptAsyncLocalStorage();
+    const span = this._storage.getStore();
+    if (!span || span === NOOP_SPAN) return void 0;
+    return {
+      traceIdB64: span.traceIdB64,
+      spanIdB64: span.spanIdB64,
+      eventId: span.eventId
+    };
+  }
+  runInContext(span, callback) {
+    this.maybeAdoptAsyncLocalStorage();
+    return this._storage.run(span, callback);
+  }
+  getCurrentSpan() {
+    this.maybeAdoptAsyncLocalStorage();
+    return this._storage.getStore();
+  }
+};
+var _contextManager = null;
+function getContextManager() {
+  if (!_contextManager) {
+    _contextManager = globalThis.RAINDROP_CONTEXT_MANAGER ? new globalThis.RAINDROP_CONTEXT_MANAGER() : new RaindropContextManager();
+  }
+  return _contextManager;
+}
+function currentSpan() {
+  var _a;
+  return (_a = getContextManager().getCurrentSpan()) != null ? _a : NOOP_SPAN;
+}
+function withCurrent(span, callback) {
+  return getContextManager().runInContext(span, callback);
+}
+async function getCurrentParentSpanContext() {
+  var _a, _b;
+  return (_b = getContextManager().getParentSpanIds()) != null ? _b : (_a = currentReplayTraceDestination()) == null ? void 0 : _a.parentSpanContext;
+}
+async function runWithParentSpanContext(ctx, fn) {
+  const cm = getContextManager();
+  const span = {
+    traceIdB64: ctx.traceIdB64,
+    spanIdB64: ctx.spanIdB64,
+    eventId: ctx.eventId
+  };
+  return cm.runInContext(span, fn);
+}
+async function* asyncGeneratorWithCurrent(span, gen) {
+  let nextValue;
+  while (true) {
+    const result = await withCurrent(span, async () => {
+      try {
+        return await gen.next(nextValue);
+      } catch (e) {
+        return { value: void 0, done: true, error: e };
+      }
+    });
+    if ("error" in result && result.error !== void 0) {
+      throw result.error;
+    }
+    if (result.done) {
+      return result.value;
+    }
+    nextValue = yield result.value;
+  }
+}
+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 normalizeFeatureFlags(input) {
   if (Array.isArray(input)) {
     return Object.fromEntries(input.map((name) => [name, "true"]));
@@ -447,7 +1016,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;
@@ -484,9 +1053,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);
     })
   ]);
@@ -653,82 +1222,33 @@ function attrStringArray(key, values) {
 function buildOtlpSpan(args) {
   const attrs = args.attributes.filter((x) => x !== void 0);
   const span = {
-    traceId: args.ids.traceIdB64,
-    spanId: args.ids.spanIdB64,
-    name: args.name,
-    startTimeUnixNano: args.startTimeUnixNano,
-    endTimeUnixNano: args.endTimeUnixNano
-  };
-  if (args.ids.parentSpanIdB64) span.parentSpanId = args.ids.parentSpanIdB64;
-  if (attrs.length) span.attributes = attrs;
-  if (args.status) span.status = args.status;
-  return span;
-}
-function buildExportTraceServiceRequest(spans, serviceName = "raindrop.core", serviceVersion = "0.0.0") {
-  return {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: [{ key: "service.name", value: { stringValue: serviceName } }]
-        },
-        scopeSpans: [
-          {
-            scope: { name: serviceName, version: serviceVersion },
-            spans
-          }
-        ]
-      }
-    ]
-  };
-}
-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);
+    traceId: args.ids.traceIdB64,
+    spanId: args.ids.spanIdB64,
+    name: args.name,
+    startTimeUnixNano: args.startTimeUnixNano,
+    endTimeUnixNano: args.endTimeUnixNano
+  };
+  if (args.ids.parentSpanIdB64) span.parentSpanId = args.ids.parentSpanIdB64;
+  if (attrs.length) span.attributes = attrs;
+  if (args.status) span.status = args.status;
+  return span;
 }
-function replayTraceUrl(baseUrl) {
-  return `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
+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";
@@ -864,6 +1384,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 };
@@ -913,22 +1440,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}`);
     }
@@ -939,8 +1469,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",
@@ -948,6 +1478,9 @@ var EventShipper = class {
       }
     };
   }
+  ownAppGitContextForShutdown() {
+    this.ownsAppGitContext = true;
+  }
   isDebugEnabled() {
     return this.debug;
   }
@@ -1026,6 +1559,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);
@@ -1039,6 +1579,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(() => {
@@ -1070,6 +1612,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) {
@@ -1504,6 +2047,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),
@@ -1526,23 +2076,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}`);
     }
@@ -1643,7 +2200,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 = [
@@ -1653,13 +2210,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,
@@ -1699,11 +2267,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) {
@@ -1719,8 +2293,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;
@@ -1731,20 +2316,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(
@@ -1890,127 +2496,305 @@ var TraceShipper = class {
       }
     } finally {
       this.shutdownDeadlineAt = void 0;
+      if (this.ownsAppGitContext) this.appGitContext.dispose();
     }
   }
 };
-var NOOP_SPAN = {
-  traceIdB64: "",
-  spanIdB64: "",
-  eventId: "",
-  log() {
-  }
-};
-function getAsyncLocalStorageCtor() {
-  return globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
-}
-var SynchronousContextStorage = class {
-  constructor() {
-    this._stack = [];
-  }
-  isEmpty() {
-    return this._stack.length === 0;
-  }
-  getStore() {
-    return this._stack[this._stack.length - 1];
-  }
-  run(store, callback) {
-    this._stack.push(store);
+var PROMPT_TOOLS_ATTRIBUTE = "ai.prompt.tools";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var JSON_SCHEMA_KEYS = [
+  "type",
+  "properties",
+  "$schema",
+  "$ref",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "enum",
+  "const",
+  "items",
+  "additionalProperties",
+  "required"
+];
+function isJsonSchema(value) {
+  if (!isRecord(value)) return false;
+  if (typeof value["~standard"] === "object") return false;
+  if (isRecord(value._def) || isRecord(value._zod)) return false;
+  if (Object.keys(value).length === 0) return true;
+  return JSON_SCHEMA_KEYS.some((key) => key in value);
+}
+function toJsonSchema(value, options) {
+  if (value === void 0 || value === null) return void 0;
+  if (isJsonSchema(value)) return value;
+  if (isRecord(value) && isJsonSchema(value.jsonSchema)) return value.jsonSchema;
+  if (isRecord(value) && isJsonSchema(value.json)) return value.json;
+  if (options == null ? void 0 : options.schema) {
     try {
-      return callback();
-    } finally {
-      this._stack.pop();
+      return options.schema(value);
+    } catch (e) {
+      return void 0;
     }
   }
-};
-var ContextManager = class {
-};
-var RaindropContextManager = class extends ContextManager {
-  constructor() {
-    super();
-    this._fallback = null;
-    const Ctor = getAsyncLocalStorageCtor();
-    if (Ctor) {
-      this._storage = new Ctor();
-      return;
+  return void 0;
+}
+function pickString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function functionTool(name, description, schema, options) {
+  const tool = { type: "function", name };
+  const desc = pickString(description);
+  if (desc !== void 0) tool.description = desc;
+  const inputSchema = toJsonSchema(schema, options);
+  if (inputSchema !== void 0) tool.inputSchema = inputSchema;
+  return tool;
+}
+function normalizeToolDeclaration(tool, options, fallbackName) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (!isRecord(tool)) return void 0;
+  if (tool.type === "provider-defined" || tool.type === "provider") {
+    const name2 = (_b = (_a = pickString(tool.name)) != null ? _a : pickString(tool.id)) != null ? _b : fallbackName;
+    if (name2 === void 0) return void 0;
+    const declaration = { type: "provider-defined", name: name2 };
+    const id = pickString(tool.id);
+    if (id !== void 0) declaration.id = id;
+    if (isRecord(tool.args)) declaration.args = tool.args;
+    return declaration;
+  }
+  if (isRecord(tool.toolSpec)) {
+    const spec = tool.toolSpec;
+    const name2 = (_c = pickString(spec.name)) != null ? _c : fallbackName;
+    if (name2 === void 0) return void 0;
+    return functionTool(name2, spec.description, spec.inputSchema, options);
+  }
+  if (isRecord(tool.function)) {
+    const fn = tool.function;
+    const name2 = (_d = pickString(fn.name)) != null ? _d : fallbackName;
+    if (name2 === void 0) return void 0;
+    return functionTool(name2, fn.description, (_e = fn.parameters) != null ? _e : fn.input_schema, options);
+  }
+  const name = (_g = (_f = pickString(tool.name)) != null ? _f : pickString(tool.id)) != null ? _g : fallbackName;
+  if (name === void 0) return void 0;
+  const type = pickString(tool.type);
+  if (type !== void 0 && type !== "function" && type !== "dynamic" && type !== "custom") {
+    if (!("input_schema" in tool) && !("inputSchema" in tool) && !("parameters" in tool)) {
+      return { type: "provider-defined", id: type, name };
+    }
+  }
+  return functionTool(
+    name,
+    tool.description,
+    (_j = (_i = (_h = tool.inputSchema) != null ? _h : tool.input_schema) != null ? _i : tool.parameters) != null ? _j : tool.schema,
+    options
+  );
+}
+var NOT_A_GEMINI_GROUP_KEYS = ["name", "id", "type", "function", "toolSpec", "cachePoint"];
+function isGeminiToolGroup(tool) {
+  if (Array.isArray(tool.functionDeclarations)) return true;
+  const keys = Object.keys(tool);
+  if (keys.length === 0 || NOT_A_GEMINI_GROUP_KEYS.some((key) => key in tool)) return false;
+  return keys.every((key) => isRecord(tool[key]));
+}
+function expandGeminiTool(tool, options) {
+  const declarations = [];
+  for (const [key, value] of Object.entries(tool)) {
+    if (key === "functionDeclarations" && Array.isArray(value)) {
+      for (const declaration of value) {
+        const normalized = normalizeToolDeclaration(declaration, options);
+        if (normalized) declarations.push(normalized);
+      }
+    } else if (isRecord(value)) {
+      declarations.push({ type: "provider-defined", id: key, name: key, args: value });
     }
-    this._fallback = new SynchronousContextStorage();
-    this._storage = this._fallback;
-  }
-  maybeAdoptAsyncLocalStorage() {
-    if (!this._fallback || !this._fallback.isEmpty()) return;
-    const Ctor = getAsyncLocalStorageCtor();
-    if (!Ctor) return;
-    this._storage = new Ctor();
-    this._fallback = null;
-  }
-  isReady() {
-    return true;
-  }
-  getParentSpanIds() {
-    this.maybeAdoptAsyncLocalStorage();
-    const span = this._storage.getStore();
-    if (!span || span === NOOP_SPAN) return void 0;
-    return {
-      traceIdB64: span.traceIdB64,
-      spanIdB64: span.spanIdB64,
-      eventId: span.eventId
-    };
-  }
-  runInContext(span, callback) {
-    this.maybeAdoptAsyncLocalStorage();
-    return this._storage.run(span, callback);
   }
-  getCurrentSpan() {
-    this.maybeAdoptAsyncLocalStorage();
-    return this._storage.getStore();
-  }
-};
-var _contextManager = null;
-function getContextManager() {
-  if (!_contextManager) {
-    _contextManager = globalThis.RAINDROP_CONTEXT_MANAGER ? new globalThis.RAINDROP_CONTEXT_MANAGER() : new RaindropContextManager();
+  return declarations;
+}
+function normalizeToolDeclarations(tools, options) {
+  if (tools === void 0 || tools === null) return void 0;
+  if (Array.isArray(tools)) {
+    return tools.flatMap((tool) => {
+      if (isRecord(tool) && isGeminiToolGroup(tool)) {
+        return expandGeminiTool(tool, options);
+      }
+      const declaration = normalizeToolDeclaration(tool, options);
+      return declaration ? [declaration] : [];
+    });
   }
-  return _contextManager;
+  if (!isRecord(tools)) return void 0;
+  return Object.entries(tools).flatMap(([key, tool]) => {
+    const declaration = normalizeToolDeclaration(tool, options, key);
+    return declaration ? [declaration] : [];
+  });
 }
-function currentSpan() {
+function resolvePromptTools(args) {
   var _a;
-  return (_a = getContextManager().getCurrentSpan()) != null ? _a : NOOP_SPAN;
-}
-function withCurrent(span, callback) {
-  return getContextManager().runInContext(span, callback);
-}
-async function getCurrentParentSpanContext() {
-  var _a, _b;
-  return (_b = getContextManager().getParentSpanIds()) != null ? _b : (_a = currentReplayTraceDestination()) == null ? void 0 : _a.parentSpanContext;
+  if (args.override !== void 0) {
+    return (_a = normalizeToolDeclarations(args.override, args.options)) != null ? _a : [];
+  }
+  return normalizeToolDeclarations(args.inferred, args.options);
 }
-async function runWithParentSpanContext(ctx, fn) {
-  const cm = getContextManager();
-  const span = {
-    traceIdB64: ctx.traceIdB64,
-    spanIdB64: ctx.spanIdB64,
-    eventId: ctx.eventId
+function promptToolsAttribute(tools) {
+  const values = promptToolsAttributeValue(tools);
+  if (values === void 0) return void 0;
+  return {
+    key: PROMPT_TOOLS_ATTRIBUTE,
+    value: { arrayValue: { values: values.map((stringValue) => ({ stringValue })) } }
   };
-  return cm.runInContext(span, fn);
 }
-async function* asyncGeneratorWithCurrent(span, gen) {
-  let nextValue;
-  while (true) {
-    const result = await withCurrent(span, async () => {
+function promptToolsAttributeValue(tools) {
+  if (tools === void 0) return void 0;
+  return tools.map((tool) => {
+    try {
+      return JSON.stringify(tool);
+    } catch (e) {
+      return JSON.stringify({ type: tool.type, name: tool.name });
+    }
+  });
+}
+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 {
-        return await gen.next(nextValue);
-      } catch (e) {
-        return { value: void 0, done: true, error: e };
+        done(void 0);
+      } catch (e2) {
       }
-    });
-    if ("error" in result && result.error !== void 0) {
-      throw result.error;
     }
-    if (result.done) {
-      return result.value;
+  };
+  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) {
     }
-    nextValue = yield result.value;
-  }
+  };
+};
+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"
@@ -2166,7 +2950,7 @@ function boundedStringify(value, limit) {
 }
 
 // src/internal/wrap/helpers.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function isFunction(value) {
@@ -2205,7 +2989,7 @@ function extractModelInfo(model) {
     }
     return { modelId: model };
   }
-  if (!isRecord(model)) return {};
+  if (!isRecord2(model)) return {};
   const provider = typeof model["provider"] === "string" ? model["provider"] : void 0;
   let modelIdRaw;
   if (typeof model["modelId"] === "string") {
@@ -2226,13 +3010,13 @@ function extractModelInfo(model) {
   return { provider, modelId: modelIdRaw };
 }
 function extractTextOutput(result) {
-  if (!isRecord(result)) return void 0;
+  if (!isRecord2(result)) return void 0;
   const text = result["text"];
   return typeof text === "string" ? text : void 0;
 }
 function extractObjectOutput(result) {
   var _a;
-  if (!isRecord(result)) return void 0;
+  if (!isRecord2(result)) return void 0;
   const obj = result["object"];
   if (obj === void 0) return void 0;
   return (_a = safeJson(obj)) != null ? _a : String(obj);
@@ -2240,24 +3024,24 @@ function extractObjectOutput(result) {
 function isAgentClass(value) {
   if (typeof value !== "function") return false;
   const proto = value.prototype;
-  if (!isRecord(proto)) return false;
+  if (!isRecord2(proto)) return false;
   return typeof proto["generate"] === "function" && typeof proto["stream"] === "function";
 }
 function extractModel(result) {
-  if (!isRecord(result)) return void 0;
+  if (!isRecord2(result)) return void 0;
   const model = result["model"];
   if (typeof model === "string" && model.length) return model;
   const response = result["response"];
-  if (isRecord(response)) {
+  if (isRecord2(response)) {
     const modelId = response["modelId"];
     if (typeof modelId === "string" && modelId.length) return modelId;
   }
   return void 0;
 }
 function extractFinishReason(result) {
-  if (!isRecord(result)) return void 0;
+  if (!isRecord2(result)) return void 0;
   if (typeof result["finishReason"] === "string") return result["finishReason"];
-  if (isRecord(result["finishReason"]) && typeof result["finishReason"]["unified"] === "string") {
+  if (isRecord2(result["finishReason"]) && typeof result["finishReason"]["unified"] === "string") {
     return result["finishReason"]["unified"];
   }
   return void 0;
@@ -2301,7 +3085,7 @@ function attachmentMediaType(part) {
   if (typeof part["mediaType"] === "string") return part["mediaType"];
   if (typeof part["mimeType"] === "string") return part["mimeType"];
   const file = part["file"];
-  if (isRecord(file)) {
+  if (isRecord2(file)) {
     if (typeof file["mediaType"] === "string") return file["mediaType"];
     if (typeof file["mimeType"] === "string") return file["mimeType"];
   }
@@ -2311,7 +3095,7 @@ function attachmentName(part) {
   if (typeof part["filename"] === "string") return part["filename"];
   if (typeof part["name"] === "string") return part["name"];
   const file = part["file"];
-  if (isRecord(file)) {
+  if (isRecord2(file)) {
     if (typeof file["filename"] === "string") return file["filename"];
     if (typeof file["name"] === "string") return file["name"];
   }
@@ -2320,7 +3104,7 @@ function attachmentName(part) {
 function attachmentData(part) {
   if ("data" in part) return part["data"];
   const file = part["file"];
-  if (isRecord(file)) {
+  if (isRecord2(file)) {
     if ("file_data" in file) return file["file_data"];
     if ("data" in file) return file["data"];
   }
@@ -2338,7 +3122,7 @@ function contentPartToAttachment(part, role) {
   }
   if (partType === "image_url") {
     const imageUrlPart = part["image_url"];
-    const imageUrlValue = isRecord(imageUrlPart) ? imageUrlPart["url"] : imageUrlPart;
+    const imageUrlValue = isRecord2(imageUrlPart) ? imageUrlPart["url"] : imageUrlPart;
     const value = asDataUrl(imageUrlValue, "image/png");
     if (!value) return void 0;
     return { type: "image", role, value };
@@ -2358,7 +3142,7 @@ function attachmentsFromContent(content, role) {
   if (!Array.isArray(content)) return void 0;
   const attachments = [];
   for (const part of content) {
-    if (!isRecord(part)) continue;
+    if (!isRecord2(part)) continue;
     const attachment = contentPartToAttachment(part, role);
     if (attachment) attachments.push(attachment);
   }
@@ -2391,7 +3175,7 @@ async function outputAttachmentsFromFiles(files) {
   if (!Array.isArray(resolvedFiles)) return void 0;
   const attachments = [];
   for (const file of resolvedFiles) {
-    if (!isRecord(file)) continue;
+    if (!isRecord2(file)) continue;
     const attachment = generatedFileToAttachment(file);
     if (attachment) attachments.push(attachment);
   }
@@ -2402,7 +3186,7 @@ function extractTextFromMessageContent(content) {
   if (!Array.isArray(content)) return void 0;
   let result = "";
   for (const part of content) {
-    if (!isRecord(part) || part["type"] !== "text" || typeof part["text"] !== "string") continue;
+    if (!isRecord2(part) || part["type"] !== "text" || typeof part["text"] !== "string") continue;
     result += part["text"];
   }
   return result.length ? result : void 0;
@@ -2419,7 +3203,7 @@ function lastUserMessageFromArgs(args) {
   if (!messages) return void 0;
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i];
-    if (isRecord(message) && message["role"] === "user") {
+    if (isRecord2(message) && message["role"] === "user") {
       return message;
     }
   }
@@ -2427,24 +3211,24 @@ function lastUserMessageFromArgs(args) {
 }
 function extractInputAttachmentsFromArgs(args) {
   var _a;
-  if (!isRecord(args)) return void 0;
+  if (!isRecord2(args)) return void 0;
   return attachmentsFromContent((_a = lastUserMessageFromArgs(args)) == null ? void 0 : _a["content"], "input");
 }
 async function extractOutputAttachmentsFromResult(result) {
-  if (!isRecord(result)) return void 0;
+  if (!isRecord2(result)) return void 0;
   const fileAttachments = await outputAttachmentsFromFiles(result["files"]);
   if (fileAttachments == null ? void 0 : fileAttachments.length) return fileAttachments;
   const responseMessages = extractResponseMessages(result);
   for (let i = responseMessages.length - 1; i >= 0; i--) {
     const message = responseMessages[i];
-    if (!isRecord(message) || message["role"] !== "assistant") continue;
+    if (!isRecord2(message) || message["role"] !== "assistant") continue;
     return attachmentsFromContent(message["content"], "output");
   }
   return attachmentsFromContent(result["content"], "output");
 }
 function lastUserMessageTextFromArgs(args) {
   var _a, _b;
-  if (!isRecord(args)) return void 0;
+  if (!isRecord2(args)) return void 0;
   const content = (_a = lastUserMessageFromArgs(args)) == null ? void 0 : _a["content"];
   if (content === void 0) return void 0;
   const text = extractTextFromMessageContent(content);
@@ -2453,13 +3237,13 @@ function lastUserMessageTextFromArgs(args) {
 }
 function extractInputFromArgs(args) {
   var _a;
-  if (!isRecord(args)) return void 0;
+  if (!isRecord2(args)) return void 0;
   const prompt = args["prompt"];
   if (typeof prompt === "string") return prompt;
   const messages = messagesFromArgs(args);
   if (Array.isArray(messages) && messages.length > 0) {
     const last = messages[messages.length - 1];
-    if (isRecord(last)) {
+    if (isRecord2(last)) {
       const content = last["content"];
       const text = extractTextFromMessageContent(content);
       if (text !== void 0) return text;
@@ -2473,7 +3257,7 @@ function extractInputFromArgs(args) {
   return safeJson(args);
 }
 function coerceMessagesFromArgs(args) {
-  if (!isRecord(args)) return [];
+  if (!isRecord2(args)) return [];
   const result = [];
   if (typeof args["system"] === "string" && args["system"]) {
     result.push({ role: "system", content: args["system"] });
@@ -2481,7 +3265,7 @@ function coerceMessagesFromArgs(args) {
   const messages = messagesFromArgs(args);
   if (Array.isArray(messages)) {
     for (const message of messages) {
-      if (isRecord(message) && typeof message["role"] === "string") {
+      if (isRecord2(message) && typeof message["role"] === "string") {
         result.push(message);
       }
     }
@@ -2493,21 +3277,21 @@ function coerceMessagesFromArgs(args) {
   return result;
 }
 function extractResponseMessages(result) {
-  if (!isRecord(result)) return [];
+  if (!isRecord2(result)) return [];
   const response = result["response"];
-  if (isRecord(response) && Array.isArray(response["messages"])) {
+  if (isRecord2(response) && Array.isArray(response["messages"])) {
     return response["messages"].filter(
-      (message) => isRecord(message) && typeof message["role"] === "string" && "content" in message
+      (message) => isRecord2(message) && typeof message["role"] === "string" && "content" in message
     ).map((message) => message);
   }
   const steps = result["steps"];
   if (Array.isArray(steps) && steps.length > 0) {
     const lastStep = steps[steps.length - 1];
-    if (isRecord(lastStep) && isRecord(lastStep["response"])) {
+    if (isRecord2(lastStep) && isRecord2(lastStep["response"])) {
       const responseMessages = lastStep["response"]["messages"];
       if (Array.isArray(responseMessages)) {
         return responseMessages.filter(
-          (message) => isRecord(message) && typeof message["role"] === "string" && "content" in message
+          (message) => isRecord2(message) && typeof message["role"] === "string" && "content" in message
         ).map((message) => message);
       }
     }
@@ -2528,7 +3312,7 @@ function isTranscriptToolResultError(part, result) {
   if (part["isError"] === true || part["type"] === "tool-error") {
     return true;
   }
-  if (isRecord(result) && typeof result["type"] === "string") {
+  if (isRecord2(result) && typeof result["type"] === "string") {
     return result["type"].startsWith("error") || result["type"] === "execution-denied";
   }
   return false;
@@ -2537,7 +3321,7 @@ function getTranscriptToolErrorMessage(result) {
   if (typeof result === "string" && result.length > 0) {
     return result;
   }
-  if (isRecord(result)) {
+  if (isRecord2(result)) {
     if (typeof result["value"] === "string" && result["value"].length > 0) {
       return result["value"];
     }
@@ -2551,12 +3335,12 @@ function getTranscriptToolErrorMessage(result) {
   return safeJsonWithUint8(result);
 }
 function getTranscriptMessageParts(message) {
-  if (!isRecord(message)) return [];
+  if (!isRecord2(message)) return [];
   const content = message["content"];
   if (Array.isArray(content)) {
-    return content.filter(isRecord);
+    return content.filter(isRecord2);
   }
-  return isRecord(content) ? [content] : [];
+  return isRecord2(content) ? [content] : [];
 }
 function getTranscriptToolCallInput(part) {
   return "input" in part ? part["input"] : "args" in part ? part["args"] : void 0;
@@ -2657,7 +3441,7 @@ function extractTextFromLmContent(content) {
   if (!Array.isArray(content)) return void 0;
   let result = "";
   for (const part of content) {
-    if (isRecord(part) && part["type"] === "text" && typeof part["text"] === "string") {
+    if (isRecord2(part) && part["type"] === "text" && typeof part["text"] === "string") {
       result += part["text"];
     }
   }
@@ -2667,7 +3451,7 @@ function extractToolCallsFromLmContent(content) {
   if (!Array.isArray(content)) return void 0;
   const calls = [];
   for (const part of content) {
-    if (!isRecord(part) || part["type"] !== "tool-call") continue;
+    if (!isRecord2(part) || part["type"] !== "tool-call") continue;
     const toolCallId = getTranscriptToolCallId(part);
     const toolName = typeof part["toolName"] === "string" ? part["toolName"] : void 0;
     if (toolCallId || toolName) {
@@ -2677,15 +3461,15 @@ function extractToolCallsFromLmContent(content) {
   return calls.length ? calls : void 0;
 }
 function extractExperimentalTelemetry(args) {
-  if (!isRecord(args)) return void 0;
+  if (!isRecord2(args)) return void 0;
   const telemetryConfig = args["experimental_telemetry"];
-  if (!isRecord(telemetryConfig)) return void 0;
+  if (!isRecord2(telemetryConfig)) return void 0;
   return {
     functionId: typeof telemetryConfig["functionId"] === "string" ? telemetryConfig["functionId"] : void 0,
     isEnabled: typeof telemetryConfig["isEnabled"] === "boolean" ? telemetryConfig["isEnabled"] : void 0,
     recordInputs: typeof telemetryConfig["recordInputs"] === "boolean" ? telemetryConfig["recordInputs"] : void 0,
     recordOutputs: typeof telemetryConfig["recordOutputs"] === "boolean" ? telemetryConfig["recordOutputs"] : void 0,
-    metadata: isRecord(telemetryConfig["metadata"]) ? telemetryConfig["metadata"] : void 0
+    metadata: isRecord2(telemetryConfig["metadata"]) ? telemetryConfig["metadata"] : void 0
   };
 }
 function opName(operationId, functionId) {
@@ -2713,7 +3497,7 @@ function attrsFromTelemetryMetadata(metadata) {
   });
 }
 function attrsFromHeaders(headers) {
-  if (!isRecord(headers)) return [];
+  if (!isRecord2(headers)) return [];
   return Object.entries(headers).filter(([, v]) => typeof v === "string").map(([k, v]) => attrString(`ai.request.headers.${k}`, v));
 }
 function attrsFromModelProvider(provider) {
@@ -2726,7 +3510,7 @@ function attrsFromModelProvider(provider) {
   ];
 }
 function attrsFromSettings(args) {
-  if (!isRecord(args)) return [];
+  if (!isRecord2(args)) return [];
   const result = [];
   const settingKeys = [
     "maxRetries",
@@ -2754,7 +3538,7 @@ function attrsFromSettings(args) {
   return result;
 }
 function attrsFromGenAiRequest(options) {
-  if (!isRecord(options)) return [];
+  if (!isRecord2(options)) return [];
   return [
     attrDouble(
       "gen_ai.request.frequency_penalty",
@@ -2784,7 +3568,7 @@ function attrsFromGenAiRequest(options) {
   ];
 }
 function attrProviderOptions(options) {
-  if (!isRecord(options) || !isRecord(options["providerOptions"])) return void 0;
+  if (!isRecord2(options) || !isRecord2(options["providerOptions"])) return void 0;
   const json = safeJsonWithUint8(options["providerOptions"]);
   return json ? attrString("ai.request.providerOptions", json) : void 0;
 }
@@ -2826,10 +3610,10 @@ function readRaindropCallMetadataFromArgs(args) {
   var _a;
   if (args.length === 0) return void 0;
   const first = args[0];
-  if (!isRecord(first)) return void 0;
-  const topLevel = isRecord(first["metadata"]) ? first["metadata"] : void 0;
-  const stable = isRecord(first["telemetry"]) ? first["telemetry"]["metadata"] : void 0;
-  const stableMetadata = isRecord(stable) ? stable : void 0;
+  if (!isRecord2(first)) return void 0;
+  const topLevel = isRecord2(first["metadata"]) ? first["metadata"] : void 0;
+  const stable = isRecord2(first["telemetry"]) ? first["telemetry"]["metadata"] : void 0;
+  const stableMetadata = isRecord2(stable) ? stable : void 0;
   const exp = extractExperimentalTelemetry(first);
   const expMetadata = (exp == null ? void 0 : exp.metadata) && typeof exp.metadata === "object" ? exp.metadata : void 0;
   const raw = (_a = topLevel != null ? topLevel : stableMetadata) != null ? _a : expMetadata;
@@ -3269,38 +4053,38 @@ var CACHE_WRITE_METADATA_KEYS = [
   ["bedrock", "cacheWriteInputTokens"]
 ];
 function cacheWriteTokensFromProviderMetadata(providerMetadata) {
-  if (!isRecord(providerMetadata)) return void 0;
+  if (!isRecord2(providerMetadata)) return void 0;
   return firstTokenCount(
     ...CACHE_WRITE_METADATA_KEYS.flatMap(([namespace, key]) => {
       const scope = providerMetadata[namespace];
-      if (!isRecord(scope)) return [];
+      if (!isRecord2(scope)) return [];
       const usage = scope["usage"];
-      return [scope[key], isRecord(usage) ? usage[key] : void 0];
+      return [scope[key], isRecord2(usage) ? usage[key] : void 0];
     })
   );
 }
 function extractUsageMetricsFromUsage(usage, _provider, providerMetadata) {
-  if (!isRecord(usage)) return {};
+  if (!isRecord2(usage)) return {};
   const inputTokenValue = usage["inputTokens"];
   const outputTokenValue = usage["outputTokens"];
   const inputTokenDetails = usage["inputTokenDetails"];
   const outputTokenDetails = usage["outputTokenDetails"];
-  const hasStructuredUsage = isRecord(inputTokenValue) || isRecord(outputTokenValue) || isRecord(inputTokenDetails) || isRecord(outputTokenDetails);
+  const hasStructuredUsage = isRecord2(inputTokenValue) || isRecord2(outputTokenValue) || isRecord2(inputTokenDetails) || isRecord2(outputTokenDetails);
   const inputTokens = firstTokenCount(
-    isRecord(inputTokenValue) ? inputTokenValue["total"] : void 0,
+    isRecord2(inputTokenValue) ? inputTokenValue["total"] : void 0,
     inputTokenValue,
     usage["promptTokens"],
     usage["prompt_tokens"]
   );
   const outputTokens = firstTokenCount(
-    isRecord(outputTokenValue) ? outputTokenValue["total"] : void 0,
+    isRecord2(outputTokenValue) ? outputTokenValue["total"] : void 0,
     outputTokenValue,
     usage["completionTokens"],
     usage["completion_tokens"]
   );
   const reasoningTokens = firstTokenCount(
-    isRecord(outputTokenValue) ? outputTokenValue["reasoning"] : void 0,
-    isRecord(outputTokenDetails) ? outputTokenDetails["reasoningTokens"] : void 0,
+    isRecord2(outputTokenValue) ? outputTokenValue["reasoning"] : void 0,
+    isRecord2(outputTokenDetails) ? outputTokenDetails["reasoningTokens"] : void 0,
     usage["reasoningTokens"],
     usage["completionReasoningTokens"],
     usage["completion_reasoning_tokens"],
@@ -3309,27 +4093,27 @@ function extractUsageMetricsFromUsage(usage, _provider, providerMetadata) {
     usage["thinking_tokens"]
   );
   const cacheReadInputTokens = firstTokenCount(
-    isRecord(inputTokenValue) ? inputTokenValue["cacheRead"] : void 0,
-    isRecord(inputTokenDetails) ? inputTokenDetails["cacheReadTokens"] : void 0,
+    isRecord2(inputTokenValue) ? inputTokenValue["cacheRead"] : void 0,
+    isRecord2(inputTokenDetails) ? inputTokenDetails["cacheReadTokens"] : void 0,
     usage["cachedInputTokens"],
     usage["promptCachedTokens"],
     usage["prompt_cached_tokens"]
   );
   const cacheWriteInputTokens = firstTokenCount(
-    isRecord(inputTokenValue) ? inputTokenValue["cacheWrite"] : void 0,
-    isRecord(inputTokenDetails) ? inputTokenDetails["cacheWriteTokens"] : void 0,
+    isRecord2(inputTokenValue) ? inputTokenValue["cacheWrite"] : void 0,
+    isRecord2(inputTokenDetails) ? inputTokenDetails["cacheWriteTokens"] : void 0,
     usage["cacheWriteInputTokens"],
     usage["cacheCreationInputTokens"],
     usage["cache_creation_input_tokens"],
     cacheWriteTokensFromProviderMetadata(providerMetadata)
   );
   const nonCachedInputTokens = firstTokenCount(
-    isRecord(inputTokenValue) ? inputTokenValue["noCache"] : void 0,
-    isRecord(inputTokenDetails) ? inputTokenDetails["noCacheTokens"] : void 0
+    isRecord2(inputTokenValue) ? inputTokenValue["noCache"] : void 0,
+    isRecord2(inputTokenDetails) ? inputTokenDetails["noCacheTokens"] : void 0
   );
   const nonReasoningOutputTokens = firstTokenCount(
-    isRecord(outputTokenValue) ? outputTokenValue["text"] : void 0,
-    isRecord(outputTokenDetails) ? outputTokenDetails["textTokens"] : void 0
+    isRecord2(outputTokenValue) ? outputTokenValue["text"] : void 0,
+    isRecord2(outputTokenDetails) ? outputTokenDetails["textTokens"] : void 0
   );
   const totalTokens = firstTokenCount(
     usage["totalTokens"],
@@ -3555,17 +4339,10 @@ var RaindropTelemetryIntegration = class {
         if (event.promptMessages) {
           inputAttrs.push(attrString("ai.prompt.messages", safeJsonWithUint8(event.promptMessages)));
         }
-        if (event.stepTools) {
-          inputAttrs.push(
-            attrStringArray(
-              "ai.prompt.tools",
-              event.stepTools.map((t) => {
-                var _a;
-                return (_a = safeJsonWithUint8(t)) != null ? _a : "";
-              })
-            )
-          );
-        }
+        const promptTools = promptToolsAttribute(
+          resolvePromptTools({ override: this.promptTools, inferred: event.stepTools })
+        );
+        if (promptTools) inputAttrs.push(promptTools);
         if (event.stepToolChoice != null) {
           inputAttrs.push(
             attrString("ai.prompt.toolChoice", safeJsonWithUint8(event.stepToolChoice))
@@ -3913,6 +4690,7 @@ var RaindropTelemetryIntegration = class {
     this.subagentWrapping = opts.subagentWrapping !== false;
     this.debug = opts.debug === true;
     this.defaultContext = opts.context;
+    this.promptTools = opts.tools;
     this.subagents = new SubagentApi({
       traceShipper: this.traceShipper,
       eventShipper: this.eventShipper,
@@ -4538,6 +5316,18 @@ function createStandaloneSelfDiagnosticsTool(args) {
 }
 
 // src/internal/wrap/wrapAISDK.ts
+function promptToolsOptionsFrom(aiSDK) {
+  if (!isRecord2(aiSDK)) return void 0;
+  const asSchema = aiSDK["asSchema"];
+  if (!isFunction(asSchema)) return void 0;
+  return {
+    schema: (schema) => {
+      const converted = asSchema(schema);
+      const json = isRecord2(converted) ? converted["jsonSchema"] : void 0;
+      return isRecord2(json) ? json : void 0;
+    }
+  };
+}
 var pendingStoresByShipper = /* @__PURE__ */ new WeakMap();
 var PendingToolSpanStore = class _PendingToolSpanStore {
   constructor() {
@@ -4594,9 +5384,9 @@ function _resetWarnedMissingUserId() {
   warnedMissingUserId = false;
 }
 function extractRaindropCallOptions(options) {
-  if (!isRecord(options)) return {};
+  if (!isRecord2(options)) return {};
   const em = options["metadata"];
-  if (isRecord(em)) return extractRaindropMetadata(em);
+  if (isRecord2(em)) return extractRaindropMetadata(em);
   const telemetry = extractExperimentalTelemetry(options);
   if (telemetry == null ? void 0 : telemetry.metadata) return extractRaindropMetadata(telemetry.metadata);
   return {};
@@ -4658,20 +5448,20 @@ function mergeContexts(wrapTime, callTime) {
   return result;
 }
 function detectAISDKVersion(aiSDK) {
-  if (!isRecord(aiSDK)) return "unknown";
+  if (!isRecord2(aiSDK)) return "unknown";
   if (isFunction(aiSDK["jsonSchema"])) return "6";
   if (isFunction(aiSDK["tool"])) return "5";
   return "4";
 }
 function hasStructuredTelemetryEvents(aiSDK) {
-  if (!isRecord(aiSDK)) return false;
+  if (!isRecord2(aiSDK)) return false;
   const hasRegister = isFunction(aiSDK["registerTelemetry"]) || isFunction(aiSDK["registerTelemetryIntegration"]);
   const hasV7Marker = isFunction(aiSDK["experimental_streamLanguageModelCall"]) || isFunction(aiSDK["experimental_streamModelCall"]);
   return hasRegister && hasV7Marker;
 }
 function resolveRegisterTelemetry(aiSDK) {
   var _a;
-  if (!isRecord(aiSDK)) return void 0;
+  if (!isRecord2(aiSDK)) return void 0;
   const fn = (_a = aiSDK["registerTelemetry"]) != null ? _a : aiSDK["registerTelemetryIntegration"];
   return isFunction(fn) ? fn : void 0;
 }
@@ -4702,18 +5492,18 @@ function isAsyncIterable(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
 }
 function resolveUsageRecord(result) {
-  if (!isRecord(result)) return void 0;
+  if (!isRecord2(result)) return void 0;
   let usage;
   try {
-    if (isRecord(result["totalUsage"])) {
+    if (isRecord2(result["totalUsage"])) {
       usage = result["totalUsage"];
-    } else if (isRecord(result["usage"])) {
+    } else if (isRecord2(result["usage"])) {
       usage = result["usage"];
     }
   } catch (e) {
     return void 0;
   }
-  return isRecord(usage) ? usage : void 0;
+  return isRecord2(usage) ? usage : void 0;
 }
 function extractUsageMetrics(result) {
   return extractUsageMetricsFromUsage(resolveUsageRecord(result));
@@ -4734,7 +5524,7 @@ function shouldKeepEventPending(params) {
 }
 function normalizePromptAttr(arg) {
   var _a, _b;
-  if (!isRecord(arg)) return arg;
+  if (!isRecord2(arg)) return arg;
   const system = arg["system"];
   const prompt = arg["prompt"];
   const messages = arg["messages"];
@@ -4788,7 +5578,7 @@ async function runWithRootContextAsync(rootSpan, eventId, fn) {
   );
 }
 function teeStreamObjectBaseStream(result) {
-  if (!result || !isRecord(result)) return;
+  if (!result || !isRecord2(result)) return;
   const baseStream = result["baseStream"];
   if (!(baseStream && typeof baseStream === "object" && "tee" in baseStream)) return;
   try {
@@ -4829,7 +5619,7 @@ function setupOperation(params) {
   const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
   const outerOperationId = `ai.${operation}`;
   const { operationName, resourceName } = opName(outerOperationId, telemetry == null ? void 0 : telemetry.functionId);
-  const modelInfoFromArgs = isRecord(arg) ? extractModelInfo(arg["model"]) : {};
+  const modelInfoFromArgs = isRecord2(arg) ? extractModelInfo(arg["model"]) : {};
   const rootSpan = sendTraces ? traceShipper.startSpan({
     name: outerOperationId,
     parent: inheritedParent,
@@ -4844,7 +5634,7 @@ function setupOperation(params) {
       attrString("ai.model.id", modelInfoFromArgs.modelId),
       attrString("ai.telemetry.metadata.raindrop.eventId", eventId),
       ...attrsFromTelemetryMetadata(telemetry == null ? void 0 : telemetry.metadata),
-      ...attrsFromHeaders(isRecord(arg) ? arg["headers"] : void 0),
+      ...attrsFromHeaders(isRecord2(arg) ? arg["headers"] : void 0),
       ...attrsFromSettings(arg),
       ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [attrString("ai.prompt", safeJsonWithUint8(normalizePromptAttr(arg)))]
     ]
@@ -4861,7 +5651,9 @@ function setupOperation(params) {
     traceShipper,
     rootParentForChildren,
     selfDiagnostics: operationSelfDiagnostics,
-    aiSDKVersion: detectAISDKVersion(aiSDK)
+    aiSDKVersion: detectAISDKVersion(aiSDK),
+    promptTools: options.tools,
+    promptToolsOptions: promptToolsOptionsFrom(aiSDK)
   };
   const toolCalls = [];
   const argsWithWrappedTools = wrapTools(arg, wrapCtx, toolCalls);
@@ -4934,8 +5726,8 @@ function createFinalize(params) {
         endTimeUnixNano: spanEndTimeUnixNano,
         keepEventPending
       });
-      const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
-      const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : setup.toolCalls.length ? safeJsonWithUint8(setup.toolCalls) : void 0;
+      const providerMetadata = isRecord2(result) ? result["providerMetadata"] : void 0;
+      const resultToolCalls = isRecord2(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : setup.toolCalls.length ? safeJsonWithUint8(setup.toolCalls) : void 0;
       traceShipper.endSpan(setup.rootSpan, {
         attributes: [
           ...((_d = setup.telemetry) == null ? void 0 : _d.recordOutputs) === false ? [] : [
@@ -5207,6 +5999,7 @@ function wrapAISDK(aiSDK, deps) {
       sendEvents: ((_b = deps.options.send) == null ? void 0 : _b.events) !== false,
       debug,
       settledEventIds: deps.settledEventIds,
+      tools: deps.options.tools,
       context: {
         userId: wrapTimeCtx.userId,
         eventId: wrapTimeCtx.eventId,
@@ -5249,7 +6042,7 @@ function wrapAISDK(aiSDK, deps) {
           const arg = callArgs[0];
           const callMetadata = readRaindropCallMetadataFromArgs(callArgs);
           const callOriginal = () => original.call(aiSDK, ...callArgs);
-          if (selfDiagnostics2 && selfDiagnosticsOps.has(propName) && isRecord(arg)) {
+          if (selfDiagnostics2 && selfDiagnosticsOps.has(propName) && isRecord2(arg)) {
             const telemetry = extractExperimentalTelemetry(arg);
             const callMeta = (telemetry == null ? void 0 : telemetry.metadata) ? extractRaindropMetadata(telemetry.metadata) : {};
             const perCallEventIdExplicit = (_b2 = (_a2 = callMetadata == null ? void 0 : callMetadata.eventId) != null ? _a2 : callMeta.eventId) != null ? _b2 : wrapTimeCtx.eventId;
@@ -5261,16 +6054,18 @@ function wrapAISDK(aiSDK, deps) {
               eventShipper: deps.eventShipper,
               traceShipper: deps.traceShipper,
               selfDiagnostics: selfDiagnostics2,
-              aiSDKVersion: "7"
+              aiSDKVersion: "7",
+              promptTools: deps.options.tools,
+              promptToolsOptions: promptToolsOptionsFrom(aiSDK)
             };
-            const tools = isRecord(arg["tools"]) ? { ...arg["tools"] } : {};
+            const tools = isRecord2(arg["tools"]) ? { ...arg["tools"] } : {};
             const toolName = selfDiagnostics2.toolName;
             if (!(toolName in tools)) {
               const reportTool = createSelfDiagnosticsTool(perCallCtx);
               if (reportTool) tools[toolName] = reportTool;
             }
-            const existingTelemetry = isRecord(arg["experimental_telemetry"]) ? arg["experimental_telemetry"] : {};
-            const existingMetadata = isRecord(existingTelemetry["metadata"]) ? existingTelemetry["metadata"] : {};
+            const existingTelemetry = isRecord2(arg["experimental_telemetry"]) ? arg["experimental_telemetry"] : {};
+            const existingMetadata = isRecord2(existingTelemetry["metadata"]) ? existingTelemetry["metadata"] : {};
             const mergedMetadata = existingMetadata["raindrop.eventId"] ? existingMetadata : {
               ...existingMetadata,
               "raindrop.eventId": perCallEventId,
@@ -5466,7 +6261,9 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
       traceShipper: deps.traceShipper,
       rootParentForChildren,
       selfDiagnostics,
-      aiSDKVersion: detectAISDKVersion(aiSDK)
+      aiSDKVersion: detectAISDKVersion(aiSDK),
+      promptTools: deps.options.tools,
+      promptToolsOptions: promptToolsOptionsFrom(aiSDK)
     };
     const toolCalls = [];
     const mergedArgsWithWrappedTools = wrapTools(mergedArgs, wrapCtx, toolCalls);
@@ -5516,8 +6313,8 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
           keepEventPending: false
         });
         const finishReason = extractFinishReason(result);
-        const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
-        const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
+        const providerMetadata = isRecord2(result) ? result["providerMetadata"] : void 0;
+        const resultToolCalls = isRecord2(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
         deps.traceShipper.endSpan(rootSpan, {
           attributes: [
             ...(telemetry == null ? void 0 : telemetry.recordOutputs) === false ? [] : [
@@ -5686,7 +6483,9 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
       traceShipper: deps.traceShipper,
       rootParentForChildren,
       selfDiagnostics,
-      aiSDKVersion: detectAISDKVersion(aiSDK)
+      aiSDKVersion: detectAISDKVersion(aiSDK),
+      promptTools: deps.options.tools,
+      promptToolsOptions: promptToolsOptionsFrom(aiSDK)
     };
     const toolCalls = [];
     const mergedArgsWithWrappedTools = wrapTools(mergedArgs, wrapCtx, toolCalls);
@@ -5736,8 +6535,8 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
           keepEventPending: false
         });
         const finishReason = extractFinishReason(result);
-        const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
-        const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
+        const providerMetadata = isRecord2(result) ? result["providerMetadata"] : void 0;
+        const resultToolCalls = isRecord2(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
         deps.traceShipper.endSpan(rootSpan, {
           attributes: [
             ...(telemetry == null ? void 0 : telemetry.recordOutputs) === false ? [] : [
@@ -5849,8 +6648,8 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
   };
 }
 function wrapTools(args, ctx, toolCalls) {
-  if (!isRecord(args)) return args;
-  const tools = isRecord(args["tools"]) ? { ...args["tools"] } : {};
+  if (!isRecord2(args)) return args;
+  const tools = isRecord2(args["tools"]) ? { ...args["tools"] } : {};
   if (ctx.selfDiagnostics) {
     const reportToolName = ctx.selfDiagnostics.toolName;
     if (!(reportToolName in tools)) {
@@ -5873,7 +6672,7 @@ function wrapTools(args, ctx, toolCalls) {
 }
 function wrapToolExecute(name, tool, ctx, toolCalls) {
   var _a;
-  if (!isRecord(tool) || !isFunction(tool["execute"])) return tool;
+  if (!isRecord2(tool) || !isFunction(tool["execute"])) return tool;
   const originalExecute = tool["execute"];
   const { operationName, resourceName } = opName("ai.toolCall", (_a = ctx.telemetry) == null ? void 0 : _a.functionId);
   const createToolSpan = (toolCallId, toolArgs, parent) => {
@@ -5934,7 +6733,7 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
   const wrappedExecute = function(...execArgs) {
     const toolArgs = execArgs[0];
     const execOptions = execArgs.length > 1 ? execArgs[1] : void 0;
-    const toolCallId = isRecord(execOptions) && typeof execOptions["toolCallId"] === "string" ? execOptions["toolCallId"] : randomUUID();
+    const toolCallId = isRecord2(execOptions) && typeof execOptions["toolCallId"] === "string" ? execOptions["toolCallId"] : randomUUID();
     const result = originalExecute.apply(this, execArgs);
     if (isAsyncIterable(result)) {
       return (async function* () {
@@ -6009,20 +6808,20 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
   return { ...tool, execute: wrappedExecute };
 }
 function wrapModel(args, aiSDK, outerOperationId, ctx) {
-  if (!isRecord(args) || !("model" in args)) return args;
+  if (!isRecord2(args) || !("model" in args)) return args;
   let model = args["model"];
   if (typeof model === "string") {
     const maybeProvider = globalThis.AI_SDK_DEFAULT_PROVIDER;
-    const gateway = isRecord(aiSDK) ? aiSDK["gateway"] : void 0;
+    const gateway = isRecord2(aiSDK) ? aiSDK["gateway"] : void 0;
     const provider = maybeProvider != null ? maybeProvider : gateway;
-    if (isRecord(provider) && isFunction(provider["languageModel"])) {
+    if (isRecord2(provider) && isFunction(provider["languageModel"])) {
       try {
         model = provider["languageModel"](model);
       } catch (e) {
       }
     }
   }
-  if (!isRecord(model)) return args;
+  if (!isRecord2(model)) return args;
   const modelInfo = extractModelInfo(model);
   const doGenerateOpId = `${outerOperationId}.doGenerate`;
   const doStreamOpId = `${outerOperationId}.doStream`;
@@ -6039,13 +6838,13 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
           try {
             const result = await original.apply(target, callArgs);
             if (span) endDoGenerateSpan(span, result, modelInfo, ctx);
-            if (localDebuggerEnabled() && ctx.rootParentForChildren && isRecord(result)) {
+            if (localDebuggerEnabled() && ctx.rootParentForChildren && isRecord2(result)) {
               const traceId = ctx.rootParentForChildren.traceIdB64;
               const liveMeta = getLocalDebuggerMetadata({ ...ctx.context, eventId: ctx.eventId });
               const content = result["content"];
               if (Array.isArray(content)) {
                 for (const part of content) {
-                  if (isRecord(part)) {
+                  if (isRecord2(part)) {
                     if ((part["type"] === "reasoning" || part["type"] === "thinking") && typeof ((_a = part["text"]) != null ? _a : part["thinking"]) === "string") {
                       sendLocalDebuggerLiveEvent({
                         traceId,
@@ -6114,7 +6913,7 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
               });
             throw error;
           }
-          const stream = isRecord(result) ? result["stream"] : void 0;
+          const stream = isRecord2(result) ? result["stream"] : void 0;
           const RS = globalThis.ReadableStream;
           if (!RS || !(stream instanceof RS)) {
             if (span) ctx.traceShipper.endSpan(span);
@@ -6187,7 +6986,7 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                   return;
                 }
                 if (firstChunkMs === void 0) firstChunkMs = Date.now();
-                if (isRecord(value)) {
+                if (isRecord2(value)) {
                   const type = value["type"];
                   if (type === "text-delta") {
                     let textDelta;
@@ -6202,7 +7001,7 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                   }
                   if (type === "finish") finishReason = extractFinishReason(value);
                   if (type === "tool-call") toolCallsLocal.push(value);
-                  if ("response" in value && isRecord(value["response"])) {
+                  if ("response" in value && isRecord2(value["response"])) {
                     const response = value["response"];
                     if (typeof response["id"] === "string") responseId = response["id"];
                     if (typeof response["modelId"] === "string")
@@ -6279,10 +7078,15 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
 function startDoGenerateSpan(operationId, options, modelInfo, parent, ctx) {
   var _a, _b, _c;
   const { operationName, resourceName } = opName(operationId, (_a = ctx.telemetry) == null ? void 0 : _a.functionId);
-  const tools = isRecord(options) ? options["tools"] : void 0;
-  const toolsJson = Array.isArray(tools) && tools.length ? tools.map((tool) => safeJsonWithUint8(tool)).filter((json) => typeof json === "string" && json.length > 0) : void 0;
-  const toolChoiceJson = isRecord(options) ? safeJsonWithUint8(options["toolChoice"]) : void 0;
-  const promptJson = isRecord(options) ? safeJsonWithUint8(options["prompt"]) : safeJsonWithUint8(options);
+  const promptTools = promptToolsAttribute(
+    resolvePromptTools({
+      override: ctx.promptTools,
+      inferred: isRecord2(options) ? options["tools"] : void 0,
+      options: ctx.promptToolsOptions
+    })
+  );
+  const toolChoiceJson = isRecord2(options) ? safeJsonWithUint8(options["toolChoice"]) : void 0;
+  const promptJson = isRecord2(options) ? safeJsonWithUint8(options["prompt"]) : safeJsonWithUint8(options);
   return ctx.traceShipper.startSpan({
     name: operationId,
     parent,
@@ -6297,7 +7101,7 @@ function startDoGenerateSpan(operationId, options, modelInfo, parent, ctx) {
       attrString("ai.model.id", modelInfo.modelId),
       ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [
         attrString("ai.prompt.messages", promptJson),
-        attrStringArray("ai.prompt.tools", toolsJson),
+        promptTools,
         attrString("ai.prompt.toolChoice", toolChoiceJson)
       ],
       attrString(MODEL_USAGE_ATTRIBUTES.requestModel, modelInfo.modelId),
@@ -6309,26 +7113,26 @@ function startDoGenerateSpan(operationId, options, modelInfo, parent, ctx) {
 function endDoGenerateSpan(span, result, modelInfo, ctx) {
   var _a;
   const finishReason = extractFinishReason(result);
-  const content = isRecord(result) ? result["content"] : void 0;
-  const response = isRecord(result) ? result["response"] : void 0;
-  const usage = isRecord(result) ? result["usage"] : void 0;
-  const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
+  const content = isRecord2(result) ? result["content"] : void 0;
+  const response = isRecord2(result) ? result["response"] : void 0;
+  const usage = isRecord2(result) ? result["usage"] : void 0;
+  const providerMetadata = isRecord2(result) ? result["providerMetadata"] : void 0;
   let responseId;
-  if (isRecord(response) && typeof response["id"] === "string") {
+  if (isRecord2(response) && typeof response["id"] === "string") {
     responseId = response["id"];
   } else {
     responseId = randomUUID();
   }
   let responseModelId;
-  if (isRecord(response) && typeof response["modelId"] === "string") {
+  if (isRecord2(response) && typeof response["modelId"] === "string") {
     responseModelId = response["modelId"];
   } else {
     responseModelId = modelInfo.modelId;
   }
   let responseTimestampIso;
-  if (isRecord(response) && response["timestamp"] instanceof Date) {
+  if (isRecord2(response) && response["timestamp"] instanceof Date) {
     responseTimestampIso = response["timestamp"].toISOString();
-  } else if (isRecord(response) && typeof response["timestamp"] === "string") {
+  } else if (isRecord2(response) && typeof response["timestamp"] === "string") {
     responseTimestampIso = response["timestamp"];
   } else {
     responseTimestampIso = (/* @__PURE__ */ new Date()).toISOString();
@@ -6362,10 +7166,15 @@ function endDoGenerateSpan(span, result, modelInfo, ctx) {
 function startDoStreamSpan(operationId, options, modelInfo, parent, ctx) {
   var _a, _b, _c;
   const { operationName, resourceName } = opName(operationId, (_a = ctx.telemetry) == null ? void 0 : _a.functionId);
-  const tools = isRecord(options) ? options["tools"] : void 0;
-  const toolsJson = Array.isArray(tools) && tools.length ? tools.map((tool) => safeJsonWithUint8(tool)).filter((json) => typeof json === "string" && json.length > 0) : void 0;
-  const toolChoiceJson = isRecord(options) ? safeJsonWithUint8(options["toolChoice"]) : void 0;
-  const promptJson = isRecord(options) ? safeJsonWithUint8(options["prompt"]) : safeJsonWithUint8(options);
+  const promptTools = promptToolsAttribute(
+    resolvePromptTools({
+      override: ctx.promptTools,
+      inferred: isRecord2(options) ? options["tools"] : void 0,
+      options: ctx.promptToolsOptions
+    })
+  );
+  const toolChoiceJson = isRecord2(options) ? safeJsonWithUint8(options["toolChoice"]) : void 0;
+  const promptJson = isRecord2(options) ? safeJsonWithUint8(options["prompt"]) : safeJsonWithUint8(options);
   return ctx.traceShipper.startSpan({
     name: operationId,
     parent,
@@ -6380,7 +7189,7 @@ function startDoStreamSpan(operationId, options, modelInfo, parent, ctx) {
       attrString("ai.model.id", modelInfo.modelId),
       ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [
         attrString("ai.prompt.messages", promptJson),
-        attrStringArray("ai.prompt.tools", toolsJson),
+        promptTools,
         attrString("ai.prompt.toolChoice", toolChoiceJson)
       ],
       attrString(MODEL_USAGE_ATTRIBUTES.requestModel, modelInfo.modelId),
@@ -6394,7 +7203,7 @@ function resolveContext(context, info) {
   return typeof context === "function" ? context(info) : context;
 }
 function wrapOnFinish(args, onFinish) {
-  if (!isRecord(args)) return args;
+  if (!isRecord2(args)) return args;
   const existing = args["onFinish"];
   if (existing === void 0) {
     return { ...args, onFinish: async (result) => onFinish(result) };
@@ -6452,14 +7261,14 @@ function mergeAttachments(...groups) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.3.2"};
+  version: "0.3.4"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
 var libraryVersion = package_default.version;
 
 // src/internal/events.ts
-var EventShipper2 = class extends EventShipper {
+var EventShipper3 = class extends EventShipper2 {
   constructor(opts) {
     var _a, _b, _c;
     super({
@@ -6472,7 +7281,7 @@ var EventShipper2 = class extends EventShipper {
 };
 
 // src/internal/traces.ts
-var TraceShipper2 = class extends TraceShipper {
+var TraceShipper3 = class extends TraceShipper2 {
   constructor(opts) {
     var _a, _b, _c;
     super({
@@ -6539,11 +7348,11 @@ function userAttrsToOtlp(attrs) {
 function envDebugEnabled() {
   var _a;
   if (typeof process === "undefined") return false;
-  const flag = (_a = process.env) == null ? void 0 : _a.RAINDROP_AI_DEBUG;
-  return flag === "1" || flag === "true";
+  const flag2 = (_a = process.env) == null ? void 0 : _a.RAINDROP_AI_DEBUG;
+  return flag2 === "1" || flag2 === "true";
 }
 function createRaindropAISDK(opts) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
   const writeKey = opts.writeKey;
   const eventsRequested = ((_a = opts.events) == null ? void 0 : _a.enabled) !== false;
   const tracesRequested = ((_b = opts.traces) == null ? void 0 : _b.enabled) !== false;
@@ -6552,37 +7361,53 @@ function createRaindropAISDK(opts) {
   const localWorkshopInput = opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl;
   const resolvedLocalDebuggerUrl = resolveLocalDebuggerBaseUrl(localWorkshopInput);
   const localDebuggerUrl = localWorkshopInput === null ? null : resolvedLocalDebuggerUrl != null ? resolvedLocalDebuggerUrl : void 0;
-  const hasDestination = !!writeKey || !!resolvedLocalDebuggerUrl;
-  const eventsEnabled = eventsRequested && hasDestination;
-  const tracesEnabled = tracesRequested && hasDestination;
-  if (!hasDestination && (eventsRequested || tracesRequested)) {
+  const hasDestination2 = Boolean(writeKey == null ? void 0 : writeKey.trim()) || Boolean(resolvedLocalDebuggerUrl);
+  const eventsEnabled = eventsRequested && hasDestination2;
+  const tracesEnabled = tracesRequested && hasDestination2;
+  const appGitContext = (_c = opts.appGitContext) != null ? _c : createAppGitContext2(
+    eventsEnabled || tracesEnabled ? opts.appGit : false,
+    { allowLocalGit: true }
+  );
+  if (!hasDestination2 && (eventsRequested || tracesRequested)) {
     console.warn(
       "[raindrop-ai/ai-sdk] writeKey not provided and no local Workshop reachable; telemetry shipping is disabled"
     );
   }
-  const eventShipper = new EventShipper2({
-    writeKey,
-    endpoint: opts.endpoint,
-    enabled: eventsEnabled,
-    debug: ((_c = opts.events) == null ? void 0 : _c.debug) === true || envDebug,
-    partialFlushMs: (_d = opts.events) == null ? void 0 : _d.partialFlushMs,
-    projectId: opts.projectId,
-    localDebuggerUrl
-  });
-  const traceShipper = new TraceShipper2({
-    writeKey,
-    endpoint: opts.endpoint,
-    enabled: tracesEnabled,
-    debug: ((_e = opts.traces) == null ? void 0 : _e.debug) === true || envDebug,
-    debugSpans: ((_f = opts.traces) == null ? void 0 : _f.debugSpans) === true || envDebug,
-    flushIntervalMs: (_g = opts.traces) == null ? void 0 : _g.flushIntervalMs,
-    maxBatchSize: (_h = opts.traces) == null ? void 0 : _h.maxBatchSize,
-    maxQueueSize: (_i = opts.traces) == null ? void 0 : _i.maxQueueSize,
-    projectId: opts.projectId,
-    localDebuggerUrl,
-    transformSpan: (_j = opts.traces) == null ? void 0 : _j.transformSpan,
-    disableDefaultRedaction: (_k = opts.traces) == null ? void 0 : _k.disableDefaultRedaction
-  });
+  let eventShipper;
+  let traceShipper;
+  try {
+    eventShipper = new EventShipper3({
+      writeKey,
+      endpoint: opts.endpoint,
+      enabled: eventsEnabled,
+      debug: ((_d = opts.events) == null ? void 0 : _d.debug) === true || envDebug,
+      partialFlushMs: (_e = opts.events) == null ? void 0 : _e.partialFlushMs,
+      projectId: opts.projectId,
+      localDebuggerUrl,
+      appGitContext
+    });
+    traceShipper = new TraceShipper3({
+      writeKey,
+      endpoint: opts.endpoint,
+      enabled: tracesEnabled,
+      debug: ((_f = opts.traces) == null ? void 0 : _f.debug) === true || envDebug,
+      debugSpans: ((_g = opts.traces) == null ? void 0 : _g.debugSpans) === true || envDebug,
+      flushIntervalMs: (_h = opts.traces) == null ? void 0 : _h.flushIntervalMs,
+      maxBatchSize: (_i = opts.traces) == null ? void 0 : _i.maxBatchSize,
+      maxQueueSize: (_j = opts.traces) == null ? void 0 : _j.maxQueueSize,
+      projectId: opts.projectId,
+      localDebuggerUrl,
+      transformSpan: (_k = opts.traces) == null ? void 0 : _k.transformSpan,
+      disableDefaultRedaction: (_l = opts.traces) == null ? void 0 : _l.disableDefaultRedaction,
+      appGitContext
+    });
+  } catch (error) {
+    try {
+      appGitContext.dispose();
+    } catch (e) {
+    }
+    throw error;
+  }
   const settledEventIds = /* @__PURE__ */ new Set();
   const subagentApi = new SubagentApi({
     traceShipper,
@@ -6620,11 +7445,16 @@ function createRaindropAISDK(opts) {
       ];
       let context;
       let subagentWrapping;
+      let tools;
       if (contextOrOptions === void 0) ; else if ("context" in contextOrOptions) {
-        context = contextOrOptions.context;
-        subagentWrapping = contextOrOptions.subagentWrapping;
-      } else if ("subagentWrapping" in contextOrOptions && !FLAT_CONTEXT_KEYS.some((k) => k in contextOrOptions)) {
-        subagentWrapping = contextOrOptions.subagentWrapping;
+        const shaped = contextOrOptions;
+        context = shaped.context;
+        subagentWrapping = shaped.subagentWrapping;
+        tools = shaped.tools;
+      } else if (("subagentWrapping" in contextOrOptions || "tools" in contextOrOptions) && !FLAT_CONTEXT_KEYS.some((k) => k in contextOrOptions)) {
+        const shaped = contextOrOptions;
+        subagentWrapping = shaped.subagentWrapping;
+        tools = shaped.tools;
       } else {
         context = contextOrOptions;
       }
@@ -6636,7 +7466,8 @@ function createRaindropAISDK(opts) {
         subagentWrapping,
         debug: envDebug,
         settledEventIds,
-        context
+        context,
+        tools
       });
     },
     subagents: subagentApi,
@@ -6750,16 +7581,23 @@ function createRaindropAISDK(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 (e) {
+        }
+      }
     }
   };
 }
 function raindrop(options = {}) {
   var _a;
-  const { context, subagentWrapping, writeKey, ...rest } = options;
+  const { context, subagentWrapping, tools, writeKey, ...rest } = options;
   const resolvedWriteKey = writeKey != null ? writeKey : typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a.RAINDROP_WRITE_KEY : void 0;
   const client = createRaindropAISDK({ ...rest, writeKey: resolvedWriteKey });
-  return client.createTelemetryIntegration({ context, subagentWrapping });
+  return client.createTelemetryIntegration({ context, subagentWrapping, tools });
 }
 
-export { DEFAULT_MAX_TEXT_FIELD_CHARS2 as DEFAULT_MAX_TEXT_FIELD_CHARS, DEFAULT_REDACT_ATTRIBUTE_KEYS, DEFAULT_SECRET_KEY_NAMES, DETACHED_MODE, HANDOFF_ATTRIBUTE_PREFIXES, HANDOFF_ATTRIBUTE_SUFFIXES, HANDOFF_TERMINAL_CANCELLED, HANDOFF_TERMINAL_PROPERTY_KEY, REDACTED_PLACEHOLDER, RaindropTelemetryIntegration, SUBAGENT_ABORTED_OUTPUT, SUBAGENT_AGENT_ROLE, SUBAGENT_CANCELLED_OUTPUT, TOOL_EVENTS_ALLOW, TRUNCATION_MARKER2 as TRUNCATION_MARKER, _resetParentToolContextStorage, _resetRaindropCallMetadataStorage, _resetWarnedMissingUserId, boundedStringify, capText2 as capText, clearParentToolContext, createRaindropAISDK, currentSpan, defaultTransformSpan, enterParentToolContext, eventMetadata, eventMetadataFromChatRequest, fromHeaders, getContextManager, getCurrentParentToolContext, getCurrentRaindropCallMetadata, normalizeFeatureFlags, raindrop, readRaindropCallMetadataFromArgs, redactJsonAttributeValue, redactSecretsInObject, resetUnresolvedCarrierWarning, runWithParentToolContext, runWithRaindropCallMetadata, toHeaders, toLangSmithHeaders, withCurrent };
+export { DEFAULT_MAX_TEXT_FIELD_CHARS2 as DEFAULT_MAX_TEXT_FIELD_CHARS, DEFAULT_REDACT_ATTRIBUTE_KEYS, DEFAULT_SECRET_KEY_NAMES, DETACHED_MODE, HANDOFF_ATTRIBUTE_PREFIXES, HANDOFF_ATTRIBUTE_SUFFIXES, HANDOFF_TERMINAL_CANCELLED, HANDOFF_TERMINAL_PROPERTY_KEY, PROMPT_TOOLS_ATTRIBUTE, REDACTED_PLACEHOLDER, RaindropTelemetryIntegration, SUBAGENT_ABORTED_OUTPUT, SUBAGENT_AGENT_ROLE, SUBAGENT_CANCELLED_OUTPUT, TOOL_EVENTS_ALLOW, TRUNCATION_MARKER2 as TRUNCATION_MARKER, _resetParentToolContextStorage, _resetRaindropCallMetadataStorage, _resetWarnedMissingUserId, boundedStringify, capText2 as capText, clearParentToolContext, createRaindropAISDK, currentSpan, defaultTransformSpan, enterParentToolContext, eventMetadata, eventMetadataFromChatRequest, fromHeaders, getContextManager, getCurrentParentToolContext, getCurrentRaindropCallMetadata, normalizeFeatureFlags, raindrop, readRaindropCallMetadataFromArgs, redactJsonAttributeValue, redactSecretsInObject, resetUnresolvedCarrierWarning, runWithParentToolContext, runWithRaindropCallMetadata, toHeaders, toLangSmithHeaders, withCurrent };