@sentry/junior 0.202.0 → 0.204.0

package/dist/agent-hooks-UXITLYOK.js

@@ -1,51 +0,0 @@
-import {
-  PluginHookDeniedError,
-  applyPluginFormatMarkdown,
-  createPluginHookRunner,
-  getPluginApiRoutes,
-  getPluginOperationalReports,
-  getPluginProfileReports,
-  getPluginRoutes,
-  getPluginSlackConversationLink,
-  getPluginSystemPromptContributions,
-  getPluginTools,
-  getPluginUserPromptContributions,
-  getPlugins,
-  setPlugins,
-  validatePlugins
-} from "./chunk-U2GPUYAL.js";
-import "./chunk-3Y47VMHV.js";
-import "./chunk-M76HMB7M.js";
-import "./chunk-PW4P4JYF.js";
-import "./chunk-NSXKRGRT.js";
-import "./chunk-2MK3QBGA.js";
-import "./chunk-7NL7T6VU.js";
-import "./chunk-VFUK3X5B.js";
-import "./chunk-63NKKFJL.js";
-import "./chunk-NHJU2ZAL.js";
-import "./chunk-5NOPO64K.js";
-import "./chunk-YDUR3ZYW.js";
-import "./chunk-BXCX5QKA.js";
-import "./chunk-CEMMLV5L.js";
-import "./chunk-N7TMSOZH.js";
-import "./chunk-DWPN6SCH.js";
-import "./chunk-TXKUKMVO.js";
-import "./chunk-MAGNK5J4.js";
-import "./chunk-PEQXYSSE.js";
-import "./chunk-HMREVIO2.js";
-export {
-  PluginHookDeniedError,
-  applyPluginFormatMarkdown,
-  createPluginHookRunner,
-  getPluginApiRoutes,
-  getPluginOperationalReports,
-  getPluginProfileReports,
-  getPluginRoutes,
-  getPluginSlackConversationLink,
-  getPluginSystemPromptContributions,
-  getPluginTools,
-  getPluginUserPromptContributions,
-  getPlugins,
-  setPlugins,
-  validatePlugins
-};

package/dist/catalog-runtime-BG3JLLK2.js

@@ -1,14 +0,0 @@
-import {
-  pluginCatalogRuntime
-} from "./chunk-YDUR3ZYW.js";
-import "./chunk-BXCX5QKA.js";
-import "./chunk-CEMMLV5L.js";
-import "./chunk-N7TMSOZH.js";
-import "./chunk-DWPN6SCH.js";
-import "./chunk-TXKUKMVO.js";
-import "./chunk-MAGNK5J4.js";
-import "./chunk-PEQXYSSE.js";
-import "./chunk-HMREVIO2.js";
-export {
-  pluginCatalogRuntime
-};

package/dist/chunk-2LYHWMR4.js

@@ -1,46 +0,0 @@
-// src/chat/experimental.ts
-var EXPERIMENTAL_FEATURES = ["passive-routing", "subagents"];
-var EXPERIMENTAL_FEATURE_SET = new Set(EXPERIMENTAL_FEATURES);
-var configuredExperimental = {};
-function isExperimentalFeature(value) {
-  return EXPERIMENTAL_FEATURE_SET.has(value);
-}
-function setExperimentalFeatures(config) {
-  const previous = { ...configuredExperimental };
-  if (config === void 0) {
-    configuredExperimental = {};
-    return previous;
-  }
-  const next = {};
-  for (const [rawName, enabled] of Object.entries(config)) {
-    if (enabled === void 0) {
-      continue;
-    }
-    if (typeof enabled !== "boolean") {
-      throw new Error(
-        `experimental.${rawName} must be a boolean when provided`
-      );
-    }
-    if (!isExperimentalFeature(rawName)) {
-      throw new Error(
-        `experimental.${rawName} is not a known experimental feature. Known features: ${EXPERIMENTAL_FEATURES.join(", ")}`
-      );
-    }
-    next[rawName] = enabled;
-  }
-  configuredExperimental = next;
-  return previous;
-}
-function getExperimentalFeatures() {
-  return { ...configuredExperimental };
-}
-function isExperimentalFeatureEnabled(feature) {
-  return configuredExperimental[feature] === true;
-}
-
-export {
-  EXPERIMENTAL_FEATURES,
-  setExperimentalFeatures,
-  getExperimentalFeatures,
-  isExperimentalFeatureEnabled
-};

package/dist/chunk-2MK3QBGA.js

@@ -1,321 +0,0 @@
-import {
-  getChatConfig
-} from "./chunk-63NKKFJL.js";
-
-// src/chat/state/adapter.ts
-import { createMemoryState } from "@chat-adapter/state-memory";
-import { createRedisState } from "@chat-adapter/state-redis";
-
-// src/chat/state/locks.ts
-import { setTimeout as sleep } from "timers/promises";
-var ACTIVE_LOCK_TTL_MS = 9e4;
-var MUTATION_LOCK_TTL_MS = 1e4;
-async function acquireActiveLock(state, threadId) {
-  return await state.acquireLock(threadId, ACTIVE_LOCK_TTL_MS);
-}
-async function withLock(state, key, run, options = {}) {
-  const startedAtMs = Date.now();
-  let lock;
-  while (true) {
-    lock = await state.acquireLock(key, options.ttlMs ?? ACTIVE_LOCK_TTL_MS);
-    if (lock) break;
-    if (Date.now() - startedAtMs >= (options.waitMs ?? 0)) {
-      return { acquired: false };
-    }
-    await sleep(options.retryMs ?? 25, void 0, { ref: false });
-  }
-  const ttlMs = options.ttlMs ?? ACTIVE_LOCK_TTL_MS;
-  const heartbeat = options.keepAlive ? setInterval(
-    () => {
-      void state.extendLock(lock, ttlMs);
-    },
-    Math.max(1, Math.floor(ttlMs / 3))
-  ) : void 0;
-  heartbeat?.unref();
-  try {
-    return { acquired: true, value: await run(lock) };
-  } finally {
-    if (heartbeat) clearInterval(heartbeat);
-    await state.releaseLock(lock);
-  }
-}
-async function fenceLock(state, lock, ttlMs = MUTATION_LOCK_TTL_MS) {
-  if (!await state.extendLock(lock, ttlMs)) {
-    throw new Error(
-      `Lock ownership was lost before write for ${lock.threadId}`
-    );
-  }
-}
-async function withActiveLock(state, key, run) {
-  return await withLock(state, key, run);
-}
-
-// src/chat/state/adapter.ts
-var ACTIVE_LOCK_HEARTBEAT_MS = 3e4;
-var stateAdapter;
-var redisStateAdapter;
-function createConnectingStateAdapter(base) {
-  const connected = async (operation) => {
-    await base.connect();
-    return await operation();
-  };
-  return {
-    appendToList: (key, value, options) => connected(() => base.appendToList(key, value, options)),
-    connect: () => base.connect(),
-    disconnect: () => base.disconnect(),
-    subscribe: (threadId) => connected(() => base.subscribe(threadId)),
-    unsubscribe: (threadId) => connected(() => base.unsubscribe(threadId)),
-    isSubscribed: (threadId) => connected(() => base.isSubscribed(threadId)),
-    acquireLock: (threadId, ttlMs) => connected(() => base.acquireLock(threadId, ttlMs)),
-    releaseLock: (lock) => connected(() => base.releaseLock(lock)),
-    extendLock: (lock, ttlMs) => connected(() => base.extendLock(lock, ttlMs)),
-    forceReleaseLock: (threadId) => connected(() => base.forceReleaseLock(threadId)),
-    enqueue: (threadId, entry, maxSize) => connected(() => base.enqueue(threadId, entry, maxSize)),
-    dequeue: (threadId) => connected(() => base.dequeue(threadId)),
-    queueDepth: (threadId) => connected(() => base.queueDepth(threadId)),
-    get: (key) => connected(() => base.get(key)),
-    getList: (key) => connected(() => base.getList(key)),
-    set: (key, value, ttlMs) => connected(() => base.set(key, value, ttlMs)),
-    setIfNotExists: (key, value, ttlMs) => connected(() => base.setIfNotExists(key, value, ttlMs)),
-    delete: (key) => connected(() => base.delete(key))
-  };
-}
-function createPrefixedStateAdapter(base, prefix) {
-  const prefixed = (value) => `${prefix}:${value}`;
-  const unprefixed = (value) => value.startsWith(`${prefix}:`) ? value.slice(prefix.length + 1) : value;
-  const prefixLock = (lock) => ({
-    ...lock,
-    threadId: prefixed(lock.threadId)
-  });
-  const unprefixLock = (lock) => ({
-    ...lock,
-    threadId: unprefixed(lock.threadId)
-  });
-  return {
-    appendToList: (key, value, options) => base.appendToList(prefixed(key), value, options),
-    connect: () => base.connect(),
-    disconnect: () => base.disconnect(),
-    subscribe: (threadId) => base.subscribe(prefixed(threadId)),
-    unsubscribe: (threadId) => base.unsubscribe(prefixed(threadId)),
-    isSubscribed: (threadId) => base.isSubscribed(prefixed(threadId)),
-    acquireLock: async (threadId, ttlMs) => {
-      const lock = await base.acquireLock(prefixed(threadId), ttlMs);
-      return lock ? unprefixLock(lock) : null;
-    },
-    releaseLock: (lock) => base.releaseLock(prefixLock(lock)),
-    extendLock: async (lock, ttlMs) => {
-      const prefixedLock = prefixLock(lock);
-      const extended = await base.extendLock(prefixedLock, ttlMs);
-      if (extended) {
-        lock.expiresAt = prefixedLock.expiresAt;
-      }
-      return extended;
-    },
-    forceReleaseLock: (threadId) => base.forceReleaseLock(prefixed(threadId)),
-    enqueue: (threadId, entry, maxSize) => base.enqueue(prefixed(threadId), entry, maxSize),
-    dequeue: (threadId) => base.dequeue(prefixed(threadId)),
-    queueDepth: (threadId) => base.queueDepth(prefixed(threadId)),
-    get: (key) => base.get(prefixed(key)),
-    getList: (key) => base.getList(prefixed(key)),
-    set: (key, value, ttlMs) => base.set(prefixed(key), value, ttlMs),
-    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(prefixed(key), value, ttlMs),
-    delete: (key) => base.delete(prefixed(key))
-  };
-}
-function createQueuedStateAdapter(base, options) {
-  const heartbeats = /* @__PURE__ */ new Map();
-  const shouldHeartbeatLock = (ttlMs) => ttlMs === ACTIVE_LOCK_TTL_MS;
-  const heartbeatKey = (lock) => `${lock.threadId}:${lock.token}`;
-  const stopHeartbeatByKey = (key) => {
-    const heartbeat = heartbeats.get(key);
-    if (!heartbeat) {
-      return;
-    }
-    clearInterval(heartbeat.timer);
-    heartbeats.delete(key);
-  };
-  const stopHeartbeat = (lock) => {
-    stopHeartbeatByKey(heartbeatKey(lock));
-  };
-  const stopHeartbeatsForThread = (threadId) => {
-    for (const [key, heartbeat] of heartbeats) {
-      if (heartbeat.lock.threadId === threadId) {
-        stopHeartbeatByKey(key);
-      }
-    }
-  };
-  const stopAllHeartbeats = () => {
-    for (const key of heartbeats.keys()) {
-      stopHeartbeatByKey(key);
-    }
-  };
-  const runHeartbeat = async (key) => {
-    const heartbeat = heartbeats.get(key);
-    if (!heartbeat || heartbeat.inFlight) {
-      return;
-    }
-    heartbeat.inFlight = true;
-    try {
-      if (Date.now() - heartbeat.startedAtMs >= options.activeLockMaxAgeMs) {
-        stopHeartbeatByKey(key);
-        return;
-      }
-      const extended = await base.extendLock(heartbeat.lock, heartbeat.ttlMs);
-      if (!extended) {
-        stopHeartbeatByKey(key);
-        return;
-      }
-      heartbeat.lock.expiresAt = Date.now() + heartbeat.ttlMs;
-    } catch {
-    } finally {
-      const current = heartbeats.get(key);
-      if (current === heartbeat) {
-        current.inFlight = false;
-      }
-    }
-  };
-  const startOrUpdateHeartbeat = (lock, ttlMs) => {
-    const key = heartbeatKey(lock);
-    const existing = heartbeats.get(key);
-    if (existing) {
-      existing.ttlMs = ttlMs;
-      return;
-    }
-    const timer = setInterval(() => {
-      void runHeartbeat(key);
-    }, ACTIVE_LOCK_HEARTBEAT_MS);
-    timer.unref?.();
-    heartbeats.set(key, {
-      inFlight: false,
-      lock,
-      startedAtMs: Date.now(),
-      timer,
-      ttlMs
-    });
-  };
-  const acquireLock = async (threadId, ttlMs) => {
-    const lock = await base.acquireLock(threadId, ttlMs);
-    if (lock && shouldHeartbeatLock(ttlMs)) {
-      startOrUpdateHeartbeat(lock, ttlMs);
-    }
-    return lock;
-  };
-  return {
-    appendToList: (key, value, options2) => base.appendToList(key, value, options2),
-    connect: () => base.connect(),
-    disconnect: async () => {
-      stopAllHeartbeats();
-      await base.disconnect();
-    },
-    subscribe: (threadId) => base.subscribe(threadId),
-    unsubscribe: (threadId) => base.unsubscribe(threadId),
-    isSubscribed: (threadId) => base.isSubscribed(threadId),
-    acquireLock,
-    releaseLock: async (lock) => {
-      stopHeartbeat(lock);
-      await base.releaseLock(lock);
-    },
-    extendLock: async (lock, ttlMs) => {
-      const extended = await base.extendLock(lock, ttlMs);
-      if (extended) {
-        lock.expiresAt = Date.now() + ttlMs;
-        if (shouldHeartbeatLock(ttlMs)) {
-          startOrUpdateHeartbeat(lock, ttlMs);
-        } else {
-          stopHeartbeat(lock);
-        }
-      } else {
-        stopHeartbeat(lock);
-      }
-      return extended;
-    },
-    forceReleaseLock: async (threadId) => {
-      stopHeartbeatsForThread(threadId);
-      await base.forceReleaseLock(threadId);
-    },
-    enqueue: (threadId, entry, maxSize) => base.enqueue(threadId, entry, maxSize),
-    dequeue: (threadId) => base.dequeue(threadId),
-    queueDepth: (threadId) => base.queueDepth(threadId),
-    get: (key) => base.get(key),
-    getList: (key) => base.getList(key),
-    set: (key, value, ttlMs) => base.set(key, value, ttlMs),
-    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
-    delete: (key) => base.delete(key)
-  };
-}
-function withOptionalPrefix(base, prefix) {
-  return prefix ? createPrefixedStateAdapter(base, prefix) : base;
-}
-function createStateAdapter() {
-  const config = getChatConfig();
-  const activeLockMaxAgeMs = config.bot.turnTimeoutMs + ACTIVE_LOCK_TTL_MS;
-  if (config.state.adapter === "memory") {
-    redisStateAdapter = void 0;
-    return createQueuedStateAdapter(
-      createConnectingStateAdapter(
-        withOptionalPrefix(createMemoryState(), config.state.keyPrefix)
-      ),
-      { activeLockMaxAgeMs }
-    );
-  }
-  if (!config.state.redisUrl) {
-    throw new Error("REDIS_URL is required for durable Slack thread state");
-  }
-  const redisState = createRedisState({
-    url: config.state.redisUrl
-  });
-  redisStateAdapter = redisState;
-  return createQueuedStateAdapter(
-    createConnectingStateAdapter(
-      withOptionalPrefix(redisState, config.state.keyPrefix)
-    ),
-    { activeLockMaxAgeMs }
-  );
-}
-function getOptionalRedisStateAdapter() {
-  getStateAdapter();
-  return redisStateAdapter;
-}
-async function getConnectedStateContext() {
-  const adapter = getStateAdapter();
-  await adapter.connect();
-  return {
-    redisStateAdapter: getOptionalRedisStateAdapter(),
-    stateAdapter: adapter
-  };
-}
-async function getDefaultRedisStateAdapterFor(adapter) {
-  if (adapter !== stateAdapter) {
-    return void 0;
-  }
-  const context = await getConnectedStateContext();
-  return context.stateAdapter === adapter ? context.redisStateAdapter : void 0;
-}
-function getStateAdapter() {
-  if (!stateAdapter) {
-    stateAdapter = createStateAdapter();
-  }
-  return stateAdapter;
-}
-async function disconnectStateAdapter() {
-  if (!stateAdapter) {
-    return;
-  }
-  try {
-    await stateAdapter.disconnect();
-  } finally {
-    stateAdapter = void 0;
-    redisStateAdapter = void 0;
-  }
-}
-
-export {
-  MUTATION_LOCK_TTL_MS,
-  acquireActiveLock,
-  withLock,
-  fenceLock,
-  withActiveLock,
-  getDefaultRedisStateAdapterFor,
-  getStateAdapter,
-  disconnectStateAdapter
-};