@sentry/junior 0.106.0 → 0.107.0

package/dist/{chunk-AZ5OMSN5.js → chunk-AUUOHQAT.js}

@@ -1,11 +1,11 @@
 import {
   getStateAdapter
-} from "./chunk-4UYIRWDW.js";
+} from "./chunk-B2Z2H66D.js";
 import {
   logException,
   logInfo,
   logWarn
-} from "./chunk-AEWZ7F65.js";
+} from "./chunk-O24R4DCK.js";
 
 // src/chat/plugins/logging.ts
 function createPluginLogger(plugin) {

package/dist/chunk-B2Z2H66D.js

@@ -0,0 +1,250 @@
+import {
+  getChatConfig
+} from "./chunk-SS67LUOK.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
+};

package/dist/{chunk-4W4O4DCV.js → chunk-CQ7KSO2B.js}

@@ -7,48 +7,42 @@ import {
   clearPendingAuth,
   getInterruptionMarker,
   getPersistedThreadState,
+  hydrateConversationMessages,
+  markConversationMessage,
   markTurnCompleted,
-  mergeArtifactsState
-} from "./chunk-BKM4UXUD.js";
-import {
-  coerceThreadConversationState
-} from "./chunk-XIMUQ4IU.js";
+  mergeArtifactsState,
+  updateConversationStats
+} from "./chunk-YFQ7CQDE.js";
 import {
+  coerceThreadConversationState,
   getAgentTurnSessionRecord
-} from "./chunk-DDRQ4U7I.js";
-import {
-  generateConversationId,
-  hydrateConversationMessages,
-  markConversationMessage,
-  normalizeConversationText,
-  updateConversationStats,
-  upsertConversationMessage
-} from "./chunk-P4P7O5WG.js";
+} from "./chunk-4YF7Z6IA.js";
 import {
   createPluginEmbedder,
   createPluginModel,
   getPlugins
-} from "./chunk-ZMRLBBD5.js";
+} from "./chunk-RMVOAJRL.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-AZ5OMSN5.js";
+} from "./chunk-AUUOHQAT.js";
+import {
+  getStateAdapter
+} from "./chunk-B2Z2H66D.js";
 import {
   getDb
-} from "./chunk-XTKJPSMF.js";
+} from "./chunk-NVOTGWYX.js";
 import {
-  botConfig,
   getPiMessageRole,
-  getStateAdapter,
   instructionTextForProjection,
   isToolResultError,
   isToolResultMessage,
   normalizeToolNameFromResult,
   stripRuntimeTurnContext
-} from "./chunk-4UYIRWDW.js";
+} from "./chunk-SS67LUOK.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-AEWZ7F65.js";
+} from "./chunk-O24R4DCK.js";
 import {
   parseSlackMessageTs
 } from "./chunk-7FBGKXPE.js";
@@ -111,9 +105,9 @@ function getAgentTurnDiagnosticsAttributes(reply) {
     ...reply.diagnostics.errorMessage ? { "exception.message": reply.diagnostics.errorMessage } : {}
   };
 }
-function finalizeFailedTurnReply(args) {
+function finalizeFailedTurnReplyWithEvent(args) {
   if (args.reply.diagnostics.outcome === "success") {
-    return args.reply;
+    return { reply: args.reply };
   }
   const capture = getFailureCapture(args.reply);
   const eventId = requireTurnFailureEventId(
@@ -132,16 +126,66 @@ function finalizeFailedTurnReply(args) {
   );
   const providerPartialText = args.reply.diagnostics.outcome === "provider_error" && args.reply.diagnostics.assistantMessageCount > 0 ? args.reply.text.trim() : "";
   return {
-    ...args.reply,
-    text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : buildTurnFailureResponse(eventId),
-    deliveryMode: "thread",
-    deliveryPlan: {
-      mode: "thread",
-      postThreadText: true
+    eventId,
+    reply: {
+      ...args.reply,
+      text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : buildTurnFailureResponse(eventId)
     }
   };
 }
 
+// src/chat/conversations/turn-lifecycle.ts
+var ConversationTurnLifecycleService = class {
+  constructor(events) {
+    this.events = events;
+  }
+  events;
+  /** Record the turn start once after every input message is durable. */
+  async start(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:started`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_started",
+          turnId: input.turnId,
+          inputMessageIds: input.inputMessageIds,
+          surface: input.surface
+        }
+      }
+    ]);
+  }
+  /** Record successful or intentional-silence completion once. */
+  async complete(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:terminal`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_completed",
+          turnId: input.turnId,
+          outcome: input.outcome
+        }
+      }
+    ]);
+  }
+  /** Record a classified failure once without accepting raw error details. */
+  async fail(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:terminal`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_failed",
+          turnId: input.turnId,
+          failureCode: input.failureCode,
+          ...input.eventId ? { eventId: input.eventId } : {}
+        }
+      }
+    ]);
+  }
+};
+
 // src/chat/plugins/task-runner.ts
 import {
   isPrivateSource,
@@ -453,7 +497,6 @@ async function processPluginTask(message, options = {}) {
 }
 
 // src/chat/runtime/delivered-turn-state.ts
-var NO_VISIBLE_REPLY_CONVERSATION_TEXT = "[no visible reply]";
 function buildDeliveredTurnStatePatch(args) {
   const conversation = structuredClone(args.conversation);
   const artifactStatePatch = {
@@ -462,24 +505,10 @@ function buildDeliveredTurnStatePatch(args) {
   };
   const artifacts = Object.keys(artifactStatePatch).length > 0 ? mergeArtifactsState(args.artifacts, artifactStatePatch) : void 0;
   clearPendingAuth(conversation, args.sessionId);
-  const assistantText = normalizeConversationText(args.reply.text) || (args.reply.deliveryPlan?.postThreadText === false ? NO_VISIBLE_REPLY_CONVERSATION_TEXT : "[empty response]");
   markConversationMessage(conversation, args.userMessageId, {
     replied: true,
     skippedReason: void 0
   });
-  upsertConversationMessage(conversation, {
-    id: generateConversationId("assistant"),
-    role: "assistant",
-    text: assistantText,
-    createdAtMs: Date.now(),
-    author: {
-      userName: botConfig.userName,
-      isBot: true
-    },
-    meta: {
-      replied: true
-    }
-  });
   markTurnCompleted({
     conversation,
     nowMs: Date.now(),
@@ -497,7 +526,8 @@ function buildDeliveredTurnStatePatch(args) {
 export {
   requireTurnFailureEventId,
   getAgentTurnDiagnosticsAttributes,
-  finalizeFailedTurnReply,
+  finalizeFailedTurnReplyWithEvent,
+  ConversationTurnLifecycleService,
   scheduleSessionCompletedPluginTasks,
   processPluginTask,
   buildDeliveredTurnStatePatch

package/dist/{chunk-MJSJAHBW.js → chunk-DY7TRYB5.js}

@@ -1,6 +1,6 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-77LHNQK4.js";
+} from "./chunk-YIPD3L6L.js";
 
 // src/chat/plugins/validation.ts
 import { isDeepStrictEqual } from "util";