claude-code-best 1.4.4 → 1.5.0

package/dist/{chunk-1npsp555.js → chunk-d6kw0esk.js}

@@ -7,12 +7,17 @@ import {
   readJSONLFile,
   safeParseJSON,
   stripBOM
-} from "./chunk-h3p151fx.js";
+} from "./chunk-ykcqa4mj.js";
 import {
   expandPath,
   init_path,
   normalizePathForConfigKey
-} from "./chunk-6gg2cvm2.js";
+} from "./chunk-r4j2h4yp.js";
+import {
+  getAWSClientProxyConfig,
+  getProxyFetchOptions,
+  init_proxy
+} from "./chunk-7zrkp054.js";
 import {
   count,
   getAgentId,
@@ -26,16 +31,6 @@ import {
   lockSync,
   uniq
 } from "./chunk-zwarn9h7.js";
-import {
-  getAWSClientProxyConfig,
-  getProxyFetchOptions,
-  init_proxy
-} from "./chunk-hxc8e6wd.js";
-import {
-  EXTERNAL_PERMISSION_MODES,
-  PERMISSION_MODES,
-  init_permissions
-} from "./chunk-qbrsmra3.js";
 import {
   sanitizePath
 } from "./chunk-7hmy36fh.js";
@@ -43,6 +38,15 @@ import {
   init_lazySchema,
   lazySchema
 } from "./chunk-64c1avct.js";
+import {
+  EXTERNAL_PERMISSION_MODES,
+  PERMISSION_MODES,
+  init_permissions
+} from "./chunk-qbrsmra3.js";
+import {
+  init_sleep,
+  sleep
+} from "./chunk-8g5pe1gr.js";
 import {
   detectVcs,
   getLinuxDistroInfo,
@@ -50,27 +54,15 @@ import {
   getWslVersion,
   init_platform
 } from "./chunk-pjz4m7pd.js";
-import {
-  init_sleep,
-  sleep
-} from "./chunk-8g5pe1gr.js";
 import {
   getAncestorCommandsAsync,
   init_genericProcessUtils
 } from "./chunk-zvdc0eh1.js";
-import {
-  init_v4,
-  v4_default
-} from "./chunk-8g747a8x.js";
-import {
-  exports_external,
-  toJSONSchema
-} from "./chunk-d7886r6a.js";
 import {
   require_src as require_src2,
   require_src1 as require_src3,
   require_src2 as require_src4
-} from "./chunk-f5ma3nh5.js";
+} from "./chunk-7a31vc3r.js";
 import {
   exports_common,
   init_common
@@ -99,6 +91,14 @@ import {
   getOauthConfig,
   init_oauth
 } from "./chunk-rh5a2rg9.js";
+import {
+  init_v4,
+  v4_default
+} from "./chunk-8g747a8x.js";
+import {
+  exports_external,
+  toJSONSchema
+} from "./chunk-d7886r6a.js";
 import {
   require_src
 } from "./chunk-p2816w9z.js";
@@ -122,11 +122,11 @@ import {
   init_diagLogs,
   init_git,
   logForDiagnosticsNoPII
-} from "./chunk-73pxnrgv.js";
+} from "./chunk-rvb54w68.js";
 import {
   init_memoize as init_memoize2,
   memoizeWithTTLAsync
-} from "./chunk-5aw4k8fc.js";
+} from "./chunk-fz395yre.js";
 import {
   execFileNoThrow,
   execFileNoThrowWithCwd,
@@ -5014,6 +5014,1045 @@ var init_user = __esm(() => {
   });
 });
 
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+function suppressTracing(context) {
+  return context.setValue(SUPPRESS_TRACING_KEY, true);
+}
+function isTracingSuppressed(context) {
+  return context.getValue(SUPPRESS_TRACING_KEY) === true;
+}
+var import_api, SUPPRESS_TRACING_KEY;
+var init_suppress_tracing = __esm(() => {
+  import_api = __toESM(require_src(), 1);
+  SUPPRESS_TRACING_KEY = import_api.createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/baggage/constants.js
+var BAGGAGE_KEY_PAIR_SEPARATOR = "=", BAGGAGE_PROPERTIES_SEPARATOR = ";", BAGGAGE_ITEMS_SEPARATOR = ",", BAGGAGE_HEADER = "baggage", BAGGAGE_MAX_NAME_VALUE_PAIRS = 180, BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096, BAGGAGE_MAX_TOTAL_LENGTH = 8192;
+var init_constants = () => {};
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/baggage/utils.js
+function serializeKeyPairs(keyPairs) {
+  return keyPairs.reduce((hValue, current) => {
+    const value = `${hValue}${hValue !== "" ? BAGGAGE_ITEMS_SEPARATOR : ""}${current}`;
+    return value.length > BAGGAGE_MAX_TOTAL_LENGTH ? hValue : value;
+  }, "");
+}
+function getKeyPairs(baggage) {
+  return baggage.getAllEntries().map(([key, value]) => {
+    let entry = `${encodeURIComponent(key)}=${encodeURIComponent(value.value)}`;
+    if (value.metadata !== undefined) {
+      entry += BAGGAGE_PROPERTIES_SEPARATOR + value.metadata.toString();
+    }
+    return entry;
+  });
+}
+function parsePairKeyValue(entry) {
+  if (!entry)
+    return;
+  const metadataSeparatorIndex = entry.indexOf(BAGGAGE_PROPERTIES_SEPARATOR);
+  const keyPairPart = metadataSeparatorIndex === -1 ? entry : entry.substring(0, metadataSeparatorIndex);
+  const separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
+  if (separatorIndex <= 0)
+    return;
+  const rawKey = keyPairPart.substring(0, separatorIndex).trim();
+  const rawValue = keyPairPart.substring(separatorIndex + 1).trim();
+  if (!rawKey || !rawValue)
+    return;
+  let key;
+  let value;
+  try {
+    key = decodeURIComponent(rawKey);
+    value = decodeURIComponent(rawValue);
+  } catch {
+    return;
+  }
+  let metadata;
+  if (metadataSeparatorIndex !== -1 && metadataSeparatorIndex < entry.length - 1) {
+    const metadataString = entry.substring(metadataSeparatorIndex + 1);
+    metadata = import_api2.baggageEntryMetadataFromString(metadataString);
+  }
+  return { key, value, metadata };
+}
+var import_api2;
+var init_utils = __esm(() => {
+  init_constants();
+  import_api2 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js
+class W3CBaggagePropagator {
+  inject(context, carrier, setter) {
+    const baggage = import_api3.propagation.getBaggage(context);
+    if (!baggage || isTracingSuppressed(context))
+      return;
+    const keyPairs = getKeyPairs(baggage).filter((pair) => {
+      return pair.length <= BAGGAGE_MAX_PER_NAME_VALUE_PAIRS;
+    }).slice(0, BAGGAGE_MAX_NAME_VALUE_PAIRS);
+    const headerValue = serializeKeyPairs(keyPairs);
+    if (headerValue.length > 0) {
+      setter.set(carrier, BAGGAGE_HEADER, headerValue);
+    }
+  }
+  extract(context, carrier, getter) {
+    const headerValue = getter.get(carrier, BAGGAGE_HEADER);
+    const baggageString = Array.isArray(headerValue) ? headerValue.join(BAGGAGE_ITEMS_SEPARATOR) : headerValue;
+    if (!baggageString)
+      return context;
+    const baggage = {};
+    if (baggageString.length === 0) {
+      return context;
+    }
+    const pairs = baggageString.split(BAGGAGE_ITEMS_SEPARATOR);
+    pairs.forEach((entry) => {
+      const keyPair = parsePairKeyValue(entry);
+      if (keyPair) {
+        const baggageEntry = { value: keyPair.value };
+        if (keyPair.metadata) {
+          baggageEntry.metadata = keyPair.metadata;
+        }
+        baggage[keyPair.key] = baggageEntry;
+      }
+    });
+    if (Object.entries(baggage).length === 0) {
+      return context;
+    }
+    return import_api3.propagation.setBaggage(context, import_api3.propagation.createBaggage(baggage));
+  }
+  fields() {
+    return [BAGGAGE_HEADER];
+  }
+}
+var import_api3;
+var init_W3CBaggagePropagator = __esm(() => {
+  init_suppress_tracing();
+  init_constants();
+  init_utils();
+  import_api3 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/common/attributes.js
+function sanitizeAttributes(attributes) {
+  const out = {};
+  if (typeof attributes !== "object" || attributes == null) {
+    return out;
+  }
+  for (const key in attributes) {
+    if (!Object.prototype.hasOwnProperty.call(attributes, key)) {
+      continue;
+    }
+    if (!isAttributeKey(key)) {
+      import_api4.diag.warn(`Invalid attribute key: ${key}`);
+      continue;
+    }
+    const val = attributes[key];
+    if (!isAttributeValue(val)) {
+      import_api4.diag.warn(`Invalid attribute value set for key: ${key}`);
+      continue;
+    }
+    if (Array.isArray(val)) {
+      out[key] = val.slice();
+    } else {
+      out[key] = val;
+    }
+  }
+  return out;
+}
+function isAttributeKey(key) {
+  return typeof key === "string" && key !== "";
+}
+function isAttributeValue(val) {
+  if (val == null) {
+    return true;
+  }
+  if (Array.isArray(val)) {
+    return isHomogeneousAttributeValueArray(val);
+  }
+  return isValidPrimitiveAttributeValueType(typeof val);
+}
+function isHomogeneousAttributeValueArray(arr) {
+  let type;
+  for (const element of arr) {
+    if (element == null)
+      continue;
+    const elementType = typeof element;
+    if (elementType === type) {
+      continue;
+    }
+    if (!type) {
+      if (isValidPrimitiveAttributeValueType(elementType)) {
+        type = elementType;
+        continue;
+      }
+      return false;
+    }
+    return false;
+  }
+  return true;
+}
+function isValidPrimitiveAttributeValueType(valType) {
+  switch (valType) {
+    case "number":
+    case "boolean":
+    case "string":
+      return true;
+  }
+  return false;
+}
+var import_api4;
+var init_attributes = __esm(() => {
+  import_api4 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+function loggingErrorHandler() {
+  return (ex) => {
+    import_api5.diag.error(stringifyException(ex));
+  };
+}
+function stringifyException(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException(ex));
+  }
+}
+function flattenException(ex) {
+  const result = {};
+  let current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach((propertyName) => {
+      if (result[propertyName])
+        return;
+      const value = current[propertyName];
+      if (value) {
+        result[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result;
+}
+var import_api5;
+var init_logging_error_handler = __esm(() => {
+  import_api5 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch {}
+}
+var delegateHandler;
+var init_global_error_handler = __esm(() => {
+  init_logging_error_handler();
+  delegateHandler = loggingErrorHandler();
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+import { inspect } from "util";
+function getNumberFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return;
+  }
+  const value = Number(raw);
+  if (isNaN(value)) {
+    import_api6.diag.warn(`Unknown value ${inspect(raw)} for ${key}, expected a number, using defaults`);
+    return;
+  }
+  return value;
+}
+function getStringFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return;
+  }
+  return raw;
+}
+var import_api6;
+var init_environment = __esm(() => {
+  import_api6 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/version.js
+var VERSION = "2.7.0";
+var init_version = () => {};
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/semconv.js
+var ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
+var init_semconv = () => {};
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
+var import_semantic_conventions, SDK_INFO;
+var init_sdk_info = __esm(() => {
+  init_version();
+  init_semconv();
+  import_semantic_conventions = __toESM(require_src2(), 1);
+  SDK_INFO = {
+    [import_semantic_conventions.ATTR_TELEMETRY_SDK_NAME]: "opentelemetry",
+    [ATTR_PROCESS_RUNTIME_NAME]: "node",
+    [import_semantic_conventions.ATTR_TELEMETRY_SDK_LANGUAGE]: import_semantic_conventions.TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+    [import_semantic_conventions.ATTR_TELEMETRY_SDK_VERSION]: VERSION
+  };
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/platform/node/index.js
+var otperformance;
+var init_node = __esm(() => {
+  init_environment();
+  init_sdk_info();
+  otperformance = performance;
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/platform/index.js
+var init_platform2 = __esm(() => {
+  init_node();
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/common/time.js
+function millisToHrTime(epochMillis) {
+  const epochSeconds = epochMillis / 1000;
+  const seconds = Math.trunc(epochSeconds);
+  const nanos = Math.round(epochMillis % 1000 * MILLISECONDS_TO_NANOSECONDS);
+  return [seconds, nanos];
+}
+function hrTime(performanceNow) {
+  const timeOrigin = millisToHrTime(otperformance.timeOrigin);
+  const now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
+  return addHrTimes(timeOrigin, now);
+}
+function hrTimeDuration(startTime, endTime) {
+  let seconds = endTime[0] - startTime[0];
+  let nanos = endTime[1] - startTime[1];
+  if (nanos < 0) {
+    seconds -= 1;
+    nanos += SECOND_TO_NANOSECONDS;
+  }
+  return [seconds, nanos];
+}
+function hrTimeToMilliseconds(time) {
+  return time[0] * 1000 + time[1] / 1e6;
+}
+function hrTimeToMicroseconds(time) {
+  return time[0] * 1e6 + time[1] / 1000;
+}
+function isTimeInputHrTime(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+}
+function isTimeInput(value) {
+  return isTimeInputHrTime(value) || typeof value === "number" || value instanceof Date;
+}
+function addHrTimes(time1, time2) {
+  const out = [time1[0] + time2[0], time1[1] + time2[1]];
+  if (out[1] >= SECOND_TO_NANOSECONDS) {
+    out[1] -= SECOND_TO_NANOSECONDS;
+    out[0] += 1;
+  }
+  return out;
+}
+var NANOSECOND_DIGITS = 9, NANOSECOND_DIGITS_IN_MILLIS = 6, MILLISECONDS_TO_NANOSECONDS, SECOND_TO_NANOSECONDS;
+var init_time = __esm(() => {
+  init_platform2();
+  MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
+  SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+var init_ExportResult = __esm(() => {
+  (function(ExportResultCode2) {
+    ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+    ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+  })(ExportResultCode || (ExportResultCode = {}));
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/internal/validators.js
+function validateKey(key) {
+  return VALID_KEY_REGEX.test(key);
+}
+function validateValue(value) {
+  return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+}
+var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]", VALID_KEY, VALID_VENDOR_KEY, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX;
+var init_validators = __esm(() => {
+  VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+  VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+  VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+  VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+  INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/trace/TraceState.js
+class TraceState {
+  _internalState = new Map;
+  constructor(rawTraceState) {
+    if (rawTraceState)
+      this._parse(rawTraceState);
+  }
+  set(key, value) {
+    const traceState = this._clone();
+    if (traceState._internalState.has(key)) {
+      traceState._internalState.delete(key);
+    }
+    traceState._internalState.set(key, value);
+    return traceState;
+  }
+  unset(key) {
+    const traceState = this._clone();
+    traceState._internalState.delete(key);
+    return traceState;
+  }
+  get(key) {
+    return this._internalState.get(key);
+  }
+  serialize() {
+    return this._keys().reduce((agg, key) => {
+      agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+      return agg;
+    }, []).join(LIST_MEMBERS_SEPARATOR);
+  }
+  _parse(rawTraceState) {
+    if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+      return;
+    this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
+      const listMember = part.trim();
+      const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+      if (i !== -1) {
+        const key = listMember.slice(0, i);
+        const value = listMember.slice(i + 1, part.length);
+        if (validateKey(key) && validateValue(value)) {
+          agg.set(key, value);
+        } else {}
+      }
+      return agg;
+    }, new Map);
+    if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+      this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
+    }
+  }
+  _keys() {
+    return Array.from(this._internalState.keys()).reverse();
+  }
+  _clone() {
+    const traceState = new TraceState;
+    traceState._internalState = new Map(this._internalState);
+    return traceState;
+  }
+}
+var MAX_TRACE_STATE_ITEMS = 32, MAX_TRACE_STATE_LEN = 512, LIST_MEMBERS_SEPARATOR = ",", LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+var init_TraceState = __esm(() => {
+  init_validators();
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/trace/rpc-metadata.js
+function setRPCMetadata(context, meta) {
+  return context.setValue(RPC_METADATA_KEY, meta);
+}
+function getRPCMetadata(context) {
+  return context.getValue(RPC_METADATA_KEY);
+}
+var import_api7, RPC_METADATA_KEY, RPCType;
+var init_rpc_metadata = __esm(() => {
+  import_api7 = __toESM(require_src(), 1);
+  RPC_METADATA_KEY = import_api7.createContextKey("OpenTelemetry SDK Context Key RPC_METADATA");
+  (function(RPCType2) {
+    RPCType2["HTTP"] = "http";
+  })(RPCType || (RPCType = {}));
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js
+function isPlainObject2(value) {
+  if (!isObjectLike(value) || baseGetTag(value) !== objectTag2) {
+    return false;
+  }
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = hasOwnProperty2.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString2.call(Ctor) === objectCtorString2;
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function getRawTag(value) {
+  const isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
+  let unmasked = false;
+  try {
+    value[symToStringTag] = undefined;
+    unmasked = true;
+  } catch {}
+  const result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var objectTag2 = "[object Object]", nullTag = "[object Null]", undefinedTag = "[object Undefined]", funcProto2, funcToString2, objectCtorString2, getPrototypeOf, objectProto2, hasOwnProperty2, symToStringTag, nativeObjectToString;
+var init_lodash_merge = __esm(() => {
+  funcProto2 = Function.prototype;
+  funcToString2 = funcProto2.toString;
+  objectCtorString2 = funcToString2.call(Object);
+  getPrototypeOf = Object.getPrototypeOf;
+  objectProto2 = Object.prototype;
+  hasOwnProperty2 = objectProto2.hasOwnProperty;
+  symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+  nativeObjectToString = objectProto2.toString;
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/utils/merge.js
+function merge(...args) {
+  let result = args.shift();
+  const objects = new WeakMap;
+  while (args.length > 0) {
+    result = mergeTwoObjects(result, args.shift(), 0, objects);
+  }
+  return result;
+}
+function takeValue(value) {
+  if (isArray(value)) {
+    return value.slice();
+  }
+  return value;
+}
+function mergeTwoObjects(one, two, level = 0, objects) {
+  let result;
+  if (level > MAX_LEVEL) {
+    return;
+  }
+  level++;
+  if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) {
+    result = takeValue(two);
+  } else if (isArray(one)) {
+    result = one.slice();
+    if (isArray(two)) {
+      for (let i = 0, j = two.length;i < j; i++) {
+        result.push(takeValue(two[i]));
+      }
+    } else if (isObject(two)) {
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length;i < j; i++) {
+        const key = keys[i];
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+          continue;
+        }
+        result[key] = takeValue(two[key]);
+      }
+    }
+  } else if (isObject(one)) {
+    if (isObject(two)) {
+      if (!shouldMerge(one, two)) {
+        return two;
+      }
+      result = Object.assign({}, one);
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length;i < j; i++) {
+        const key = keys[i];
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+          continue;
+        }
+        const twoValue = two[key];
+        if (isPrimitive(twoValue)) {
+          if (typeof twoValue === "undefined") {
+            delete result[key];
+          } else {
+            result[key] = twoValue;
+          }
+        } else {
+          const obj1 = result[key];
+          const obj2 = twoValue;
+          if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
+            delete result[key];
+          } else {
+            if (isObject(obj1) && isObject(obj2)) {
+              const arr1 = objects.get(obj1) || [];
+              const arr2 = objects.get(obj2) || [];
+              arr1.push({ obj: one, key });
+              arr2.push({ obj: two, key });
+              objects.set(obj1, arr1);
+              objects.set(obj2, arr2);
+            }
+            result[key] = mergeTwoObjects(result[key], twoValue, level, objects);
+          }
+        }
+      }
+    } else {
+      result = two;
+    }
+  }
+  return result;
+}
+function wasObjectReferenced(obj, key, objects) {
+  const arr = objects.get(obj[key]) || [];
+  for (let i = 0, j = arr.length;i < j; i++) {
+    const info = arr[i];
+    if (info.key === key && info.obj === obj) {
+      return true;
+    }
+  }
+  return false;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return !isPrimitive(value) && !isArray(value) && !isFunction(value) && typeof value === "object";
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null;
+}
+function shouldMerge(one, two) {
+  if (!isPlainObject2(one) || !isPlainObject2(two)) {
+    return false;
+  }
+  return true;
+}
+var MAX_LEVEL = 20;
+var init_merge = __esm(() => {
+  init_lodash_merge();
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+class Deferred {
+  _promise;
+  _resolve;
+  _reject;
+  constructor() {
+    this._promise = new Promise((resolve2, reject) => {
+      this._resolve = resolve2;
+      this._reject = reject;
+    });
+  }
+  get promise() {
+    return this._promise;
+  }
+  resolve(val) {
+    this._resolve(val);
+  }
+  reject(err) {
+    this._reject(err);
+  }
+}
+var init_promise = () => {};
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/utils/callback.js
+class BindOnceFuture {
+  _isCalled = false;
+  _deferred = new Deferred;
+  _callback;
+  _that;
+  constructor(callback, that) {
+    this._callback = callback;
+    this._that = that;
+  }
+  get isCalled() {
+    return this._isCalled;
+  }
+  get promise() {
+    return this._deferred.promise;
+  }
+  call(...args) {
+    if (!this._isCalled) {
+      this._isCalled = true;
+      try {
+        Promise.resolve(this._callback.call(this._that, ...args)).then((val) => this._deferred.resolve(val), (err) => this._deferred.reject(err));
+      } catch (err) {
+        this._deferred.reject(err);
+      }
+    }
+    return this._deferred.promise;
+  }
+}
+var init_callback = __esm(() => {
+  init_promise();
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/internal/exporter.js
+function _export(exporter, arg) {
+  return new Promise((resolve2) => {
+    import_api8.context.with(suppressTracing(import_api8.context.active()), () => {
+      exporter.export(arg, resolve2);
+    });
+  });
+}
+var import_api8;
+var init_exporter = __esm(() => {
+  init_suppress_tracing();
+  import_api8 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+core@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/core/build/esm/index.js
+var internal;
+var init_esm2 = __esm(() => {
+  init_W3CBaggagePropagator();
+  init_attributes();
+  init_global_error_handler();
+  init_time();
+  init_ExportResult();
+  init_platform2();
+  init_rpc_metadata();
+  init_suppress_tracing();
+  init_TraceState();
+  init_merge();
+  init_callback();
+  init_exporter();
+  internal = {
+    _export
+  };
+});
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/detectors/EnvDetector.js
+class EnvDetector {
+  _MAX_LENGTH = 255;
+  _COMMA_SEPARATOR = ",";
+  _LABEL_KEY_VALUE_SPLITTER = "=";
+  detect(_config) {
+    const attributes = {};
+    const rawAttributes = getStringFromEnv("OTEL_RESOURCE_ATTRIBUTES");
+    const serviceName = getStringFromEnv("OTEL_SERVICE_NAME");
+    if (rawAttributes) {
+      try {
+        const parsedAttributes = this._parseResourceAttributes(rawAttributes);
+        Object.assign(attributes, parsedAttributes);
+      } catch (e) {
+        import_api9.diag.debug(`EnvDetector failed: ${e instanceof Error ? e.message : e}`);
+      }
+    }
+    if (serviceName) {
+      attributes[import_semantic_conventions2.ATTR_SERVICE_NAME] = serviceName;
+    }
+    return { attributes };
+  }
+  _parseResourceAttributes(rawEnvAttributes) {
+    if (!rawEnvAttributes)
+      return {};
+    const attributes = {};
+    const rawAttributes = rawEnvAttributes.split(this._COMMA_SEPARATOR).filter((attr) => attr.trim() !== "");
+    for (const rawAttribute of rawAttributes) {
+      const keyValuePair = rawAttribute.split(this._LABEL_KEY_VALUE_SPLITTER);
+      if (keyValuePair.length !== 2) {
+        throw new Error(`Invalid format for OTEL_RESOURCE_ATTRIBUTES: "${rawAttribute}". ` + `Expected format: key=value. The ',' and '=' characters must be percent-encoded in keys and values.`);
+      }
+      const [rawKey, rawValue] = keyValuePair;
+      const key = rawKey.trim();
+      const value = rawValue.trim();
+      if (key.length === 0) {
+        throw new Error(`Invalid OTEL_RESOURCE_ATTRIBUTES: empty attribute key in "${rawAttribute}".`);
+      }
+      let decodedKey;
+      let decodedValue;
+      try {
+        decodedKey = decodeURIComponent(key);
+        decodedValue = decodeURIComponent(value);
+      } catch (e) {
+        throw new Error(`Failed to percent-decode OTEL_RESOURCE_ATTRIBUTES entry "${rawAttribute}": ${e instanceof Error ? e.message : e}`);
+      }
+      if (decodedKey.length > this._MAX_LENGTH) {
+        throw new Error(`Attribute key exceeds the maximum length of ${this._MAX_LENGTH} characters: "${decodedKey}".`);
+      }
+      if (decodedValue.length > this._MAX_LENGTH) {
+        throw new Error(`Attribute value exceeds the maximum length of ${this._MAX_LENGTH} characters for key "${decodedKey}".`);
+      }
+      attributes[decodedKey] = decodedValue;
+    }
+    return attributes;
+  }
+}
+var import_api9, import_semantic_conventions2, envDetector;
+var init_EnvDetector = __esm(() => {
+  init_esm2();
+  import_api9 = __toESM(require_src(), 1);
+  import_semantic_conventions2 = __toESM(require_src2(), 1);
+  envDetector = new EnvDetector;
+});
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/semconv.js
+var ATTR_HOST_ARCH = "host.arch", ATTR_HOST_ID = "host.id", ATTR_HOST_NAME = "host.name", ATTR_OS_TYPE = "os.type", ATTR_OS_VERSION = "os.version";
+var init_semconv2 = () => {};
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId.js
+import * as process2 from "process";
+async function getMachineId() {
+  if (!getMachineIdImpl) {
+    switch (process2.platform) {
+      case "darwin":
+        getMachineIdImpl = (await import("./chunk-cga5sq7g.js")).getMachineId;
+        break;
+      case "linux":
+        getMachineIdImpl = (await import("./chunk-t7vqt78m.js")).getMachineId;
+        break;
+      case "freebsd":
+        getMachineIdImpl = (await import("./chunk-q95b9wrd.js")).getMachineId;
+        break;
+      case "win32":
+        getMachineIdImpl = (await import("./chunk-es6y15pn.js")).getMachineId;
+        break;
+      default:
+        getMachineIdImpl = (await import("./chunk-t8sg0wf3.js")).getMachineId;
+        break;
+    }
+  }
+  return getMachineIdImpl();
+}
+var getMachineIdImpl;
+var init_getMachineId = () => {};
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/utils.js
+var normalizeArch = (nodeArchString) => {
+  switch (nodeArchString) {
+    case "arm":
+      return "arm32";
+    case "ppc":
+      return "ppc32";
+    case "x64":
+      return "amd64";
+    default:
+      return nodeArchString;
+  }
+}, normalizeType = (nodePlatform) => {
+  switch (nodePlatform) {
+    case "sunos":
+      return "solaris";
+    case "win32":
+      return "windows";
+    default:
+      return nodePlatform;
+  }
+};
+var init_utils2 = () => {};
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/HostDetector.js
+import { arch, hostname } from "os";
+
+class HostDetector {
+  detect(_config) {
+    const attributes = {
+      [ATTR_HOST_NAME]: hostname(),
+      [ATTR_HOST_ARCH]: normalizeArch(arch()),
+      [ATTR_HOST_ID]: getMachineId()
+    };
+    return { attributes };
+  }
+}
+var hostDetector;
+var init_HostDetector = __esm(() => {
+  init_semconv2();
+  init_getMachineId();
+  init_utils2();
+  hostDetector = new HostDetector;
+});
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/OSDetector.js
+import { platform as platform2, release } from "os";
+
+class OSDetector {
+  detect(_config) {
+    const attributes = {
+      [ATTR_OS_TYPE]: normalizeType(platform2()),
+      [ATTR_OS_VERSION]: release()
+    };
+    return { attributes };
+  }
+}
+var osDetector;
+var init_OSDetector = __esm(() => {
+  init_semconv2();
+  init_utils2();
+  osDetector = new OSDetector;
+});
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/index.js
+var init_node2 = __esm(() => {
+  init_HostDetector();
+  init_OSDetector();
+});
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/detectors/platform/index.js
+var init_platform3 = __esm(() => {
+  init_node2();
+});
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/detectors/index.js
+var init_detectors = __esm(() => {
+  init_EnvDetector();
+  init_platform3();
+});
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/default-service-name.js
+function defaultServiceName() {
+  if (serviceName === undefined) {
+    try {
+      const argv0 = globalThis.process.argv0;
+      serviceName = argv0 ? `unknown_service:${argv0}` : "unknown_service";
+    } catch {
+      serviceName = "unknown_service";
+    }
+  }
+  return serviceName;
+}
+var serviceName;
+var init_default_service_name = () => {};
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/utils.js
+var isPromiseLike = (val) => {
+  return val !== null && typeof val === "object" && typeof val.then === "function";
+};
+var init_utils3 = () => {};
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+class ResourceImpl {
+  _rawAttributes;
+  _asyncAttributesPending = false;
+  _schemaUrl;
+  _memoizedAttributes;
+  static FromAttributeList(attributes, options) {
+    const res = new ResourceImpl({}, options);
+    res._rawAttributes = guardedRawAttributes(attributes);
+    res._asyncAttributesPending = attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
+    return res;
+  }
+  constructor(resource, options) {
+    const attributes = resource.attributes ?? {};
+    this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
+      if (isPromiseLike(v)) {
+        this._asyncAttributesPending = true;
+      }
+      return [k, v];
+    });
+    this._rawAttributes = guardedRawAttributes(this._rawAttributes);
+    this._schemaUrl = validateSchemaUrl(options?.schemaUrl);
+  }
+  get asyncAttributesPending() {
+    return this._asyncAttributesPending;
+  }
+  async waitForAsyncAttributes() {
+    if (!this.asyncAttributesPending) {
+      return;
+    }
+    for (let i = 0;i < this._rawAttributes.length; i++) {
+      const [k, v] = this._rawAttributes[i];
+      this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
+    }
+    this._asyncAttributesPending = false;
+  }
+  get attributes() {
+    if (this.asyncAttributesPending) {
+      import_api10.diag.error("Accessing resource attributes before async attributes settled");
+    }
+    if (this._memoizedAttributes) {
+      return this._memoizedAttributes;
+    }
+    const attrs = {};
+    for (const [k, v] of this._rawAttributes) {
+      if (isPromiseLike(v)) {
+        import_api10.diag.debug(`Unsettled resource attribute ${k} skipped`);
+        continue;
+      }
+      if (v != null) {
+        attrs[k] ??= v;
+      }
+    }
+    if (!this._asyncAttributesPending) {
+      this._memoizedAttributes = attrs;
+    }
+    return attrs;
+  }
+  getRawAttributes() {
+    return this._rawAttributes;
+  }
+  get schemaUrl() {
+    return this._schemaUrl;
+  }
+  merge(resource) {
+    if (resource == null)
+      return this;
+    const mergedSchemaUrl = mergeSchemaUrl(this, resource);
+    const mergedOptions = mergedSchemaUrl ? { schemaUrl: mergedSchemaUrl } : undefined;
+    return ResourceImpl.FromAttributeList([...resource.getRawAttributes(), ...this.getRawAttributes()], mergedOptions);
+  }
+}
+function resourceFromAttributes(attributes, options) {
+  return ResourceImpl.FromAttributeList(Object.entries(attributes), options);
+}
+function defaultResource() {
+  return resourceFromAttributes({
+    [import_semantic_conventions3.ATTR_SERVICE_NAME]: defaultServiceName(),
+    [import_semantic_conventions3.ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO[import_semantic_conventions3.ATTR_TELEMETRY_SDK_LANGUAGE],
+    [import_semantic_conventions3.ATTR_TELEMETRY_SDK_NAME]: SDK_INFO[import_semantic_conventions3.ATTR_TELEMETRY_SDK_NAME],
+    [import_semantic_conventions3.ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO[import_semantic_conventions3.ATTR_TELEMETRY_SDK_VERSION]
+  });
+}
+function guardedRawAttributes(attributes) {
+  return attributes.map(([k, v]) => {
+    if (isPromiseLike(v)) {
+      return [
+        k,
+        v.catch((err) => {
+          import_api10.diag.debug("promise rejection for resource attribute: %s - %s", k, err);
+          return;
+        })
+      ];
+    }
+    return [k, v];
+  });
+}
+function validateSchemaUrl(schemaUrl) {
+  if (typeof schemaUrl === "string" || schemaUrl === undefined) {
+    return schemaUrl;
+  }
+  import_api10.diag.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", schemaUrl);
+  return;
+}
+function mergeSchemaUrl(old, updating) {
+  const oldSchemaUrl = old?.schemaUrl;
+  const updatingSchemaUrl = updating?.schemaUrl;
+  const isOldEmpty = oldSchemaUrl === undefined || oldSchemaUrl === "";
+  const isUpdatingEmpty = updatingSchemaUrl === undefined || updatingSchemaUrl === "";
+  if (isOldEmpty) {
+    return updatingSchemaUrl;
+  }
+  if (isUpdatingEmpty) {
+    return oldSchemaUrl;
+  }
+  if (oldSchemaUrl === updatingSchemaUrl) {
+    return oldSchemaUrl;
+  }
+  import_api10.diag.warn('Schema URL merge conflict: old resource has "%s", updating resource has "%s". Resulting resource will have undefined Schema URL.', oldSchemaUrl, updatingSchemaUrl);
+  return;
+}
+var import_api10, import_semantic_conventions3;
+var init_ResourceImpl = __esm(() => {
+  init_esm2();
+  init_default_service_name();
+  init_utils3();
+  import_api10 = __toESM(require_src(), 1);
+  import_semantic_conventions3 = __toESM(require_src2(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/esm/index.js
+var init_esm3 = __esm(() => {
+  init_detectors();
+  init_ResourceImpl();
+});
+
 // node_modules/.bun/@opentelemetry+api-logs@0.214.0/node_modules/@opentelemetry/api-logs/build/src/types/LogRecord.js
 var require_LogRecord = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -5294,12 +6333,12 @@ class LogRecordImpl {
     return this._droppedAttributesCount;
   }
   constructor(_sharedState, instrumentationScope, logRecord) {
-    const { timestamp, observedTimestamp, eventName, severityNumber, severityText, body, attributes = {}, exception, context } = logRecord;
+    const { timestamp, observedTimestamp, eventName, severityNumber, severityText, body, attributes = {}, exception, context: context2 } = logRecord;
     const now = Date.now();
-    this.hrTime = import_core3.timeInputToHrTime(timestamp ?? now);
-    this.hrTimeObserved = import_core3.timeInputToHrTime(observedTimestamp ?? now);
-    if (context) {
-      const spanContext = api.trace.getSpanContext(context);
+    this.hrTime = import_core5.timeInputToHrTime(timestamp ?? now);
+    this.hrTimeObserved = import_core5.timeInputToHrTime(observedTimestamp ?? now);
+    if (context2) {
+      const spanContext = api.trace.getSpanContext(context2);
       if (spanContext && api.isSpanContextValid(spanContext)) {
         this.spanContext = spanContext;
       }
@@ -5397,32 +6436,32 @@ class LogRecordImpl {
   _setException(exception) {
     let hasMinimumAttributes = false;
     if (typeof exception === "string" || typeof exception === "number") {
-      if (!Object.hasOwn(this.attributes, import_semantic_conventions.ATTR_EXCEPTION_MESSAGE)) {
-        this.setAttribute(import_semantic_conventions.ATTR_EXCEPTION_MESSAGE, String(exception));
+      if (!Object.hasOwn(this.attributes, import_semantic_conventions4.ATTR_EXCEPTION_MESSAGE)) {
+        this.setAttribute(import_semantic_conventions4.ATTR_EXCEPTION_MESSAGE, String(exception));
       }
       hasMinimumAttributes = true;
     } else if (exception && typeof exception === "object") {
       const exceptionObj = exception;
       if (exceptionObj.code) {
-        if (!Object.hasOwn(this.attributes, import_semantic_conventions.ATTR_EXCEPTION_TYPE)) {
-          this.setAttribute(import_semantic_conventions.ATTR_EXCEPTION_TYPE, exceptionObj.code.toString());
+        if (!Object.hasOwn(this.attributes, import_semantic_conventions4.ATTR_EXCEPTION_TYPE)) {
+          this.setAttribute(import_semantic_conventions4.ATTR_EXCEPTION_TYPE, exceptionObj.code.toString());
         }
         hasMinimumAttributes = true;
       } else if (exceptionObj.name) {
-        if (!Object.hasOwn(this.attributes, import_semantic_conventions.ATTR_EXCEPTION_TYPE)) {
-          this.setAttribute(import_semantic_conventions.ATTR_EXCEPTION_TYPE, exceptionObj.name);
+        if (!Object.hasOwn(this.attributes, import_semantic_conventions4.ATTR_EXCEPTION_TYPE)) {
+          this.setAttribute(import_semantic_conventions4.ATTR_EXCEPTION_TYPE, exceptionObj.name);
         }
         hasMinimumAttributes = true;
       }
       if (exceptionObj.message) {
-        if (!Object.hasOwn(this.attributes, import_semantic_conventions.ATTR_EXCEPTION_MESSAGE)) {
-          this.setAttribute(import_semantic_conventions.ATTR_EXCEPTION_MESSAGE, exceptionObj.message);
+        if (!Object.hasOwn(this.attributes, import_semantic_conventions4.ATTR_EXCEPTION_MESSAGE)) {
+          this.setAttribute(import_semantic_conventions4.ATTR_EXCEPTION_MESSAGE, exceptionObj.message);
         }
         hasMinimumAttributes = true;
       }
       if (exceptionObj.stack) {
-        if (!Object.hasOwn(this.attributes, import_semantic_conventions.ATTR_EXCEPTION_STACKTRACE)) {
-          this.setAttribute(import_semantic_conventions.ATTR_EXCEPTION_STACKTRACE, exceptionObj.stack);
+        if (!Object.hasOwn(this.attributes, import_semantic_conventions4.ATTR_EXCEPTION_STACKTRACE)) {
+          this.setAttribute(import_semantic_conventions4.ATTR_EXCEPTION_STACKTRACE, exceptionObj.stack);
         }
         hasMinimumAttributes = true;
       }
@@ -5444,12 +6483,12 @@ class LogRecordImpl {
     return this._isReadonly;
   }
 }
-var api, import_core3, import_semantic_conventions;
+var api, import_core5, import_semantic_conventions4;
 var init_LogRecordImpl = __esm(() => {
   init_validation();
   api = __toESM(require_src(), 1);
-  import_core3 = __toESM(require_src3(), 1);
-  import_semantic_conventions = __toESM(require_src2(), 1);
+  import_core5 = __toESM(require_src3(), 1);
+  import_semantic_conventions4 = __toESM(require_src2(), 1);
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/Logger.js
@@ -5464,15 +6503,15 @@ class Logger {
   }
   emit(logRecord) {
     const loggerConfig = this._loggerConfig;
-    const currentContext = logRecord.context || import_api.context.active();
+    const currentContext = logRecord.context || import_api11.context.active();
     const recordSeverity = logRecord.severityNumber ?? import_api_logs.SeverityNumber.UNSPECIFIED;
     if (recordSeverity !== import_api_logs.SeverityNumber.UNSPECIFIED && recordSeverity < loggerConfig.minimumSeverity) {
       return;
     }
     if (loggerConfig.traceBased) {
-      const spanContext = import_api.trace.getSpanContext(currentContext);
-      if (spanContext && import_api.isSpanContextValid(spanContext)) {
-        const isSampled = (spanContext.traceFlags & import_api.TraceFlags.SAMPLED) === import_api.TraceFlags.SAMPLED;
+      const spanContext = import_api11.trace.getSpanContext(currentContext);
+      if (spanContext && import_api11.isSpanContextValid(spanContext)) {
+        const isSampled = (spanContext.traceFlags & import_api11.TraceFlags.SAMPLED) === import_api11.TraceFlags.SAMPLED;
         if (!isSampled) {
           return;
         }
@@ -5486,11 +6525,11 @@ class Logger {
     logRecordInstance._makeReadonly();
   }
 }
-var import_api_logs, import_api;
+var import_api_logs, import_api11;
 var init_Logger = __esm(() => {
   init_LogRecordImpl();
   import_api_logs = __toESM(require_src5(), 1);
-  import_api = __toESM(require_src(), 1);
+  import_api11 = __toESM(require_src(), 1);
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/export/NoopLogRecordProcessor.js
@@ -5515,25 +6554,25 @@ class MultiLogRecordProcessor {
   }
   async forceFlush() {
     const timeout = this.forceFlushTimeoutMillis;
-    await Promise.all(this.processors.map((processor) => import_core4.callWithTimeout(processor.forceFlush(), timeout)));
+    await Promise.all(this.processors.map((processor) => import_core6.callWithTimeout(processor.forceFlush(), timeout)));
   }
-  onEmit(logRecord, context2) {
-    this.processors.forEach((processors) => processors.onEmit(logRecord, context2));
+  onEmit(logRecord, context3) {
+    this.processors.forEach((processors) => processors.onEmit(logRecord, context3));
   }
   async shutdown() {
     await Promise.all(this.processors.map((processor) => processor.shutdown()));
   }
 }
-var import_core4;
+var import_core6;
 var init_MultiLogRecordProcessor = __esm(() => {
-  import_core4 = __toESM(require_src3(), 1);
+  import_core6 = __toESM(require_src3(), 1);
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/internal/utils.js
 function getInstrumentationScopeKey(scope) {
   return `${scope.name}@${scope.version || ""}:${scope.schemaUrl || ""}`;
 }
-var init_utils = () => {};
+var init_utils4 = () => {};
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/internal/LoggerProviderSharedState.js
 class LoggerProviderSharedState {
@@ -5576,7 +6615,7 @@ var import_api_logs2, DEFAULT_LOGGER_CONFIG, DEFAULT_LOGGER_CONFIGURATOR = () =>
 var init_LoggerProviderSharedState = __esm(() => {
   init_NoopLogRecordProcessor();
   init_MultiLogRecordProcessor();
-  init_utils();
+  init_utils4();
   import_api_logs2 = __toESM(require_src5(), 1);
   DEFAULT_LOGGER_CONFIG = {
     disabled: false,
@@ -5601,15 +6640,15 @@ class LoggerProvider {
       processors: config.processors ?? []
     };
     this._sharedState = new LoggerProviderSharedState(mergedConfig.resource, mergedConfig.forceFlushTimeoutMillis, mergedConfig.logRecordLimits, mergedConfig.processors, mergedConfig.loggerConfigurator);
-    this._shutdownOnce = new import_core5.BindOnceFuture(this._shutdown, this);
+    this._shutdownOnce = new import_core7.BindOnceFuture(this._shutdown, this);
   }
   getLogger(name, version, options) {
     if (this._shutdownOnce.isCalled) {
-      import_api2.diag.warn("A shutdown LoggerProvider cannot provide a Logger");
+      import_api12.diag.warn("A shutdown LoggerProvider cannot provide a Logger");
       return import_api_logs3.NOOP_LOGGER;
     }
     if (!name) {
-      import_api2.diag.warn("Logger requested without instrumentation scope name.");
+      import_api12.diag.warn("Logger requested without instrumentation scope name.");
     }
     const loggerName = name || DEFAULT_LOGGER_NAME;
     const key = `${loggerName}@${version || ""}:${options?.schemaUrl || ""}`;
@@ -5620,14 +6659,14 @@ class LoggerProvider {
   }
   forceFlush() {
     if (this._shutdownOnce.isCalled) {
-      import_api2.diag.warn("invalid attempt to force flush after LoggerProvider shutdown");
+      import_api12.diag.warn("invalid attempt to force flush after LoggerProvider shutdown");
       return this._shutdownOnce.promise;
     }
     return this._sharedState.activeProcessor.forceFlush();
   }
   shutdown() {
     if (this._shutdownOnce.isCalled) {
-      import_api2.diag.warn("shutdown may only be called once per LoggerProvider");
+      import_api12.diag.warn("shutdown may only be called once per LoggerProvider");
       return this._shutdownOnce.promise;
     }
     return this._shutdownOnce.call();
@@ -5636,14 +6675,14 @@ class LoggerProvider {
     return this._sharedState.activeProcessor.shutdown();
   }
 }
-var import_api2, import_api_logs3, import_resources, import_core5, DEFAULT_LOGGER_NAME = "unknown";
+var import_api12, import_api_logs3, import_resources, import_core7, DEFAULT_LOGGER_NAME = "unknown";
 var init_LoggerProvider = __esm(() => {
   init_Logger();
   init_LoggerProviderSharedState();
-  import_api2 = __toESM(require_src(), 1);
+  import_api12 = __toESM(require_src(), 1);
   import_api_logs3 = __toESM(require_src5(), 1);
   import_resources = __toESM(require_src4(), 1);
-  import_core5 = __toESM(require_src3(), 1);
+  import_core7 = __toESM(require_src3(), 1);
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/export/ConsoleLogRecordExporter.js
@@ -5660,7 +6699,7 @@ class ConsoleLogRecordExporter {
         attributes: logRecord.resource.attributes
       },
       instrumentationScope: logRecord.instrumentationScope,
-      timestamp: import_core6.hrTimeToMicroseconds(logRecord.hrTime),
+      timestamp: import_core8.hrTimeToMicroseconds(logRecord.hrTime),
       traceId: logRecord.spanContext?.traceId,
       spanId: logRecord.spanContext?.spanId,
       traceFlags: logRecord.spanContext?.traceFlags,
@@ -5675,12 +6714,12 @@ class ConsoleLogRecordExporter {
     for (const logRecord of logRecords) {
       console.dir(this._exportInfo(logRecord), { depth: 3 });
     }
-    done?.({ code: import_core6.ExportResultCode.SUCCESS });
+    done?.({ code: import_core8.ExportResultCode.SUCCESS });
   }
 }
-var import_core6;
+var import_core8;
 var init_ConsoleLogRecordExporter = __esm(() => {
-  import_core6 = __toESM(require_src3(), 1);
+  import_core8 = __toESM(require_src3(), 1);
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/export/BatchLogRecordProcessorBase.js
@@ -5700,9 +6739,9 @@ class BatchLogRecordProcessorBase {
     this._maxQueueSize = config?.maxQueueSize ?? 2048;
     this._scheduledDelayMillis = config?.scheduledDelayMillis ?? 5000;
     this._exportTimeoutMillis = config?.exportTimeoutMillis ?? 30000;
-    this._shutdownOnce = new import_core7.BindOnceFuture(this._shutdown, this);
+    this._shutdownOnce = new import_core9.BindOnceFuture(this._shutdown, this);
     if (this._maxExportBatchSize > this._maxQueueSize) {
-      import_api3.diag.warn("BatchLogRecordProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
+      import_api13.diag.warn("BatchLogRecordProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
       this._maxExportBatchSize = this._maxQueueSize;
     }
   }
@@ -5750,7 +6789,7 @@ class BatchLogRecordProcessorBase {
     if (this._finishedLogRecords.length === 0) {
       return Promise.resolve();
     }
-    return import_core7.callWithTimeout(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis);
+    return import_core9.callWithTimeout(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis);
   }
   _maybeStartTimer() {
     if (this._isExporting)
@@ -5765,7 +6804,7 @@ class BatchLogRecordProcessorBase {
         }
       }).catch((e) => {
         this._isExporting = false;
-        import_core7.globalErrorHandler(e);
+        import_core9.globalErrorHandler(e);
       });
     };
     if (this._finishedLogRecords.length >= this._maxExportBatchSize) {
@@ -5785,11 +6824,11 @@ class BatchLogRecordProcessorBase {
     }
   }
   _export(logRecords) {
-    const doExport = () => import_core7.internal._export(this._exporter, logRecords).then((result) => {
-      if (result.code !== import_core7.ExportResultCode.SUCCESS) {
-        import_core7.globalErrorHandler(result.error ?? new Error(`BatchLogRecordProcessor: log record export failed (status ${result})`));
+    const doExport = () => import_core9.internal._export(this._exporter, logRecords).then((result) => {
+      if (result.code !== import_core9.ExportResultCode.SUCCESS) {
+        import_core9.globalErrorHandler(result.error ?? new Error(`BatchLogRecordProcessor: log record export failed (status ${result})`));
       }
-    }).catch(import_core7.globalErrorHandler);
+    }).catch(import_core9.globalErrorHandler);
     const pendingResources = [];
     for (let i = 0;i < logRecords.length; i++) {
       const resource = logRecords[i].resource;
@@ -5800,14 +6839,14 @@ class BatchLogRecordProcessorBase {
     if (pendingResources.length === 0) {
       return doExport();
     } else {
-      return Promise.all(pendingResources).then(doExport, import_core7.globalErrorHandler);
+      return Promise.all(pendingResources).then(doExport, import_core9.globalErrorHandler);
     }
   }
 }
-var import_api3, import_core7;
+var import_api13, import_core9;
 var init_BatchLogRecordProcessorBase = __esm(() => {
-  import_api3 = __toESM(require_src(), 1);
-  import_core7 = __toESM(require_src3(), 1);
+  import_api13 = __toESM(require_src(), 1);
+  import_core9 = __toESM(require_src3(), 1);
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/platform/node/export/BatchLogRecordProcessor.js
@@ -5820,20 +6859,20 @@ var init_BatchLogRecordProcessor = __esm(() => {
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/platform/node/index.js
-var init_node = __esm(() => {
+var init_node3 = __esm(() => {
   init_BatchLogRecordProcessor();
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/platform/index.js
-var init_platform2 = __esm(() => {
-  init_node();
+var init_platform4 = __esm(() => {
+  init_node3();
 });
 
 // node_modules/.bun/@opentelemetry+sdk-logs@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-logs/build/esm/index.js
-var init_esm2 = __esm(() => {
+var init_esm4 = __esm(() => {
   init_LoggerProvider();
   init_ConsoleLogRecordExporter();
-  init_platform2();
+  init_platform4();
 });
 
 // src/services/analytics/config.ts
@@ -8006,7 +9045,7 @@ async function getAnthropicClient({
     }
   };
   if (isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)) {
-    const { AnthropicBedrock } = await import("./chunk-c358prbg.js");
+    const { AnthropicBedrock } = await import("./chunk-b0yyp8et.js");
     const awsRegion = model === getSmallFastModel() && process.env.ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION ? process.env.ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION : getAWSRegion();
     const bedrockArgs = {
       ...ARGS,
@@ -8042,7 +9081,7 @@ async function getAnthropicClient({
         const {
           DefaultAzureCredential: AzureCredential,
           getBearerTokenProvider
-        } = await import("./chunk-y3jmpqat.js");
+        } = await import("./chunk-5vdpbk46.js");
         azureADTokenProvider = getBearerTokenProvider(new AzureCredential, "https://cognitiveservices.azure.com/.default");
       }
     }
@@ -8058,7 +9097,7 @@ async function getAnthropicClient({
       await refreshGcpCredentialsIfNeeded();
     }
     const [{ AnthropicVertex }, { GoogleAuth }] = await Promise.all([
-      import("./chunk-0fnpkgd6.js"),
+      import("./chunk-ybebarb1.js"),
       import("./chunk-tezak8rx.js").then((m)=>__toESM(m.default,1))
     ]);
     const hasProjectEnvVar = process.env["GCLOUD_PROJECT"] || process.env["GOOGLE_CLOUD_PROJECT"] || process.env["gcloud_project"] || process.env["google_cloud_project"];
@@ -8672,28 +9711,28 @@ import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 function getAgentContext() {
   return agentContextStorage.getStore();
 }
-function runWithAgentContext(context2, fn) {
-  return agentContextStorage.run(context2, fn);
+function runWithAgentContext(context3, fn) {
+  return agentContextStorage.run(context3, fn);
 }
-function isSubagentContext(context2) {
-  return context2?.agentType === "subagent";
+function isSubagentContext(context3) {
+  return context3?.agentType === "subagent";
 }
 function getSubagentLogName() {
-  const context2 = getAgentContext();
-  if (!isSubagentContext(context2) || !context2.subagentName) {
+  const context3 = getAgentContext();
+  if (!isSubagentContext(context3) || !context3.subagentName) {
     return;
   }
-  return context2.isBuiltIn ? context2.subagentName : "user-defined";
+  return context3.isBuiltIn ? context3.subagentName : "user-defined";
 }
 function consumeInvokingRequestId() {
-  const context2 = getAgentContext();
-  if (!context2?.invokingRequestId || context2.invocationEmitted) {
+  const context3 = getAgentContext();
+  if (!context3?.invokingRequestId || context3.invocationEmitted) {
     return;
   }
-  context2.invocationEmitted = true;
+  context3.invocationEmitted = true;
   return {
-    invokingRequestId: context2.invokingRequestId,
-    invocationKind: context2.invocationKind
+    invokingRequestId: context3.invokingRequestId,
+    invocationKind: context3.invocationKind
   };
 }
 var agentContextStorage;
@@ -9179,7 +10218,7 @@ var init_metadata = __esm(() => {
       isClaudeAiAuth: isClaudeAISubscriber(),
       version: "2.1.888",
       versionBase: getVersionBase(),
-      buildTime: "2026-04-19T00:32:56.089Z",
+      buildTime: "2026-04-19T04:33:30.431Z",
       deploymentEnvironment: env.detectDeploymentEnvironment(),
       ...isEnvTruthy(process.env.GITHUB_ACTIONS) && {
         githubEventName: process.env.GITHUB_EVENT_NAME,
@@ -9338,7 +10377,7 @@ class FirstPartyEventLoggingExporter {
         logForDebugging("1P event logging export failed: Exporter has been shutdown");
       }
       resultCallback({
-        code: import_core8.ExportResultCode.FAILED,
+        code: ExportResultCode.FAILED,
         error: new Error("Exporter has been shutdown")
       });
       return;
@@ -9356,17 +10395,17 @@ class FirstPartyEventLoggingExporter {
     try {
       const eventLogs = logs.filter((log) => log.instrumentationScope?.name === "com.anthropic.claude_code.events");
       if (eventLogs.length === 0) {
-        resultCallback({ code: import_core8.ExportResultCode.SUCCESS });
+        resultCallback({ code: ExportResultCode.SUCCESS });
         return;
       }
       const events = this.transformLogsToEvents(eventLogs).events;
       if (events.length === 0) {
-        resultCallback({ code: import_core8.ExportResultCode.SUCCESS });
+        resultCallback({ code: ExportResultCode.SUCCESS });
         return;
       }
       if (this.attempts >= this.maxAttempts) {
         resultCallback({
-          code: import_core8.ExportResultCode.FAILED,
+          code: ExportResultCode.FAILED,
           error: new Error(`Dropped ${events.length} events: max attempts (${this.maxAttempts}) reached`)
         });
         return;
@@ -9376,10 +10415,10 @@ class FirstPartyEventLoggingExporter {
       if (failedEvents.length > 0) {
         await this.queueFailedEvents(failedEvents);
         this.scheduleBackoffRetry();
-        const context2 = this.lastExportErrorContext ? ` (${this.lastExportErrorContext})` : "";
+        const context3 = this.lastExportErrorContext ? ` (${this.lastExportErrorContext})` : "";
         resultCallback({
-          code: import_core8.ExportResultCode.FAILED,
-          error: new Error(`Failed to export ${failedEvents.length} events${context2}`)
+          code: ExportResultCode.FAILED,
+          error: new Error(`Failed to export ${failedEvents.length} events${context3}`)
         });
         return;
       }
@@ -9387,14 +10426,14 @@ class FirstPartyEventLoggingExporter {
       if (await this.getQueuedEventCount() > 0 && !this.isRetrying) {
         this.retryFailedEvents();
       }
-      resultCallback({ code: import_core8.ExportResultCode.SUCCESS });
+      resultCallback({ code: ExportResultCode.SUCCESS });
     } catch (error) {
       if (process.env.USER_TYPE === "ant") {
         logForDebugging(`1P event logging export failed: ${errorMessage(error)}`);
       }
       logError(error);
       resultCallback({
-        code: import_core8.ExportResultCode.FAILED,
+        code: ExportResultCode.FAILED,
         error: toError(error)
       });
     }
@@ -9436,8 +10475,8 @@ class FirstPartyEventLoggingExporter {
   async queueFailedEvents(events) {
     const filePath = this.getCurrentBatchFilePath();
     await this.appendEventsToFile(filePath, events);
-    const context2 = this.lastExportErrorContext ? ` (${this.lastExportErrorContext})` : "";
-    const message = `1P event logging: ${events.length} events failed to export${context2}`;
+    const context3 = this.lastExportErrorContext ? ` (${this.lastExportErrorContext})` : "";
+    const message = `1P event logging: ${events.length} events failed to export${context3}`;
     logError(new Error(message));
   }
   scheduleBackoffRetry() {
@@ -9552,8 +10591,8 @@ class FirstPartyEventLoggingExporter {
       logForDebugging(`API Response: ${jsonStringify(responseData, null, 2)}`);
     }
   }
-  hrTimeToDate(hrTime) {
-    const [seconds, nanoseconds] = hrTime;
+  hrTimeToDate(hrTime2) {
+    const [seconds, nanoseconds] = hrTime2;
     return new Date(seconds * 1000 + nanoseconds / 1e6);
   }
   transformLogsToEvents(logs) {
@@ -9667,8 +10706,9 @@ function getAxiosErrorContext(error) {
   }
   return parts.join(", ");
 }
-var import_core8, BATCH_UUID, FILE_PREFIX = "1p_failed_events.";
+var BATCH_UUID, FILE_PREFIX = "1p_failed_events.";
 var init_firstPartyEventLoggingExporter = __esm(() => {
+  init_esm2();
   init_axios();
   init_state();
   init_claude_code_internal_event();
@@ -9687,7 +10727,6 @@ var init_firstPartyEventLoggingExporter = __esm(() => {
   init_client2();
   init_analytics();
   init_metadata();
-  import_core8 = __toESM(require_src3(), 1);
   BATCH_UUID = randomUUID2();
 });
 
@@ -9835,18 +10874,18 @@ function initialize1PEventLogging() {
   const scheduledDelayMillis = batchConfig.scheduledDelayMillis || parseInt(process.env.OTEL_LOGS_EXPORT_INTERVAL || DEFAULT_LOGS_EXPORT_INTERVAL_MS.toString());
   const maxExportBatchSize = batchConfig.maxExportBatchSize || DEFAULT_MAX_EXPORT_BATCH_SIZE;
   const maxQueueSize = batchConfig.maxQueueSize || DEFAULT_MAX_QUEUE_SIZE;
-  const platform = getPlatform();
+  const platform3 = getPlatform();
   const attributes = {
-    [import_semantic_conventions2.ATTR_SERVICE_NAME]: "claude-code",
-    [import_semantic_conventions2.ATTR_SERVICE_VERSION]: "2.1.888"
+    [import_semantic_conventions5.ATTR_SERVICE_NAME]: "claude-code",
+    [import_semantic_conventions5.ATTR_SERVICE_VERSION]: "2.1.888"
   };
-  if (platform === "wsl") {
+  if (platform3 === "wsl") {
     const wslVersion = getWslVersion();
     if (wslVersion) {
       attributes["wsl.version"] = wslVersion;
     }
   }
-  const resource = import_resources2.resourceFromAttributes(attributes);
+  const resource = resourceFromAttributes(attributes);
   const eventLoggingExporter = new FirstPartyEventLoggingExporter({
     maxBatchSize: maxExportBatchSize,
     skipAuth: batchConfig.skipAuth,
@@ -9895,9 +10934,10 @@ async function reinitialize1PEventLoggingIfConfigChanged() {
   }
   oldProvider.shutdown().catch(() => {});
 }
-var import_resources2, import_semantic_conventions2, EVENT_SAMPLING_CONFIG_NAME = "tengu_event_sampling_config", BATCH_CONFIG_NAME = "tengu_1p_event_batch_config", firstPartyEventLogger = null, firstPartyEventLoggerProvider = null, lastBatchConfig = null, DEFAULT_LOGS_EXPORT_INTERVAL_MS = 1e4, DEFAULT_MAX_EXPORT_BATCH_SIZE = 200, DEFAULT_MAX_QUEUE_SIZE = 8192;
+var import_semantic_conventions5, EVENT_SAMPLING_CONFIG_NAME = "tengu_event_sampling_config", BATCH_CONFIG_NAME = "tengu_1p_event_batch_config", firstPartyEventLogger = null, firstPartyEventLoggerProvider = null, lastBatchConfig = null, DEFAULT_LOGS_EXPORT_INTERVAL_MS = 1e4, DEFAULT_MAX_EXPORT_BATCH_SIZE = 200, DEFAULT_MAX_QUEUE_SIZE = 8192;
 var init_firstPartyEventLogger = __esm(() => {
-  init_esm2();
+  init_esm3();
+  init_esm4();
   init_lodash();
   init_config();
   init_debug();
@@ -9911,8 +10951,7 @@ var init_firstPartyEventLogger = __esm(() => {
   init_growthbook();
   init_metadata();
   init_sinkKillswitch();
-  import_resources2 = __toESM(require_src4(), 1);
-  import_semantic_conventions2 = __toESM(require_src2(), 1);
+  import_semantic_conventions5 = __toESM(require_src2(), 1);
 });
 
 // src/services/analytics/growthbook.ts
@@ -10865,12 +11904,12 @@ function writeFileSyncAndFlush_DEPRECATED(filePath, content, options = { encodin
   }
 }
 function getDesktopPath() {
-  const platform = getPlatform();
+  const platform3 = getPlatform();
   const homeDir = homedir2();
-  if (platform === "macos") {
+  if (platform3 === "macos") {
     return join7(homeDir, "Desktop");
   }
-  if (platform === "windows") {
+  if (platform3 === "windows") {
     const windowsHome = process.env.USERPROFILE ? process.env.USERPROFILE.replace(/\\/g, "/") : null;
     if (windowsHome) {
       const wslPath = windowsHome.replace(/^[A-Z]:/, "");
@@ -11099,7 +12138,7 @@ function isSettingSourceEnabled(source) {
   return enabled.includes(source);
 }
 var SETTING_SOURCES, SOURCES, CLAUDE_CODE_SETTINGS_SCHEMA_URL = "https://json.schemastore.org/claude-code-settings.json";
-var init_constants = __esm(() => {
+var init_constants2 = __esm(() => {
   init_state();
   SETTING_SOURCES = [
     "userSettings",
@@ -11828,7 +12867,7 @@ var init_mcpStringUtils = __esm(() => {
 
 // packages/builtin-tools/src/tools/AgentTool/constants.ts
 var AGENT_TOOL_NAME = "Agent", LEGACY_AGENT_TOOL_NAME = "Task", VERIFICATION_AGENT_TYPE = "verification", ONE_SHOT_BUILTIN_AGENT_TYPES;
-var init_constants2 = __esm(() => {
+var init_constants3 = __esm(() => {
   ONE_SHOT_BUILTIN_AGENT_TYPES = new Set([
     "Explore",
     "Plan"
@@ -11837,7 +12876,7 @@ var init_constants2 = __esm(() => {
 
 // packages/builtin-tools/src/tools/TaskOutputTool/constants.ts
 var TASK_OUTPUT_TOOL_NAME = "TaskOutput";
-var init_constants3 = () => {};
+var init_constants4 = () => {};
 
 // packages/builtin-tools/src/tools/TaskStopTool/prompt.ts
 var TASK_STOP_TOOL_NAME = "TaskStop", DESCRIPTION = `
@@ -11958,8 +12997,8 @@ function findLastUnescapedChar(str, char) {
 }
 var BRIEF_TOOL_NAME2, LEGACY_TOOL_NAME_ALIASES;
 var init_permissionRuleParser = __esm(() => {
-  init_constants2();
   init_constants3();
+  init_constants4();
   init_prompt();
   BRIEF_TOOL_NAME2 = (init_prompt2(), __toCommonJS(exports_prompt)).BRIEF_TOOL_NAME;
   LEGACY_TOOL_NAME_ALIASES = {
@@ -12222,7 +13261,7 @@ var init_types2 = __esm(() => {
   init_lazySchema();
   init_PermissionMode();
   init_schemas();
-  init_constants();
+  init_constants2();
   init_permissionValidation();
   init_hooks();
   init_hooks();
@@ -12465,16 +13504,16 @@ var init_schemaOutput = __esm(() => {
 });
 
 // src/utils/settings/validationTips.ts
-function getValidationTip(context2) {
-  const matcher = TIP_MATCHERS.find((m) => m.matches(context2));
+function getValidationTip(context3) {
+  const matcher = TIP_MATCHERS.find((m) => m.matches(context3));
   if (!matcher)
     return null;
   const tip = { ...matcher.tip };
-  if (context2.code === "invalid_value" && context2.enumValues && !tip.suggestion) {
-    tip.suggestion = `Valid values: ${context2.enumValues.map((v) => `"${v}"`).join(", ")}`;
+  if (context3.code === "invalid_value" && context3.enumValues && !tip.suggestion) {
+    tip.suggestion = `Valid values: ${context3.enumValues.map((v) => `"${v}"`).join(", ")}`;
   }
-  if (!tip.docLink && context2.path) {
-    const pathPrefix = context2.path.split(".")[0];
+  if (!tip.docLink && context3.path) {
+    const pathPrefix = context3.path.split(".")[0];
     if (pathPrefix) {
       tip.docLink = PATH_DOC_LINKS[pathPrefix];
     }
@@ -12754,7 +13793,7 @@ function getMacOSPlistPaths() {
   return paths;
 }
 var MACOS_PREFERENCE_DOMAIN = "com.anthropic.claudecode", WINDOWS_REGISTRY_KEY_PATH_HKLM = "HKLM\\SOFTWARE\\Policies\\ClaudeCode", WINDOWS_REGISTRY_KEY_PATH_HKCU = "HKCU\\SOFTWARE\\Policies\\ClaudeCode", WINDOWS_REGISTRY_VALUE_NAME = "Settings", PLUTIL_PATH = "/usr/bin/plutil", PLUTIL_ARGS_PREFIX, MDM_SUBPROCESS_TIMEOUT_MS = 5000;
-var init_constants4 = __esm(() => {
+var init_constants5 = __esm(() => {
   PLUTIL_ARGS_PREFIX = ["-convert", "json", "-o", "-", "--"];
 });
 
@@ -12823,7 +13862,7 @@ function getMdmRawReadPromise() {
 }
 var rawReadPromise = null;
 var init_rawRead = __esm(() => {
-  init_constants4();
+  init_constants5();
 });
 
 // src/utils/settings/mdm/settings.ts
@@ -12965,7 +14004,7 @@ var init_settings = __esm(() => {
   init_managedPath();
   init_types2();
   init_validation2();
-  init_constants4();
+  init_constants5();
   init_rawRead();
   EMPTY_RESULT = Object.freeze({ settings: {}, errors: [] });
 });
@@ -13522,7 +14561,7 @@ var init_settings2 = __esm(() => {
   init_platform();
   init_slowOperations();
   init_startupProfiler();
-  init_constants();
+  init_constants2();
   init_internalWrites();
   init_managedPath();
   init_settings();
@@ -13537,7 +14576,7 @@ function findFirstMatch(profiles, substring) {
   return profiles.find((p) => p.includes(substring)) ?? null;
 }
 async function createBedrockClient() {
-  const { BedrockClient } = await import("./chunk-wjhhetv4.js");
+  const { BedrockClient } = await import("./chunk-32vdb088.js");
   const region = getAWSRegion();
   const skipAuth = isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH);
   const clientConfig = {
@@ -13547,12 +14586,12 @@ async function createBedrockClient() {
     },
     ...await getAWSClientProxyConfig(),
     ...skipAuth && {
-      requestHandler: new (await import("./chunk-0mf8c3kx.js")).NodeHttpHandler,
+      requestHandler: new (await import("./chunk-4drj3c7m.js")).NodeHttpHandler,
       httpAuthSchemes: [
         {
           schemeId: "smithy.api#noAuth",
           identityProvider: () => async () => ({}),
-          signer: new (await import("./chunk-6c5zyga7.js")).NoAuthSigner
+          signer: new (await import("./chunk-0s7za42b.js")).NoAuthSigner
         }
       ],
       httpAuthSchemeProvider: () => [{ schemeId: "smithy.api#noAuth" }]
@@ -13571,7 +14610,7 @@ async function createBedrockClient() {
   return new BedrockClient(clientConfig);
 }
 async function createBedrockRuntimeClient() {
-  const { BedrockRuntimeClient } = await import("./chunk-k97ze3a8.js");
+  const { BedrockRuntimeClient } = await import("./chunk-jvwa5w8w.js");
   const region = getAWSRegion();
   const skipAuth = isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH);
   const clientConfig = {
@@ -13581,12 +14620,12 @@ async function createBedrockRuntimeClient() {
     },
     ...await getAWSClientProxyConfig(),
     ...skipAuth && {
-      requestHandler: new (await import("./chunk-0mf8c3kx.js")).NodeHttpHandler,
+      requestHandler: new (await import("./chunk-4drj3c7m.js")).NodeHttpHandler,
       httpAuthSchemes: [
         {
           schemeId: "smithy.api#noAuth",
           identityProvider: () => async () => ({}),
-          signer: new (await import("./chunk-6c5zyga7.js")).NoAuthSigner
+          signer: new (await import("./chunk-0s7za42b.js")).NoAuthSigner
         }
       ],
       httpAuthSchemeProvider: () => [{ schemeId: "smithy.api#noAuth" }]
@@ -13646,7 +14685,7 @@ var init_bedrock = __esm(() => {
   getBedrockInferenceProfiles = memoize_default(async function() {
     const [client2, { ListInferenceProfilesCommand }] = await Promise.all([
       createBedrockClient(),
-      import("./chunk-wjhhetv4.js")
+      import("./chunk-32vdb088.js")
     ]);
     const allProfiles = [];
     let nextToken;
@@ -13672,7 +14711,7 @@ var init_bedrock = __esm(() => {
     try {
       const [client2, { GetInferenceProfileCommand }] = await Promise.all([
         createBedrockClient(),
-        import("./chunk-wjhhetv4.js")
+        import("./chunk-32vdb088.js")
       ]);
       const command = new GetInferenceProfileCommand({
         inferenceProfileIdentifier: profileId
@@ -14170,13 +15209,13 @@ function isValidAwsStsOutput(obj) {
   return typeof credentials.AccessKeyId === "string" && typeof credentials.SecretAccessKey === "string" && typeof credentials.SessionToken === "string" && credentials.AccessKeyId.length > 0 && credentials.SecretAccessKey.length > 0 && credentials.SessionToken.length > 0;
 }
 async function checkStsCallerIdentity() {
-  const { STSClient, GetCallerIdentityCommand } = await import("./chunk-djydtvkr.js");
+  const { STSClient, GetCallerIdentityCommand } = await import("./chunk-fekynwj1.js");
   await new STSClient().send(new GetCallerIdentityCommand({}));
 }
 async function clearAwsIniCache() {
   try {
     logForDebugging("Clearing AWS credential provider cache");
-    const { fromIni } = await import("./chunk-d90bhmt1.js");
+    const { fromIni } = await import("./chunk-w0b04y7r.js");
     const iniProvider = fromIni({ ignoreCache: true });
     await iniProvider();
     logForDebugging("AWS credential provider cache refreshed");
@@ -14531,9 +15570,9 @@ var init_secureStorage = __esm(() => {
 
 // src/utils/secureStorage/keychainPrefetch.ts
 import { execFile as execFile2 } from "child_process";
-function spawnSecurity(serviceName) {
+function spawnSecurity(serviceName2) {
   return new Promise((resolve4) => {
-    execFile2("security", ["find-generic-password", "-a", getUsername(), "-w", "-s", serviceName], { encoding: "utf-8", timeout: KEYCHAIN_PREFETCH_TIMEOUT_MS }, (err, stdout) => {
+    execFile2("security", ["find-generic-password", "-a", getUsername(), "-w", "-s", serviceName2], { encoding: "utf-8", timeout: KEYCHAIN_PREFETCH_TIMEOUT_MS }, (err, stdout) => {
       resolve4({
         stdout: err ? null : stdout?.trim() || null,
         timedOut: Boolean(err && "killed" in err && err.killed)
@@ -15378,10 +16417,10 @@ async function checkAndRefreshOAuthTokenIfNeededImpl(retryCount, force) {
   }
   const claudeDir = getClaudeConfigHomeDir();
   await mkdir4(claudeDir, { recursive: true });
-  let release;
+  let release2;
   try {
     logEvent("tengu_oauth_token_refresh_lock_acquiring", {});
-    release = await lock(claudeDir);
+    release2 = await lock(claudeDir);
     logEvent("tengu_oauth_token_refresh_lock_acquired", {});
   } catch (err) {
     if (err.code === "ELOCKED") {
@@ -15431,7 +16470,7 @@ async function checkAndRefreshOAuthTokenIfNeededImpl(retryCount, force) {
     return false;
   } finally {
     logEvent("tengu_oauth_token_refresh_lock_releasing", {});
-    await release();
+    await release2();
     logEvent("tengu_oauth_token_refresh_lock_released", {});
   }
 }
@@ -16119,4 +17158,4 @@ var init_client2 = __esm(() => {
   init_getOauthProfile();
 });
 
-export { _baseSet_default, init__baseSet, pickBy_default, init_pickBy, isEqual_default, init_isEqual, init_lodash, sequential, init_sequential, _baseFor_default, init__baseFor, isPlainObject_default, init_isPlainObject, _overRest_default, init__overRest, _setToString_default, init__setToString, detectEncodingForResolvedPath, readFileSyncWithMetadata, readFileSync, init_fileRead, setSessionCache, resetSyncCache, setEligibility, getSettingsPath, getRemoteManagedSettingsSyncFromCache, init_syncCacheState, pathExists, MAX_OUTPUT_SIZE, readFileSafe, getFileModificationTime, getFileModificationTimeAsync, writeTextContent, detectFileEncoding, detectLineEndings, convertLeadingTabsToSpaces, getDisplayPath, findSimilarFile, FILE_NOT_FOUND_CWD_NOTE, suggestPathUnderCwd, isCompactLinePrefixEnabled, addLineNumbers, stripLineNumberPrefix, isDirEmpty, readFileSyncCached, getDesktopPath, isFileWithinReadSizeLimit, normalizePathForComparison, pathsEqual, init_file, isPathGitignored, init_gitignore, SETTING_SOURCES, getSettingSourceName, getSourceDisplayName, getSettingSourceDisplayNameLowercase, getSettingSourceDisplayNameCapitalized, parseSettingSourcesFlag, getEnabledSettingSources, isSettingSourceEnabled, SOURCES, init_constants, consumeInternalWrite, clearInternalWrites, init_internalWrites, getManagedFilePath, getManagedSettingsDropInDir, init_managedPath, BLACK_CIRCLE, BULLET_OPERATOR, TEARDROP_ASTERISK, UP_ARROW, DOWN_ARROW, LIGHTNING_BOLT, EFFORT_LOW, EFFORT_MEDIUM, EFFORT_HIGH, EFFORT_MAX, PLAY_ICON, PAUSE_ICON, REFRESH_ARROW, CHANNEL_ARROW, DIAMOND_OPEN, DIAMOND_FILLED, REFERENCE_MARK, FLAG_ICON, BLOCKQUOTE_BAR, BRIDGE_SPINNER_FRAMES, BRIDGE_READY_INDICATOR, BRIDGE_FAILED_INDICATOR, init_figures, permissionModeSchema, externalPermissionModeSchema, isExternalPermissionMode, toExternalPermissionMode, permissionModeFromString, permissionModeTitle, isDefaultMode, permissionModeSymbol, getModeColor, init_PermissionMode, HOOK_EVENTS, init_agentSdkTypes, DEFAULT_HOOK_SHELL, init_shellProvider, HooksSchema, ALLOWED_OFFICIAL_MARKETPLACE_NAMES, isMarketplaceAutoUpdate, validateOfficialNameSource, PluginHooksSchema, LspServerConfigSchema, PluginManifestSchema, isLocalPluginSource, isLocalMarketplaceSource, PluginMarketplaceEntrySchema, PluginMarketplaceSchema, PluginIdSchema, InstalledPluginsFileSchemaV1, InstalledPluginsFileSchemaV2, KnownMarketplacesFileSchema, init_schemas, mcpInfoFromString, getMcpPrefix, buildMcpToolName, getToolNameForPermissionCheck, getMcpDisplayName, extractMcpToolDisplayName, init_mcpStringUtils, AGENT_TOOL_NAME, LEGACY_AGENT_TOOL_NAME, VERIFICATION_AGENT_TYPE, ONE_SHOT_BUILTIN_AGENT_TYPES, init_constants2 as init_constants1, TASK_OUTPUT_TOOL_NAME, init_constants3 as init_constants2, TASK_STOP_TOOL_NAME, DESCRIPTION, init_prompt, BRIEF_TOOL_NAME, LEGACY_BRIEF_TOOL_NAME, DESCRIPTION2 as DESCRIPTION1, BRIEF_TOOL_PROMPT, exports_prompt, init_prompt2 as init_prompt1, normalizeLegacyToolName, getLegacyToolNames, permissionRuleValueFromString, permissionRuleValueToString, init_permissionRuleParser, escapeRegExp, capitalize, plural, firstLineOf, countCharInString, normalizeFullWidthDigits, normalizeFullWidthSpace, safeJoinLines, EndTruncatingAccumulator, truncateToLines, init_stringUtils, CUSTOMIZATION_SURFACES, SettingsSchema, isMcpServerNameEntry, isMcpServerCommandEntry, isMcpServerUrlEntry, init_types2 as init_types, validateSettingsFileContent, init_validation2 as init_validation, startMdmRawRead, init_rawRead, ensureMdmSettingsLoaded, getMdmSettings, getHkcuSettings, setMdmSettingsCache, refreshMdmSettings, init_settings, getManagedFileSettingsPresence, parseSettingsFile, getSettingsRootPathForSource, getSettingsFilePathForSource, getRelativeSettingsFilePathForSource, getSettingsForSource, getPolicySettingsOrigin, updateSettingsForSource, getManagedSettingsKeysForLogging, getInitialSettings, getSettings_DEPRECATED, getSettingsWithSources, getSettingsWithErrors, hasSkipDangerousModePermissionPrompt, hasAutoModeOptIn, getUseAutoModeDuringPlan, getAutoModeConfig, rawSettingsContainsKey, init_settings2 as init_settings1, createBedrockRuntimeClient, getInferenceProfileBackingModel, isFoundationModel, getBedrockRegionPrefix, applyBedrockRegionPrefix, init_bedrock, CLAUDE_OPUS_4_6_CONFIG, init_configs, getAPIProvider, getAPIProviderForStatsig, isFirstPartyAnthropicBaseUrl, init_providers, getModelStrings2 as getModelStrings, ensureModelStringsInitialized, init_modelStrings, hasConsoleBillingAccess, hasClaudeAiBillingAccess, init_billing, getMockHeaderless429Message, getMockHeaders, applyMockHeaders, shouldProcessMockLimits, isMockFastModeRateLimitScenario, checkMockFastModeRateLimit, init_mockRateLimits, getOauthProfileFromApiKey, getOauthProfileFromOauthToken, init_getOauthProfile, shouldUseClaudeAIAuth, parseScopes, buildAuthUrl, exchangeCodeForTokens, refreshOAuthToken, fetchAndStoreUserRoles, createAndStoreApiKey, isOAuthTokenExpired, fetchProfileInfo, getOrganizationUUID, populateOAuthAccountInfoIfNeeded, storeOAuthAccountInfo, init_client2 as init_client, CCR_SESSION_INGRESS_TOKEN_PATH, maybePersistTokenForSubprocesses, readTokenFromWellKnownFile, init_authFileDescriptor, clearKeychainCache, init_macOsKeychainHelpers, normalizeApiKeyForConfig, init_authPortable, isAwsCredentialsProviderError, init_aws, AwsAuthStatusManager, init_awsAuthStatusManager, CONTEXT_1M_BETA_HEADER, CONTEXT_MANAGEMENT_BETA_HEADER, STRUCTURED_OUTPUTS_BETA_HEADER, EFFORT_BETA_HEADER, TASK_BUDGETS_BETA_HEADER, PROMPT_CACHING_SCOPE_BETA_HEADER, FAST_MODE_BETA_HEADER, REDACT_THINKING_BETA_HEADER, AFK_MODE_BETA_HEADER, ADVISOR_BETA_HEADER, VERTEX_COUNT_TOKENS_ALLOWED_BETAS, init_betas, getAntModelOverrideConfig, getAntModels, resolveAntModel, init_antModels, isFastModeEnabled, isFastModeAvailable, getFastModeUnavailableReason, FAST_MODE_MODEL_DISPLAY, getFastModeModel, getInitialFastModeSetting, isFastModeSupportedByModel, onCooldownTriggered, onCooldownExpired, getFastModeRuntimeState, triggerFastModeCooldown, clearFastModeCooldown, handleFastModeRejectedByAPI, onFastModeOverageRejection, handleFastModeOverageRejection, isFastModeCooldown, getFastModeState, onOrgFastModeChanged, resolveFastModeStatusFromCache, prefetchFastModeStatus, init_fastMode, COST_TIER_3_15, COST_HAIKU_35, COST_HAIKU_45, getOpus46CostTier, MODEL_COSTS, calculateUSDCost, calculateCostFromTokens, formatModelPricing, init_modelCost, MODEL_ALIASES, init_aliases, isModelAllowed, init_modelAllowlist, getSmallFastModel, isNonCustomOpusModel, getUserSpecifiedModelSetting, getMainLoopModel, getBestModel, getDefaultOpusModel, getDefaultSonnetModel, getDefaultHaikuModel, getRuntimeMainLoopModel, getDefaultMainLoopModelSetting, getDefaultMainLoopModel, firstPartyNameToCanonical, getCanonicalName, getClaudeAiUserDefaultModelDescription, renderDefaultModelSetting, getOpus46PricingSuffix, isOpus1mMergeEnabled, renderModelSetting, getPublicModelDisplayName, renderModelName, getPublicModelName, parseUserSpecifiedModel, resolveSkillModelOverride, isLegacyModelRemapEnabled, modelDisplayString, getMarketingNameForModel, normalizeModelStringForAPI, init_model, getAnthropicClient, CLIENT_REQUEST_ID_HEADER, init_client as init_client1, refreshModelCapabilities, init_modelCapabilities, COMPACT_MAX_OUTPUT_TOKENS, CAPPED_DEFAULT_MAX_TOKENS, ESCALATED_MAX_TOKENS, is1mContextDisabled, has1mContext, getContextWindowForModel, getSonnet1mExpTreatmentEnabled, calculateContextPercentages, getModelMaxOutputTokens, getMaxThinkingTokensForModel, init_context, get3PModelCapabilityOverride, init_modelSupportOverrides, filterAllowedSdkBetas, modelSupportsStructuredOutputs, modelSupportsAutoMode, getToolSearchBetaHeader, shouldIncludeFirstPartyOnlyBetas, shouldUseGlobalCacheScope, getModelBetas, getBedrockExtraBodyParamsBetas, getMergedBetas, clearBetasCaches, init_betas2 as init_betas1, isMacOsKeychainLocked, init_macOsKeychainStorage, getSecureStorage, init_secureStorage, startKeychainPrefetch, ensureKeychainPrefetchCompleted, init_keychainPrefetch, getToolSchemaCache, clearToolSchemaCache, init_toolSchemaCache, isAnthropicAuthEnabled, getAuthTokenSource, getAnthropicApiKey, hasAnthropicApiKeyAuth, getAnthropicApiKeyWithSource, getConfiguredApiKeyHelper, isAwsAuthRefreshFromProjectSettings, isAwsCredentialExportFromProjectSettings, calculateApiKeyHelperTTL, getApiKeyHelperElapsedMs, getApiKeyFromApiKeyHelper, getApiKeyFromApiKeyHelperCached, clearApiKeyHelperCache, prefetchApiKeyFromApiKeyHelperIfSafe, refreshAwsAuth, refreshAndGetAwsCredentials, clearAwsCredentialsCache, isGcpAuthRefreshFromProjectSettings, checkGcpCredentialsValid, refreshGcpAuth, refreshGcpCredentialsIfNeeded, clearGcpCredentialsCache, prefetchGcpCredentialsIfSafe, prefetchAwsCredentialsAndBedRockInfoIfSafe, getApiKeyFromConfigOrMacOSKeychain, saveApiKey, isCustomApiKeyApproved, removeApiKey, saveOAuthTokensIfNeeded, getClaudeAIOAuthTokens, clearOAuthTokenCache, handleOAuth401Error, getClaudeAIOAuthTokensAsync, checkAndRefreshOAuthTokenIfNeeded, isClaudeAISubscriber, hasProfileScope, is1PApiCustomer, getOauthAccountInfo, isOverageProvisioningAllowed, hasOpusAccess, getSubscriptionType, isMaxSubscriber, isTeamSubscriber, isTeamPremiumSubscriber, isEnterpriseSubscriber, isProSubscriber, getRateLimitTier, getSubscriptionName, isUsing3PServices, isOtelHeadersHelperFromProjectOrLocalSettings, getOtelHeadersFromHelper, isConsumerSubscriber, getAccountInformation, validateForceLoginOrg, exports_auth, init_auth2 as init_auth, getClaudeCodeUserAgent, init_userAgent, WORKLOAD_CRON, getWorkload, runWithWorkload, init_workloadContext, getUserAgent, getMCPUserAgent, getWebFetchUserAgent, getAuthHeaders, withOAuth401Retry, init_http, initUser, resetUserCache, getCoreUserData, getGitEmail, init_user, require_src5 as require_src, LoggerProvider, ConsoleLogRecordExporter, BatchLogRecordProcessor, init_esm2 as init_esm, isAnalyticsDisabled, isFeedbackSurveyDisabled, init_config2 as init_config, initJetBrainsDetection, envDynamic, init_envDynamic, isAgentSwarmsEnabled, init_agentSwarmsEnabled, getAgentContext, runWithAgentContext, getSubagentLogName, consumeInvokingRequestId, init_agentContext, sanitizeToolNameForAnalytics, isToolDetailsLoggingEnabled, mcpToolDetailsForAnalytics, extractMcpToolDetails, extractSkillName, extractToolInputForTelemetry, getFileExtensionForAnalytics, getFileExtensionsFromBashCommand, getEventMetadata, init_metadata, isSinkKilled, init_sinkKillswitch, getEventSamplingConfig, shouldSampleEvent, shutdown1PEventLogging, is1PEventLoggingEnabled, logEventTo1P, logGrowthBookExperimentTo1P, initialize1PEventLogging, reinitialize1PEventLoggingIfConfigChanged, init_firstPartyEventLogger, onGrowthBookRefresh, hasGrowthBookEnvOverride, getAllGrowthBookFeatures, getGrowthBookConfigOverrides, setGrowthBookConfigOverride, clearGrowthBookConfigOverrides, getApiBaseUrlHost, initializeGrowthBook, getFeatureValue_DEPRECATED, getFeatureValue_CACHED_MAY_BE_STALE, getFeatureValue_CACHED_WITH_REFRESH, checkStatsigFeatureGate_CACHED_MAY_BE_STALE, checkSecurityRestrictionGate, checkGate_CACHED_OR_BLOCKING, refreshGrowthBookAfterAuthChange, resetGrowthBook, refreshGrowthBookFeatures, setupPeriodicGrowthBookRefresh, stopPeriodicGrowthBookRefresh, getDynamicConfig_BLOCKS_ON_INIT, getDynamicConfig_CACHED_MAY_BE_STALE, init_growthbook, isAutoMemoryEnabled, isExtractModeActive, getMemoryBaseDir, hasAutoMemPathOverride, getAutoMemPath, getAutoMemEntrypoint, isAutoMemPath, init_paths, NOTIFICATION_CHANNELS, EDITOR_MODES, TEAMMATE_MODES, init_configConstants, DEFAULT_GLOBAL_CONFIG, GLOBAL_CONFIG_KEYS, isGlobalConfigKey, PROJECT_CONFIG_KEYS, resetTrustDialogAcceptedCacheForTesting, checkHasTrustDialogAccepted, isPathTrusted, isProjectConfigKey, saveGlobalConfig, getGlobalConfigWriteCount, CONFIG_WRITE_DISPLAY_THRESHOLD, getGlobalConfig, getRemoteControlAtStartup, getCustomApiKeyStatus, enableConfigs, getProjectPathForConfig, getCurrentProjectConfig, saveCurrentProjectConfig, isAutoUpdaterDisabled, shouldSkipPluginAutoupdate, formatAutoUpdaterDisabledReason, getAutoUpdaterDisabledReason, getOrCreateUserID, recordFirstStartTime, getMemoryPath, getManagedClaudeRulesDir, getUserClaudeRulesDir, _getConfigForTesting, _wouldLoseAuthStateForTesting, _setGlobalConfigCacheForTesting, init_config as init_config1 };
+export { _baseSet_default, init__baseSet, pickBy_default, init_pickBy, isEqual_default, init_isEqual, init_lodash, sequential, init_sequential, _baseFor_default, init__baseFor, isPlainObject_default, init_isPlainObject, _overRest_default, init__overRest, _setToString_default, init__setToString, detectEncodingForResolvedPath, readFileSyncWithMetadata, readFileSync, init_fileRead, setSessionCache, resetSyncCache, setEligibility, getSettingsPath, getRemoteManagedSettingsSyncFromCache, init_syncCacheState, pathExists, MAX_OUTPUT_SIZE, readFileSafe, getFileModificationTime, getFileModificationTimeAsync, writeTextContent, detectFileEncoding, detectLineEndings, convertLeadingTabsToSpaces, getDisplayPath, findSimilarFile, FILE_NOT_FOUND_CWD_NOTE, suggestPathUnderCwd, isCompactLinePrefixEnabled, addLineNumbers, stripLineNumberPrefix, isDirEmpty, readFileSyncCached, getDesktopPath, isFileWithinReadSizeLimit, normalizePathForComparison, pathsEqual, init_file, isPathGitignored, init_gitignore, SETTING_SOURCES, getSettingSourceName, getSourceDisplayName, getSettingSourceDisplayNameLowercase, getSettingSourceDisplayNameCapitalized, parseSettingSourcesFlag, getEnabledSettingSources, isSettingSourceEnabled, SOURCES, init_constants2 as init_constants, consumeInternalWrite, clearInternalWrites, init_internalWrites, getManagedFilePath, getManagedSettingsDropInDir, init_managedPath, BLACK_CIRCLE, BULLET_OPERATOR, TEARDROP_ASTERISK, UP_ARROW, DOWN_ARROW, LIGHTNING_BOLT, EFFORT_LOW, EFFORT_MEDIUM, EFFORT_HIGH, EFFORT_MAX, PLAY_ICON, PAUSE_ICON, REFRESH_ARROW, CHANNEL_ARROW, DIAMOND_OPEN, DIAMOND_FILLED, REFERENCE_MARK, FLAG_ICON, BLOCKQUOTE_BAR, BRIDGE_SPINNER_FRAMES, BRIDGE_READY_INDICATOR, BRIDGE_FAILED_INDICATOR, init_figures, permissionModeSchema, externalPermissionModeSchema, isExternalPermissionMode, toExternalPermissionMode, permissionModeFromString, permissionModeTitle, isDefaultMode, permissionModeSymbol, getModeColor, init_PermissionMode, HOOK_EVENTS, init_agentSdkTypes, DEFAULT_HOOK_SHELL, init_shellProvider, HooksSchema, ALLOWED_OFFICIAL_MARKETPLACE_NAMES, isMarketplaceAutoUpdate, validateOfficialNameSource, PluginHooksSchema, LspServerConfigSchema, PluginManifestSchema, isLocalPluginSource, isLocalMarketplaceSource, PluginMarketplaceEntrySchema, PluginMarketplaceSchema, PluginIdSchema, InstalledPluginsFileSchemaV1, InstalledPluginsFileSchemaV2, KnownMarketplacesFileSchema, init_schemas, mcpInfoFromString, getMcpPrefix, buildMcpToolName, getToolNameForPermissionCheck, getMcpDisplayName, extractMcpToolDisplayName, init_mcpStringUtils, AGENT_TOOL_NAME, LEGACY_AGENT_TOOL_NAME, VERIFICATION_AGENT_TYPE, ONE_SHOT_BUILTIN_AGENT_TYPES, init_constants3 as init_constants1, TASK_OUTPUT_TOOL_NAME, init_constants4 as init_constants2, TASK_STOP_TOOL_NAME, DESCRIPTION, init_prompt, BRIEF_TOOL_NAME, LEGACY_BRIEF_TOOL_NAME, DESCRIPTION2 as DESCRIPTION1, BRIEF_TOOL_PROMPT, exports_prompt, init_prompt2 as init_prompt1, normalizeLegacyToolName, getLegacyToolNames, permissionRuleValueFromString, permissionRuleValueToString, init_permissionRuleParser, escapeRegExp, capitalize, plural, firstLineOf, countCharInString, normalizeFullWidthDigits, normalizeFullWidthSpace, safeJoinLines, EndTruncatingAccumulator, truncateToLines, init_stringUtils, CUSTOMIZATION_SURFACES, SettingsSchema, isMcpServerNameEntry, isMcpServerCommandEntry, isMcpServerUrlEntry, init_types2 as init_types, validateSettingsFileContent, init_validation2 as init_validation, startMdmRawRead, init_rawRead, ensureMdmSettingsLoaded, getMdmSettings, getHkcuSettings, setMdmSettingsCache, refreshMdmSettings, init_settings, getManagedFileSettingsPresence, parseSettingsFile, getSettingsRootPathForSource, getSettingsFilePathForSource, getRelativeSettingsFilePathForSource, getSettingsForSource, getPolicySettingsOrigin, updateSettingsForSource, getManagedSettingsKeysForLogging, getInitialSettings, getSettings_DEPRECATED, getSettingsWithSources, getSettingsWithErrors, hasSkipDangerousModePermissionPrompt, hasAutoModeOptIn, getUseAutoModeDuringPlan, getAutoModeConfig, rawSettingsContainsKey, init_settings2 as init_settings1, createBedrockRuntimeClient, getInferenceProfileBackingModel, isFoundationModel, getBedrockRegionPrefix, applyBedrockRegionPrefix, init_bedrock, CLAUDE_OPUS_4_6_CONFIG, init_configs, getAPIProvider, getAPIProviderForStatsig, isFirstPartyAnthropicBaseUrl, init_providers, getModelStrings2 as getModelStrings, ensureModelStringsInitialized, init_modelStrings, hasConsoleBillingAccess, hasClaudeAiBillingAccess, init_billing, getMockHeaderless429Message, getMockHeaders, applyMockHeaders, shouldProcessMockLimits, isMockFastModeRateLimitScenario, checkMockFastModeRateLimit, init_mockRateLimits, getOauthProfileFromApiKey, getOauthProfileFromOauthToken, init_getOauthProfile, shouldUseClaudeAIAuth, parseScopes, buildAuthUrl, exchangeCodeForTokens, refreshOAuthToken, fetchAndStoreUserRoles, createAndStoreApiKey, isOAuthTokenExpired, fetchProfileInfo, getOrganizationUUID, populateOAuthAccountInfoIfNeeded, storeOAuthAccountInfo, init_client2 as init_client, CCR_SESSION_INGRESS_TOKEN_PATH, maybePersistTokenForSubprocesses, readTokenFromWellKnownFile, init_authFileDescriptor, clearKeychainCache, init_macOsKeychainHelpers, normalizeApiKeyForConfig, init_authPortable, isAwsCredentialsProviderError, init_aws, AwsAuthStatusManager, init_awsAuthStatusManager, CONTEXT_1M_BETA_HEADER, CONTEXT_MANAGEMENT_BETA_HEADER, STRUCTURED_OUTPUTS_BETA_HEADER, EFFORT_BETA_HEADER, TASK_BUDGETS_BETA_HEADER, PROMPT_CACHING_SCOPE_BETA_HEADER, FAST_MODE_BETA_HEADER, REDACT_THINKING_BETA_HEADER, AFK_MODE_BETA_HEADER, ADVISOR_BETA_HEADER, VERTEX_COUNT_TOKENS_ALLOWED_BETAS, init_betas, getAntModelOverrideConfig, getAntModels, resolveAntModel, init_antModels, isFastModeEnabled, isFastModeAvailable, getFastModeUnavailableReason, FAST_MODE_MODEL_DISPLAY, getFastModeModel, getInitialFastModeSetting, isFastModeSupportedByModel, onCooldownTriggered, onCooldownExpired, getFastModeRuntimeState, triggerFastModeCooldown, clearFastModeCooldown, handleFastModeRejectedByAPI, onFastModeOverageRejection, handleFastModeOverageRejection, isFastModeCooldown, getFastModeState, onOrgFastModeChanged, resolveFastModeStatusFromCache, prefetchFastModeStatus, init_fastMode, COST_TIER_3_15, COST_HAIKU_35, COST_HAIKU_45, getOpus46CostTier, MODEL_COSTS, calculateUSDCost, calculateCostFromTokens, formatModelPricing, init_modelCost, MODEL_ALIASES, init_aliases, isModelAllowed, init_modelAllowlist, getSmallFastModel, isNonCustomOpusModel, getUserSpecifiedModelSetting, getMainLoopModel, getBestModel, getDefaultOpusModel, getDefaultSonnetModel, getDefaultHaikuModel, getRuntimeMainLoopModel, getDefaultMainLoopModelSetting, getDefaultMainLoopModel, firstPartyNameToCanonical, getCanonicalName, getClaudeAiUserDefaultModelDescription, renderDefaultModelSetting, getOpus46PricingSuffix, isOpus1mMergeEnabled, renderModelSetting, getPublicModelDisplayName, renderModelName, getPublicModelName, parseUserSpecifiedModel, resolveSkillModelOverride, isLegacyModelRemapEnabled, modelDisplayString, getMarketingNameForModel, normalizeModelStringForAPI, init_model, getAnthropicClient, CLIENT_REQUEST_ID_HEADER, init_client as init_client1, refreshModelCapabilities, init_modelCapabilities, COMPACT_MAX_OUTPUT_TOKENS, CAPPED_DEFAULT_MAX_TOKENS, ESCALATED_MAX_TOKENS, is1mContextDisabled, has1mContext, getContextWindowForModel, getSonnet1mExpTreatmentEnabled, calculateContextPercentages, getModelMaxOutputTokens, getMaxThinkingTokensForModel, init_context, get3PModelCapabilityOverride, init_modelSupportOverrides, filterAllowedSdkBetas, modelSupportsStructuredOutputs, modelSupportsAutoMode, getToolSearchBetaHeader, shouldIncludeFirstPartyOnlyBetas, shouldUseGlobalCacheScope, getModelBetas, getBedrockExtraBodyParamsBetas, getMergedBetas, clearBetasCaches, init_betas2 as init_betas1, isMacOsKeychainLocked, init_macOsKeychainStorage, getSecureStorage, init_secureStorage, startKeychainPrefetch, ensureKeychainPrefetchCompleted, init_keychainPrefetch, getToolSchemaCache, clearToolSchemaCache, init_toolSchemaCache, isAnthropicAuthEnabled, getAuthTokenSource, getAnthropicApiKey, hasAnthropicApiKeyAuth, getAnthropicApiKeyWithSource, getConfiguredApiKeyHelper, isAwsAuthRefreshFromProjectSettings, isAwsCredentialExportFromProjectSettings, calculateApiKeyHelperTTL, getApiKeyHelperElapsedMs, getApiKeyFromApiKeyHelper, getApiKeyFromApiKeyHelperCached, clearApiKeyHelperCache, prefetchApiKeyFromApiKeyHelperIfSafe, refreshAwsAuth, refreshAndGetAwsCredentials, clearAwsCredentialsCache, isGcpAuthRefreshFromProjectSettings, checkGcpCredentialsValid, refreshGcpAuth, refreshGcpCredentialsIfNeeded, clearGcpCredentialsCache, prefetchGcpCredentialsIfSafe, prefetchAwsCredentialsAndBedRockInfoIfSafe, getApiKeyFromConfigOrMacOSKeychain, saveApiKey, isCustomApiKeyApproved, removeApiKey, saveOAuthTokensIfNeeded, getClaudeAIOAuthTokens, clearOAuthTokenCache, handleOAuth401Error, getClaudeAIOAuthTokensAsync, checkAndRefreshOAuthTokenIfNeeded, isClaudeAISubscriber, hasProfileScope, is1PApiCustomer, getOauthAccountInfo, isOverageProvisioningAllowed, hasOpusAccess, getSubscriptionType, isMaxSubscriber, isTeamSubscriber, isTeamPremiumSubscriber, isEnterpriseSubscriber, isProSubscriber, getRateLimitTier, getSubscriptionName, isUsing3PServices, isOtelHeadersHelperFromProjectOrLocalSettings, getOtelHeadersFromHelper, isConsumerSubscriber, getAccountInformation, validateForceLoginOrg, exports_auth, init_auth2 as init_auth, getClaudeCodeUserAgent, init_userAgent, WORKLOAD_CRON, getWorkload, runWithWorkload, init_workloadContext, getUserAgent, getMCPUserAgent, getWebFetchUserAgent, getAuthHeaders, withOAuth401Retry, init_http, initUser, resetUserCache, getCoreUserData, getGitEmail, init_user, suppressTracing, isTracingSuppressed, W3CBaggagePropagator, sanitizeAttributes, isAttributeValue, globalErrorHandler, getNumberFromEnv, getStringFromEnv, SDK_INFO, otperformance, millisToHrTime, hrTime, hrTimeDuration, hrTimeToMilliseconds, hrTimeToMicroseconds, isTimeInputHrTime, isTimeInput, addHrTimes, ExportResultCode, TraceState, RPCType, setRPCMetadata, getRPCMetadata, merge, BindOnceFuture, internal, init_esm2 as init_esm, envDetector, hostDetector, osDetector, resourceFromAttributes, defaultResource, init_esm3 as init_esm1, require_src5 as require_src, LoggerProvider, ConsoleLogRecordExporter, BatchLogRecordProcessor, init_esm4 as init_esm2, isAnalyticsDisabled, isFeedbackSurveyDisabled, init_config2 as init_config, initJetBrainsDetection, envDynamic, init_envDynamic, isAgentSwarmsEnabled, init_agentSwarmsEnabled, getAgentContext, runWithAgentContext, getSubagentLogName, consumeInvokingRequestId, init_agentContext, sanitizeToolNameForAnalytics, isToolDetailsLoggingEnabled, mcpToolDetailsForAnalytics, extractMcpToolDetails, extractSkillName, extractToolInputForTelemetry, getFileExtensionForAnalytics, getFileExtensionsFromBashCommand, getEventMetadata, init_metadata, isSinkKilled, init_sinkKillswitch, getEventSamplingConfig, shouldSampleEvent, shutdown1PEventLogging, is1PEventLoggingEnabled, logEventTo1P, logGrowthBookExperimentTo1P, initialize1PEventLogging, reinitialize1PEventLoggingIfConfigChanged, init_firstPartyEventLogger, onGrowthBookRefresh, hasGrowthBookEnvOverride, getAllGrowthBookFeatures, getGrowthBookConfigOverrides, setGrowthBookConfigOverride, clearGrowthBookConfigOverrides, getApiBaseUrlHost, initializeGrowthBook, getFeatureValue_DEPRECATED, getFeatureValue_CACHED_MAY_BE_STALE, getFeatureValue_CACHED_WITH_REFRESH, checkStatsigFeatureGate_CACHED_MAY_BE_STALE, checkSecurityRestrictionGate, checkGate_CACHED_OR_BLOCKING, refreshGrowthBookAfterAuthChange, resetGrowthBook, refreshGrowthBookFeatures, setupPeriodicGrowthBookRefresh, stopPeriodicGrowthBookRefresh, getDynamicConfig_BLOCKS_ON_INIT, getDynamicConfig_CACHED_MAY_BE_STALE, init_growthbook, isAutoMemoryEnabled, isExtractModeActive, getMemoryBaseDir, hasAutoMemPathOverride, getAutoMemPath, getAutoMemEntrypoint, isAutoMemPath, init_paths, NOTIFICATION_CHANNELS, EDITOR_MODES, TEAMMATE_MODES, init_configConstants, DEFAULT_GLOBAL_CONFIG, GLOBAL_CONFIG_KEYS, isGlobalConfigKey, PROJECT_CONFIG_KEYS, resetTrustDialogAcceptedCacheForTesting, checkHasTrustDialogAccepted, isPathTrusted, isProjectConfigKey, saveGlobalConfig, getGlobalConfigWriteCount, CONFIG_WRITE_DISPLAY_THRESHOLD, getGlobalConfig, getRemoteControlAtStartup, getCustomApiKeyStatus, enableConfigs, getProjectPathForConfig, getCurrentProjectConfig, saveCurrentProjectConfig, isAutoUpdaterDisabled, shouldSkipPluginAutoupdate, formatAutoUpdaterDisabledReason, getAutoUpdaterDisabledReason, getOrCreateUserID, recordFirstStartTime, getMemoryPath, getManagedClaudeRulesDir, getUserClaudeRulesDir, _getConfigForTesting, _wouldLoseAuthStateForTesting, _setGlobalConfigCacheForTesting, init_config as init_config1 };