@sentry/junior 0.93.0 → 0.95.0

package/dist/chat/state/conversation-details.d.ts

@@ -1,47 +0,0 @@
-import { type StoredSlackActor } from "@/chat/actor";
-import type { AgentTurnSurface } from "./turn-session";
-export interface ConversationDetailsRecord {
-    conversationId: string;
-    /** Generated display title from the LLM. Absent until title has been produced. */
-    displayTitle?: string;
-    /** The message id used as input when generating the title. */
-    titleSourceMessageId?: string;
-    /** Slack channel name or equivalent location label. */
-    channelName?: string;
-    /** Surface on which the conversation was started. */
-    originSurface?: AgentTurnSurface;
-    /** Actor who initiated the conversation (first turn). */
-    originActor?: StoredSlackActor;
-    /** Timestamp of the first turn in the conversation. */
-    startedAtMs?: number;
-}
-/**
- * Record the origin context for a conversation the first time it is seen and
- * refresh the context TTL on later turns without changing the stored origin.
- */
-export declare function initConversationContext(conversationId: string, context: {
-    channelName?: string;
-    originSurface?: AgentTurnSurface;
-    originActor?: StoredSlackActor;
-    startedAtMs: number;
-}): Promise<void>;
-/**
- * Persist or refresh the LLM-generated title for a conversation.
- *
- * Plain set — no read, no lock.
- */
-export declare function setConversationTitle(conversationId: string, title: {
-    displayTitle: string;
-    titleSourceMessageId?: string;
-}): Promise<void>;
-/**
- * Read conversation details for a single conversation.
- * Assembles the context and title records in parallel.
- * Returns undefined only when neither context nor title details exist yet.
- */
-export declare function getConversationDetails(conversationId: string): Promise<ConversationDetailsRecord | undefined>;
-/**
- * Bulk-fetch conversation details for a set of conversation ids in parallel.
- * Returns a map from conversationId → record (omits ids with no details).
- */
-export declare function getConversationDetailsForIds(conversationIds: Iterable<string>): Promise<Map<string, ConversationDetailsRecord>>;

package/dist/chunk-7STN2ZSK.js

@@ -1,250 +0,0 @@
-import {
-  getChatConfig
-} from "./chunk-NAPITCZ6.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
-var ACTIVE_LOCK_TTL_MS = 9e4;
-async function acquireActiveLock(state, threadId) {
-  return await state.acquireLock(threadId, ACTIVE_LOCK_TTL_MS);
-}
-
-// src/chat/state/adapter.ts
-var ACTIVE_LOCK_HEARTBEAT_MS = 3e4;
-var stateAdapter;
-var redisStateAdapter;
-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(
-      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(
-    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 {
-  acquireActiveLock,
-  getConnectedStateContext,
-  getDefaultRedisStateAdapterFor,
-  getStateAdapter,
-  disconnectStateAdapter
-};