@sentry/junior 0.202.0 → 0.204.0

package/dist/chunk-6AYH6252.js

@@ -1,787 +0,0 @@
-import {
-  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
-  CONVERSATION_WORK_MAX_RETRIES,
-  ackMessages,
-  beginConversationResume,
-  checkInConversationWork,
-  clearConsumedConversationWake,
-  completeConversationStop,
-  completeConversationWork,
-  countPendingConversationMessages,
-  deadLetterAttempt,
-  drainConversationMailbox,
-  ensureConversationWake,
-  getConversationWorkState,
-  isFinalAttempt,
-  isInvalidConversationRecordError,
-  recordAttemptFailure,
-  recordConversationRetry,
-  releaseConversationWork,
-  requestAnotherSlice,
-  startConversationWork
-} from "./chunk-OWMPFXJA.js";
-import {
-  getTurnRequestDeadline
-} from "./chunk-BD2KT3OB.js";
-import {
-  ConversationQueueMessageRejectedError
-} from "./chunk-JAL3CH4G.js";
-import {
-  getChatConfig,
-  isProviderRetryError
-} from "./chunk-63NKKFJL.js";
-import {
-  logException,
-  logInfo,
-  logWarn,
-  withLogContext
-} from "./chunk-MAGNK5J4.js";
-
-// src/chat/task-execution/worker.ts
-var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
-var CONVERSATION_STOP_CHECK_INTERVAL_MS = 500;
-function now(options) {
-  return options.nowMs?.() ?? Date.now();
-}
-function selectContiguousTurnBatch(messages) {
-  const first = messages[0];
-  if (!first) {
-    return [];
-  }
-  const nextTurnIndex = messages.findIndex(
-    (message) => message.input.authorId !== first.input.authorId || message.source !== first.source
-  );
-  return messages.slice(
-    0,
-    nextTurnIndex === -1 ? messages.length : nextTurnIndex
-  );
-}
-function selectAttemptMessages(work) {
-  const messages = work.messages;
-  const interrupts = messages.filter(
-    (message) => message.delivery === "interrupt"
-  );
-  if (interrupts.length > 0) {
-    return selectContiguousTurnBatch(interrupts);
-  }
-  return work.execution.status === "paused" ? [] : selectContiguousTurnBatch(messages);
-}
-function nudgeIdempotencyKey(reason, conversationId, nowMs) {
-  return `${reason}:${conversationId}:${nowMs}`;
-}
-async function requestLostLeaseRecovery(args) {
-  const before = await getConversationWorkState({
-    conversationId: args.conversationId,
-    state: args.options.state
-  });
-  const retry = await recordConversationRetry({
-    conversationId: args.conversationId,
-    leaseToken: args.leaseToken,
-    conversationStore: args.options.conversationStore,
-    nowMs: args.nowMs,
-    state: args.options.state
-  });
-  if (retry === "lost_lease") {
-    return;
-  }
-  if (retry === "stopped") {
-    logException(
-      new Error("Conversation work stopped after repeated failed attempts"),
-      "conversation.work.retry.exhausted",
-      {
-        "app.run.id": before?.execution.runId ?? "unknown",
-        "app.worker.last_progress_at_ms": before?.execution.lastProgressAtMs ?? before?.createdAtMs ?? 0,
-        "app.worker.retry_count": (before?.execution.retryCount ?? 0) + 1
-      }
-    );
-    return;
-  }
-  const sliceRequested = await requestAnotherSlice({
-    conversationId: args.conversationId,
-    destination: args.destination,
-    leaseToken: args.leaseToken,
-    conversationStore: args.options.conversationStore,
-    nowMs: args.nowMs,
-    state: args.options.state
-  });
-  if (!sliceRequested) {
-    return;
-  }
-  const released = await releaseConversationWork({
-    conversationId: args.conversationId,
-    leaseToken: args.leaseToken,
-    conversationStore: args.options.conversationStore,
-    nowMs: args.nowMs,
-    state: args.options.state
-  });
-  if (!released) {
-    return;
-  }
-  await ensureConversationWake({
-    conversationId: args.conversationId,
-    conversationStore: args.options.conversationStore,
-    idempotencyKey: nudgeIdempotencyKey(
-      "lost_lease",
-      args.conversationId,
-      args.nowMs
-    ),
-    nowMs: args.nowMs,
-    queue: args.options.queue,
-    replaceExistingWake: true,
-    state: args.options.state
-  });
-}
-async function recordFailedDeliveryAttempt(args) {
-  const failure = await recordAttemptFailure({
-    conversationId: args.conversationId,
-    inboundMessageIds: args.messageIds,
-    leaseToken: args.leaseToken,
-    conversationStore: args.options.conversationStore,
-    nowMs: args.nowMs,
-    state: args.options.state
-  });
-  for (const message of failure.deadLetteredMessages) {
-    logWarn("conversation.work.dead_lettered", {
-      "app.conversation.source": message.source,
-      "app.inbound.attempt_count": message.attemptCount ?? 0,
-      "app.inbound.message_id": message.inboundMessageId,
-      "app.inbound.pending_count": failure.pendingCount
-    });
-  }
-  return failure;
-}
-function isTerminalFailure(failure) {
-  return failure.status === "recorded" && failure.deadLetteredMessages.length > 0 && failure.pendingCount === 0;
-}
-function logRetryExhausted(args) {
-  logException(args.error, "conversation.work.retry.exhausted", {
-    "app.run.id": args.work.execution.runId ?? "unknown",
-    "app.worker.last_progress_at_ms": args.work.execution.lastProgressAtMs ?? args.work.createdAtMs,
-    "app.worker.retry_count": args.retryCount
-  });
-}
-function startLeaseCheckIn(args) {
-  const timer = setInterval(() => {
-    const nowMs = now(args.options);
-    void checkInConversationWork({
-      conversationId: args.conversationId,
-      leaseToken: args.leaseToken,
-      conversationStore: args.options.conversationStore,
-      nowMs,
-      state: args.options.state
-    }).then(
-      (checkedIn) => {
-        if (!checkedIn) {
-          args.onLostLease();
-          logWarn("conversation.work.check_in.failed");
-        }
-      },
-      (error) => {
-        logException(error, "conversation.work.check_in.failed");
-      }
-    );
-  }, args.options.checkInIntervalMs ?? CONVERSATION_WORK_CHECK_IN_INTERVAL_MS);
-  timer.unref?.();
-  return timer;
-}
-function createConversationStopSignal(args) {
-  const controller = new AbortController();
-  let checking = false;
-  let failureCaptured = false;
-  let listening = false;
-  let timer;
-  const requestStop = () => {
-    if (!controller.signal.aborted) {
-      controller.abort(new Error("Conversation work stopped"));
-    }
-  };
-  if (args.initialStopRunId === args.runId) {
-    requestStop();
-  }
-  const check = async () => {
-    if (checking || controller.signal.aborted) return;
-    checking = true;
-    try {
-      const current = await getConversationWorkState({
-        conversationId: args.conversationId,
-        state: args.options.state
-      });
-      if (current?.execution.stop?.runId === args.runId) {
-        requestStop();
-      }
-    } catch (error) {
-      if (!failureCaptured) {
-        failureCaptured = true;
-        logException(error, "conversation.work.stop_check.failed");
-      }
-    } finally {
-      checking = false;
-    }
-  };
-  return {
-    close() {
-      if (timer) clearInterval(timer);
-    },
-    isEnabled() {
-      return listening;
-    },
-    wasObserved() {
-      return listening && controller.signal.aborted;
-    },
-    signal() {
-      listening = true;
-      if (!timer && !controller.signal.aborted) {
-        timer = setInterval(
-          () => void check(),
-          CONVERSATION_STOP_CHECK_INTERVAL_MS
-        );
-        timer.unref?.();
-      }
-      return controller.signal;
-    }
-  };
-}
-async function processConversationWork(message, options) {
-  return withLogContext(
-    { conversationId: message.conversationId },
-    () => processConversationWorkInContext(message, options)
-  );
-}
-async function processConversationWorkInContext(message, options) {
-  const conversationId = message.conversationId;
-  let initial;
-  try {
-    initial = await getConversationWorkState({
-      conversationId,
-      state: options.state
-    });
-  } catch (error) {
-    if (isInvalidConversationRecordError(error)) {
-      throw new ConversationQueueMessageRejectedError(
-        "invalid_record",
-        `Conversation record failed validation for ${conversationId}`,
-        { conversationId }
-      );
-    }
-    throw error;
-  }
-  if (!initial || countPendingConversationMessages(initial) === 0 && initial.execution.status === "idle" && !initial.execution.lease) {
-    if (initial) {
-      await clearConsumedConversationWake({
-        conversationId,
-        conversationStore: options.conversationStore,
-        nowMs: now(options),
-        state: options.state
-      });
-    }
-    return { status: "no_work" };
-  }
-  let destination = initial.destination;
-  if (!destination && options.conversationStore) {
-    const stored = await options.conversationStore.get({ conversationId });
-    if (stored && !stored.parentConversationId) {
-      destination = stored.destination;
-    }
-  }
-  const lease = await startConversationWork({
-    conversationId,
-    conversationStore: options.conversationStore,
-    nowMs: now(options),
-    state: options.state
-  });
-  if (lease.status === "no_work") {
-    await clearConsumedConversationWake({
-      conversationId,
-      conversationStore: options.conversationStore,
-      nowMs: now(options),
-      state: options.state
-    });
-    return { status: "no_work" };
-  }
-  if (lease.status === "active") {
-    const nudgeNowMs = now(options);
-    await ensureConversationWake({
-      conversationId,
-      conversationStore: options.conversationStore,
-      delayMs: CONVERSATION_WORK_DEFER_DELAY_MS,
-      idempotencyKey: nudgeIdempotencyKey("active", conversationId, nudgeNowMs),
-      nowMs: nudgeNowMs,
-      queue: options.queue,
-      replaceExistingWake: true,
-      state: options.state
-    });
-    logInfo("conversation.work.nudge.deferred", {
-      "app.lease.expires_at_ms": lease.leaseExpiresAtMs
-    });
-    return { status: "active" };
-  }
-  const startedAtMs = now(options);
-  const softYieldDeadlineMs = startedAtMs + (options.softYieldAfterMs ?? getChatConfig().conversationWorkSoftYieldAfterMs);
-  let attemptMessageIds = [];
-  let attemptSelectedMessageIds = /* @__PURE__ */ new Set();
-  let attemptStartMessageIds = /* @__PURE__ */ new Set();
-  let failedWithoutProgress = false;
-  let leaseLost = false;
-  const markLeaseLost = () => {
-    leaseLost = true;
-  };
-  const timer = startLeaseCheckIn({
-    conversationId,
-    leaseToken: lease.leaseToken,
-    onLostLease: markLeaseLost,
-    options
-  });
-  logInfo("conversation.work.lease.acquired", {
-    "app.lease.expires_at_ms": lease.leaseExpiresAtMs,
-    "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
-  });
-  const drain = (handle) => drainConversationMailbox({
-    conversationId,
-    leaseToken: lease.leaseToken,
-    conversationStore: options.conversationStore,
-    handle: async (messages) => {
-      const candidates = messages.filter(
-        (message2) => message2.delivery === "interrupt" && (attemptSelectedMessageIds.has(message2.inboundMessageId) || !attemptStartMessageIds.has(message2.inboundMessageId))
-      );
-      if (candidates.length === 0) {
-        return [];
-      }
-      return await handle(candidates) ?? candidates.map((message2) => message2.inboundMessageId);
-    },
-    nowMs: now(options),
-    state: options.state
-  });
-  const requestDeadlineAtMs = getTurnRequestDeadline()?.deadlineAtMs;
-  const shouldYield = () => (
-    // Lease ownership is no longer confirmed, so this worker must stop.
-    leaseLost || // The worker soft limit reserves time to persist state and release the lease.
-    now(options) >= softYieldDeadlineMs || // Nested work can inherit an older host request deadline. Stop after that
-    // absolute deadline, even if this worker acquired its lease later.
-    requestDeadlineAtMs !== void 0 && Date.now() >= requestDeadlineAtMs
-  );
-  const checkIn = async () => {
-    const checkedIn = await checkInConversationWork({
-      conversationId,
-      leaseToken: lease.leaseToken,
-      conversationStore: options.conversationStore,
-      nowMs: now(options),
-      state: options.state
-    });
-    if (!checkedIn) {
-      markLeaseLost();
-    }
-    return checkedIn;
-  };
-  const yieldWork = async () => {
-    const yieldNowMs = now(options);
-    await ensureConversationWake({
-      conversationId,
-      conversationStore: options.conversationStore,
-      idempotencyKey: nudgeIdempotencyKey("yield", conversationId, yieldNowMs),
-      nowMs: yieldNowMs,
-      queue: options.queue,
-      replaceExistingWake: true,
-      state: options.state
-    });
-    const released = await releaseConversationWork({
-      conversationId,
-      leaseToken: lease.leaseToken,
-      conversationStore: options.conversationStore,
-      nowMs: yieldNowMs,
-      state: options.state
-    });
-    if (!released) {
-      return { status: "lost_lease" };
-    }
-    logInfo("conversation.work.yielded", {
-      "app.worker.elapsed_ms": now(options) - startedAtMs,
-      "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
-    });
-    return { status: "yielded" };
-  };
-  try {
-    let hasRun = false;
-    let resumeIfStopped = false;
-    while (true) {
-      attemptMessageIds = [];
-      const leasedWork = await getConversationWorkState({
-        conversationId,
-        state: options.state
-      });
-      if (!leasedWork || leasedWork.lease?.leaseToken !== lease.leaseToken || leaseLost) {
-        markLeaseLost();
-        await requestLostLeaseRecovery({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          options
-        });
-        return { status: "lost_lease" };
-      }
-      const resumePending = leasedWork.execution.status === "paused";
-      const attemptMessages = selectAttemptMessages(leasedWork);
-      const runId = leasedWork.execution.runId;
-      if (!runId) {
-        throw new Error(`Conversation run is missing for ${conversationId}`);
-      }
-      attemptStartMessageIds = new Set(
-        leasedWork.messages.map((message2) => message2.inboundMessageId)
-      );
-      if (hasRun && shouldYield()) {
-        if (resumePending) {
-          return await yieldWork();
-        }
-        break;
-      }
-      if (resumePending && attemptMessages.length === 0) {
-        const resumeStarted = await beginConversationResume({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: now(options),
-          state: options.state
-        });
-        if (!resumeStarted) {
-          markLeaseLost();
-          await requestLostLeaseRecovery({
-            conversationId,
-            destination,
-            leaseToken: lease.leaseToken,
-            nowMs: now(options),
-            options
-          });
-          return { status: "lost_lease" };
-        }
-      }
-      attemptMessageIds = attemptMessages.map(
-        (message2) => message2.inboundMessageId
-      );
-      attemptSelectedMessageIds = new Set(attemptMessageIds);
-      const ack = async () => {
-        const acknowledged = await ackMessages({
-          conversationId,
-          inboundMessageIds: attemptMessageIds,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: now(options),
-          state: options.state
-        });
-        if (!acknowledged) {
-          markLeaseLost();
-          throw new Error(
-            `Conversation work lease lost before inbox ack for ${conversationId}`
-          );
-        }
-      };
-      const stop = createConversationStopSignal({
-        conversationId,
-        initialStopRunId: leasedWork.execution.stop?.runId,
-        options,
-        runId
-      });
-      const workerContext = {
-        attempt: {
-          ack,
-          conversationId,
-          destination,
-          drain,
-          isFinalAttempt: attemptMessages.some(
-            (message2) => isFinalAttempt(message2)
-          ),
-          messages: attemptMessages
-        },
-        conversationId,
-        destination,
-        shouldYield,
-        stopSignal: stop.signal,
-        checkIn
-      };
-      let result;
-      try {
-        result = await options.run(workerContext);
-      } finally {
-        stop.close();
-      }
-      resumeIfStopped ||= stop.isEnabled();
-      hasRun = true;
-      if (result.status === "lost_lease") {
-        await requestLostLeaseRecovery({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          options
-        });
-        return { status: "lost_lease" };
-      }
-      if (leaseLost) {
-        await requestLostLeaseRecovery({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          options
-        });
-        return { status: "lost_lease" };
-      }
-      if (result.status === "completed" && stop.wasObserved()) {
-        const stopped = await completeConversationStop({
-          conversationId,
-          conversationStore: options.conversationStore,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          runId,
-          state: options.state
-        });
-        if (stopped.status === "lost_lease") {
-          markLeaseLost();
-          await requestLostLeaseRecovery({
-            conversationId,
-            destination,
-            leaseToken: lease.leaseToken,
-            nowMs: now(options),
-            options
-          });
-          return { status: "lost_lease" };
-        }
-      }
-      if (result.status === "yielded") {
-        const sliceRequested = await requestAnotherSlice({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: now(options),
-          state: options.state
-        });
-        if (!sliceRequested) {
-          return { status: "lost_lease" };
-        }
-        return await yieldWork();
-      }
-      if (result.status === "deferred") {
-        const deferredNowMs = now(options);
-        const released = await releaseConversationWork({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: deferredNowMs,
-          state: options.state
-        });
-        if (!released) {
-          return { status: "lost_lease" };
-        }
-        const wake = await ensureConversationWake({
-          conversationId,
-          conversationStore: options.conversationStore,
-          idempotencyKey: nudgeIdempotencyKey(
-            "deferred",
-            conversationId,
-            deferredNowMs
-          ),
-          nowMs: deferredNowMs,
-          queue: options.queue,
-          state: options.state
-        });
-        return wake.status === "enqueued" ? { status: "pending_requeued" } : { status: "completed" };
-      }
-      if (attemptMessageIds.length > 0) {
-        const failure = await recordFailedDeliveryAttempt({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          messageIds: attemptMessageIds,
-          options
-        });
-        if (isTerminalFailure(failure)) {
-          if (failure.retryCount >= CONVERSATION_WORK_MAX_RETRIES) {
-            logRetryExhausted({
-              error: new Error(
-                "Conversation work stopped after repeated failed attempts"
-              ),
-              retryCount: failure.retryCount,
-              work: leasedWork
-            });
-          }
-          await deadLetterAttempt({
-            conversationId,
-            leaseToken: lease.leaseToken,
-            conversationStore: options.conversationStore,
-            nowMs: now(options),
-            state: options.state
-          });
-          return { status: "failed" };
-        }
-        if (failure.status === "lost_lease") {
-          return { status: "lost_lease" };
-        }
-        if (failure.status === "recorded") {
-          failedWithoutProgress = true;
-          break;
-        }
-      }
-      if (result.status === "paused") {
-        break;
-      }
-      const next = await getConversationWorkState({
-        conversationId,
-        state: options.state
-      });
-      if (!next || next.lease?.leaseToken !== lease.leaseToken) {
-        return { status: "lost_lease" };
-      }
-      if (next.execution.status !== "paused" && countPendingConversationMessages(next) === 0) {
-        break;
-      }
-    }
-    const completion = await completeConversationWork({
-      conversationId,
-      leaseToken: lease.leaseToken,
-      madeProgress: !failedWithoutProgress,
-      // A stop that raced an external pause must reach the paused Turn.
-      resumeIfStopped,
-      conversationStore: options.conversationStore,
-      nowMs: now(options),
-      state: options.state
-    });
-    if (completion === "lost_lease") {
-      return { status: "lost_lease" };
-    }
-    if (completion === "pending") {
-      const nudgeNowMs = now(options);
-      const wake = await ensureConversationWake({
-        conversationId,
-        conversationStore: options.conversationStore,
-        idempotencyKey: nudgeIdempotencyKey(
-          "pending",
-          conversationId,
-          nudgeNowMs
-        ),
-        nowMs: nudgeNowMs,
-        queue: options.queue,
-        state: options.state
-      });
-      return wake.status === "enqueued" ? { status: "pending_requeued" } : { status: "completed" };
-    }
-    logInfo("conversation.work.completed", {
-      "app.worker.elapsed_ms": now(options) - startedAtMs
-    });
-    return { status: "completed" };
-  } catch (error) {
-    const errorNowMs = now(options);
-    let recoveryRecorded = false;
-    try {
-      const failure = attemptMessageIds.length > 0 ? await recordFailedDeliveryAttempt({
-        conversationId,
-        leaseToken: lease.leaseToken,
-        nowMs: errorNowMs,
-        messageIds: attemptMessageIds,
-        options
-      }) : void 0;
-      if (failure && isTerminalFailure(failure)) {
-        if (failure.retryCount >= CONVERSATION_WORK_MAX_RETRIES) {
-          logRetryExhausted({
-            error,
-            retryCount: failure.retryCount,
-            work: initial
-          });
-        }
-        await deadLetterAttempt({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: errorNowMs,
-          state: options.state
-        });
-      } else if (failure?.status === "recorded") {
-        await releaseConversationWork({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: errorNowMs,
-          state: options.state
-        });
-        await ensureConversationWake({
-          conversationId,
-          conversationStore: options.conversationStore,
-          idempotencyKey: nudgeIdempotencyKey(
-            "error",
-            conversationId,
-            errorNowMs
-          ),
-          nowMs: errorNowMs,
-          queue: options.queue,
-          replaceExistingWake: true,
-          state: options.state
-        });
-      } else {
-        const retry = failure ? failure.status : await recordConversationRetry({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: errorNowMs,
-          state: options.state
-        });
-        if (retry === "stopped") {
-          logException(error, "conversation.work.retry.exhausted", {
-            "app.run.id": initial.execution.runId ?? "unknown",
-            "app.worker.last_progress_at_ms": initial.execution.lastProgressAtMs ?? initial.createdAtMs,
-            "app.worker.retry_count": failure?.retryCount ?? (initial.execution.retryCount ?? 0) + 1
-          });
-          recoveryRecorded = true;
-          return { status: "failed" };
-        }
-        const sliceRequested = await requestAnotherSlice({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: errorNowMs,
-          state: options.state
-        });
-        if (sliceRequested) {
-          await ensureConversationWake({
-            conversationId,
-            conversationStore: options.conversationStore,
-            idempotencyKey: nudgeIdempotencyKey(
-              "error",
-              conversationId,
-              errorNowMs
-            ),
-            nowMs: errorNowMs,
-            queue: options.queue,
-            replaceExistingWake: true,
-            state: options.state
-          });
-        }
-        await releaseConversationWork({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: errorNowMs,
-          state: options.state
-        });
-      }
-      recoveryRecorded = true;
-    } catch (recoveryError) {
-      logException(recoveryError, "conversation.work.requeue.failed");
-    }
-    if (!isProviderRetryError(error)) {
-      logException(error, "conversation.work.failed", {
-        "app.worker.elapsed_ms": now(options) - startedAtMs
-      });
-    }
-    if (!recoveryRecorded) {
-      throw error;
-    }
-    return { status: "failed" };
-  } finally {
-    clearInterval(timer);
-  }
-}
-
-export {
-  CONVERSATION_WORK_DEFER_DELAY_MS,
-  processConversationWork
-};