@sentry/junior 0.137.0 → 0.138.0

package/dist/chunk-HIWJWWMT.js

@@ -0,0 +1,668 @@
+import {
+  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
+  CONVERSATION_WORK_MAX_RETRIES,
+  ackMessages,
+  beginConversationResume,
+  checkInConversationWork,
+  clearConsumedConversationWake,
+  completeConversationWork,
+  countPendingConversationMessages,
+  deadLetterAttempt,
+  drainConversationMailbox,
+  ensureConversationWake,
+  getConversationWorkState,
+  isFinalAttempt,
+  isInvalidConversationRecordError,
+  recordAttemptFailure,
+  recordConversationRetry,
+  releaseConversationWork,
+  requestConversationContinuation,
+  startConversationWork
+} from "./chunk-5LTJ4ITU.js";
+import {
+  ConversationQueueMessageRejectedError
+} from "./chunk-IUFM5JWV.js";
+import {
+  getChatConfig,
+  isProviderRetryError
+} from "./chunk-BYW4B4PR.js";
+import {
+  logException,
+  logInfo,
+  logWarn,
+  withLogContext
+} from "./chunk-JNNJZURV.js";
+
+// src/chat/task-execution/worker.ts
+var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
+function now(options) {
+  return options.nowMs?.() ?? Date.now();
+}
+function selectContiguousActorBatch(messages) {
+  const first = messages[0];
+  if (!first) {
+    return [];
+  }
+  const nextActorIndex = messages.findIndex(
+    (message) => message.input.authorId !== first.input.authorId
+  );
+  return messages.slice(
+    0,
+    nextActorIndex === -1 ? messages.length : nextActorIndex
+  );
+}
+function selectAttemptMessages(work) {
+  const messages = work.messages;
+  const interrupts = messages.filter(
+    (message) => message.delivery === "interrupt"
+  );
+  if (interrupts.length > 0) {
+    return selectContiguousActorBatch(interrupts);
+  }
+  return work.execution.status === "awaiting_resume" ? [] : selectContiguousActorBatch(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 resumeRequested = await requestConversationContinuation({
+    conversationId: args.conversationId,
+    destination: args.destination,
+    leaseToken: args.leaseToken,
+    conversationStore: args.options.conversationStore,
+    nowMs: args.nowMs,
+    state: args.options.state
+  });
+  if (!resumeRequested) {
+    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;
+}
+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" };
+  }
+  const destination = initial.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 shouldYield = () => leaseLost || now(options) >= softYieldDeadlineMs;
+  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;
+    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 === "awaiting_resume";
+      const attemptMessages = selectAttemptMessages(leasedWork);
+      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 workerContext = {
+        attempt: {
+          ack,
+          conversationId,
+          destination,
+          drain,
+          isFinalAttempt: attemptMessages.some(
+            (message2) => isFinalAttempt(message2)
+          ),
+          messages: attemptMessages
+        },
+        conversationId,
+        destination,
+        shouldYield,
+        checkIn
+      };
+      const result = await options.run(workerContext);
+      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 === "yielded") {
+        const resumeRequested = await requestConversationContinuation({
+          conversationId,
+          destination,
+          leaseToken: lease.leaseToken,
+          conversationStore: options.conversationStore,
+          nowMs: now(options),
+          state: options.state
+        });
+        if (!resumeRequested) {
+          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;
+        }
+      }
+      const next = await getConversationWorkState({
+        conversationId,
+        state: options.state
+      });
+      if (!next || next.lease?.leaseToken !== lease.leaseToken) {
+        return { status: "lost_lease" };
+      }
+      if (next.execution.status !== "awaiting_resume" && countPendingConversationMessages(next) === 0) {
+        break;
+      }
+    }
+    const completion = await completeConversationWork({
+      conversationId,
+      leaseToken: lease.leaseToken,
+      madeProgress: !failedWithoutProgress,
+      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 resumeRequested = await requestConversationContinuation({
+          conversationId,
+          destination,
+          leaseToken: lease.leaseToken,
+          conversationStore: options.conversationStore,
+          nowMs: errorNowMs,
+          state: options.state
+        });
+        if (resumeRequested) {
+          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
+};

package/dist/chunk-IUFM5JWV.js

@@ -0,0 +1,24 @@
+// src/chat/task-execution/queue.ts
+import { z } from "zod";
+var conversationQueueMessageSchema = z.object({
+  conversationId: z.string().trim().min(1)
+}).strict();
+var ConversationQueueMessageRejectedError = class extends Error {
+  conversationId;
+  reason;
+  constructor(reason, message, options = {}) {
+    super(message);
+    this.name = "ConversationQueueMessageRejectedError";
+    this.reason = reason;
+    this.conversationId = options.conversationId;
+  }
+};
+function isConversationQueueMessageRejectedError(error) {
+  return error instanceof ConversationQueueMessageRejectedError;
+}
+
+export {
+  conversationQueueMessageSchema,
+  ConversationQueueMessageRejectedError,
+  isConversationQueueMessageRejectedError
+};

package/dist/{chunk-T6Z5S6PQ.js → chunk-JNNJZURV.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-5PNJMOY5.js";
+} from "./chunk-KDCHVT25.js";
 
 // src/chat/logging.ts
 import path from "path";