@sentry/junior 0.203.0 → 0.204.0

package/dist/chunk-KIIEUXD3.js

@@ -1,1764 +0,0 @@
-import {
-  CONVERSATION_QUEUE_SCHEMA_VERSION
-} from "./chunk-JAL3CH4G.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-3Y47VMHV.js";
-import {
-  getConversationStore,
-  parseDestination,
-  sameDestination
-} from "./chunk-GKEOHJL5.js";
-import {
-  getDefaultRedisStateAdapterFor,
-  getStateAdapter
-} from "./chunk-P6KTRNVC.js";
-import {
-  getChatConfig
-} from "./chunk-ENY6SKIU.js";
-import {
-  parseStoredSlackActor
-} from "./chunk-N7TMSOZH.js";
-import {
-  isRecord,
-  toOptionalNumber,
-  toOptionalString
-} from "./chunk-WS7NAFTM.js";
-
-// src/chat/task-execution/state.ts
-import { randomUUID } from "crypto";
-import { destinationSchema } from "@sentry/junior-plugin-api";
-import { z } from "zod";
-var CONVERSATION_PREFIX = "junior:conversation:v2";
-var CONVERSATION_SCHEMA_VERSION = 2;
-var CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
-var CONVERSATION_INDEX_LOCK_TTL_MS = 1e4;
-var CONVERSATION_INDEX_LOCK_WAIT_MS = 2e3;
-var CONVERSATION_INDEX_LOCK_RETRY_MS = 25;
-var CONVERSATION_MUTATION_LOCK_TTL_MS = 1e4;
-var CONVERSATION_MUTATION_WAIT_MS = 1e4;
-var CONVERSATION_MUTATION_RETRY_MS = 25;
-var InvalidConversationRecordError = class extends Error {
-  constructor(conversationId) {
-    super(`Conversation record is invalid for ${conversationId}`);
-    this.name = "InvalidConversationRecordError";
-  }
-};
-function isInvalidConversationRecordError(error) {
-  return error instanceof InvalidConversationRecordError;
-}
-var ConversationMutationFencedError = class extends Error {
-  constructor(conversationId) {
-    super(
-      `Conversation mutation lock was lost before write for ${conversationId}`
-    );
-    this.name = "ConversationMutationFencedError";
-  }
-};
-var CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
-var CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
-var CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
-var CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
-var CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
-var CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS = 5;
-var CONVERSATION_WORK_MAX_RETRIES = 5;
-var inboundMessageSourceSchema = z.enum([
-  "api",
-  "internal",
-  "local",
-  "plugin",
-  "resource_event",
-  "scheduler",
-  "slack",
-  "web"
-]);
-var agentInputSchema = z.object({
-  attachments: z.array(z.unknown()).optional(),
-  authorId: z.string().min(1).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  text: z.string()
-}).strict().refine((input) => input.text.trim() || input.attachments?.length, {
-  message: "agent input requires text or attachments"
-});
-var inboundMessageDeliverySchema = z.enum(["defer", "interrupt"]);
-var inboundMessageSchema = z.object({
-  attemptCount: z.number().finite().optional(),
-  conversationId: z.string().refine((value) => value.trim().length > 0),
-  createdAtMs: z.number().finite(),
-  delivery: inboundMessageDeliverySchema,
-  destination: destinationSchema.optional(),
-  inboundMessageId: z.string().refine((value) => value.trim().length > 0),
-  injectedAtMs: z.number().finite().optional(),
-  input: agentInputSchema,
-  receivedAtMs: z.number().finite(),
-  source: inboundMessageSourceSchema
-}).strict();
-var storedInboundMessageSchema = inboundMessageSchema.extend({
-  publishExternally: z.boolean()
-});
-function conversationKey(conversationId) {
-  return `${CONVERSATION_PREFIX}:${conversationId}`;
-}
-function indexLockKey(indexKey) {
-  return `${indexKey}:lock`;
-}
-function mutationLockKey(conversationId) {
-  return `${CONVERSATION_PREFIX}:mutation:${conversationId}`;
-}
-function now() {
-  return Date.now();
-}
-function compareMessages(left, right) {
-  return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
-}
-function inputHasAttachments(input) {
-  return Array.isArray(input.attachments) && input.attachments.length > 0;
-}
-function upgradedPendingMessage(stored, duplicate) {
-  const promotesInterrupt = stored.delivery === "defer" && duplicate.delivery === "interrupt";
-  const delivery = promotesInterrupt ? "interrupt" : stored.delivery;
-  const input = promotesInterrupt ? {
-    ...duplicate.input,
-    ...inputHasAttachments(duplicate.input) || !inputHasAttachments(stored.input) ? void 0 : { attachments: stored.input.attachments }
-  } : inputHasAttachments(duplicate.input) && !inputHasAttachments(stored.input) ? duplicate.input : stored.input;
-  if (input === stored.input && delivery === stored.delivery) {
-    return stored;
-  }
-  return { ...stored, delivery, input };
-}
-function compareIndexDescending(left, right) {
-  return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
-}
-function compareIndexAscending(left, right) {
-  return left.score - right.score || left.conversationId.localeCompare(right.conversationId);
-}
-function uniqueStrings(values) {
-  return [...new Set(values)];
-}
-function normalizeSource(value) {
-  const parsed = inboundMessageSourceSchema.safeParse(value);
-  return parsed.success ? parsed.data : void 0;
-}
-function normalizeExecutionStatus(value) {
-  if (value === "paused") {
-    return value;
-  }
-  if (value === "failed" || value === "idle" || value === "pending" || value === "running") {
-    return value;
-  }
-  return void 0;
-}
-function normalizeMessage(value) {
-  const parsed = storedInboundMessageSchema.safeParse(value);
-  if (!parsed.success) {
-    return void 0;
-  }
-  const { publishExternally: _publishExternally, ...message } = parsed.data;
-  return message;
-}
-function storeMessage(message, publishExternally) {
-  return { ...message, publishExternally };
-}
-function isFinalAttempt(message) {
-  return (message.attemptCount ?? 0) >= CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS - 1;
-}
-function normalizeActor(value) {
-  return parseStoredSlackActor(value);
-}
-function normalizeLease(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const token = toOptionalString(value.token);
-  const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
-  const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
-  const expiresAtMs = toOptionalNumber(value.expiresAtMs);
-  if (!token || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof expiresAtMs !== "number") {
-    return void 0;
-  }
-  return {
-    token,
-    acquiredAtMs,
-    lastCheckInAtMs,
-    expiresAtMs
-  };
-}
-function normalizeStop(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(
-    value.inboundMessageIds.filter(
-      (id) => typeof id === "string"
-    )
-  ) : [];
-  const runId = toOptionalString(value.runId);
-  return runId ? { inboundMessageIds, runId } : void 0;
-}
-function normalizeExecution(conversationId, value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const status = normalizeExecutionStatus(value.status);
-  if (!status) {
-    return void 0;
-  }
-  const pendingMessages2 = [];
-  if (Array.isArray(value.pendingMessages)) {
-    for (const rawMessage of value.pendingMessages) {
-      const message = normalizeMessage(rawMessage);
-      if (!message || message.conversationId !== conversationId) {
-        return void 0;
-      }
-      if (message.injectedAtMs !== void 0) {
-        continue;
-      }
-      pendingMessages2.push(message);
-    }
-    pendingMessages2.sort(compareMessages);
-  }
-  const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(
-    value.inboundMessageIds.map((id) => typeof id === "string" ? id : void 0).filter((id) => Boolean(id))
-  ) : [];
-  const lease = normalizeLease(value.lease);
-  const runId = toOptionalString(value.runId);
-  const normalizedStop = normalizeStop(value.stop);
-  const stop = normalizedStop?.runId === runId ? normalizedStop : void 0;
-  const normalizedStatus = status === "idle" && lease ? "running" : status === "idle" && pendingMessages2.length > 0 ? "pending" : status;
-  return {
-    status: normalizedStatus,
-    inboundMessageIds: uniqueStrings([
-      ...inboundMessageIds,
-      ...pendingMessages2.map((message) => message.inboundMessageId)
-    ]),
-    pendingCount: pendingMessages2.length,
-    pendingMessages: pendingMessages2,
-    lease,
-    lastCheckpointAtMs: toOptionalNumber(value.lastCheckpointAtMs),
-    lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
-    lastProgressAtMs: toOptionalNumber(value.lastProgressAtMs),
-    retryCount: toOptionalNumber(value.retryCount),
-    runId,
-    stop,
-    updatedAtMs: toOptionalNumber(value.updatedAtMs)
-  };
-}
-function normalizeConversation(conversationId, value) {
-  if (!isRecord(value) || value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) {
-    return void 0;
-  }
-  const storedConversationId = toOptionalString(value.conversationId);
-  const createdAtMs = toOptionalNumber(value.createdAtMs);
-  const lastActivityAtMs = toOptionalNumber(value.lastActivityAtMs);
-  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
-  const execution = normalizeExecution(conversationId, value.execution);
-  const destination = value.destination === void 0 ? void 0 : parseDestination(value.destination);
-  if (storedConversationId !== conversationId || typeof createdAtMs !== "number" || typeof lastActivityAtMs !== "number" || typeof updatedAtMs !== "number" || !execution || value.destination !== void 0 && !destination) {
-    return void 0;
-  }
-  if (execution.pendingMessages.length > 0 && execution.pendingMessages.some((message) => {
-    if (!message.destination) {
-      return false;
-    }
-    return !destination || !sameDestination(message.destination, destination);
-  })) {
-    return void 0;
-  }
-  return {
-    schemaVersion: CONVERSATION_SCHEMA_VERSION,
-    conversationId,
-    createdAtMs,
-    lastActivityAtMs,
-    updatedAtMs,
-    execution,
-    ...destination ? { destination } : void 0,
-    ...toOptionalString(value.title) ? { title: toOptionalString(value.title) } : void 0,
-    ...toOptionalString(value.channelName) ? { channelName: toOptionalString(value.channelName) } : void 0,
-    ...normalizeActor(value.actor) ? { actor: normalizeActor(value.actor) } : void 0,
-    ...normalizeSource(value.source) ? { source: normalizeSource(value.source) } : void 0
-  };
-}
-function emptyConversation(args) {
-  return {
-    schemaVersion: CONVERSATION_SCHEMA_VERSION,
-    conversationId: args.conversationId,
-    createdAtMs: args.nowMs,
-    lastActivityAtMs: args.nowMs,
-    updatedAtMs: args.nowMs,
-    ...args.destination ? { destination: args.destination } : void 0,
-    ...args.source ? { source: args.source } : void 0,
-    execution: {
-      status: "idle",
-      inboundMessageIds: [],
-      pendingCount: 0,
-      pendingMessages: [],
-      updatedAtMs: args.nowMs
-    }
-  };
-}
-function isLeaseActive(lease, nowMs) {
-  return Boolean(lease && lease.expiresAtMs > nowMs);
-}
-function pendingMessages(conversation) {
-  return [...conversation.execution.pendingMessages].sort(compareMessages);
-}
-function isRunnableStatus(status) {
-  return status !== "failed" && status !== "idle";
-}
-function hasRunnableWork(conversation) {
-  return isRunnableStatus(conversation.execution.status) || pendingMessages(conversation).length > 0;
-}
-function executionWithPendingMessages(execution, pending) {
-  const pendingMessages2 = [...pending].sort(compareMessages);
-  const status = execution.status === "idle" && execution.lease ? "running" : execution.status === "idle" && pendingMessages2.length > 0 ? "pending" : execution.status;
-  return {
-    ...execution,
-    status,
-    inboundMessageIds: uniqueStrings([
-      ...execution.inboundMessageIds,
-      ...pendingMessages2.map((message) => message.inboundMessageId)
-    ]),
-    pendingMessages: pendingMessages2,
-    pendingCount: pendingMessages2.length
-  };
-}
-function withExecutionUpdate(conversation, execution, nowMs) {
-  return {
-    ...conversation,
-    updatedAtMs: nowMs,
-    execution: {
-      ...executionWithPendingMessages(execution, execution.pendingMessages),
-      updatedAtMs: nowMs
-    }
-  };
-}
-async function getConnectedState(stateAdapter) {
-  const state = stateAdapter ?? getStateAdapter();
-  await state.connect();
-  return state;
-}
-async function sleep(ms) {
-  await new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-  });
-}
-async function withIndexLock(state, indexKey, callback) {
-  const startedAtMs = now();
-  let lock;
-  while (true) {
-    lock = await state.acquireLock(
-      indexLockKey(indexKey),
-      CONVERSATION_INDEX_LOCK_TTL_MS
-    );
-    if (lock) {
-      break;
-    }
-    if (now() - startedAtMs >= CONVERSATION_INDEX_LOCK_WAIT_MS) {
-      throw new Error(
-        `Could not acquire conversation index lock for ${indexKey}`
-      );
-    }
-    await sleep(CONVERSATION_INDEX_LOCK_RETRY_MS);
-  }
-  try {
-    return await callback();
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-function normalizeIndexEntry(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const conversationId = toOptionalString(value.conversationId);
-  const score = toOptionalNumber(value.score);
-  if (!conversationId || typeof score !== "number") {
-    return void 0;
-  }
-  return { conversationId, score };
-}
-function uniqueIndexEntries(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const entries = /* @__PURE__ */ new Map();
-  for (const item of value) {
-    const entry = normalizeIndexEntry(item);
-    if (!entry) {
-      continue;
-    }
-    const existing = entries.get(entry.conversationId);
-    if (!existing || entry.score > existing.score) {
-      entries.set(entry.conversationId, entry);
-    }
-  }
-  return [...entries.values()];
-}
-function retainedIndexEntries(indexKey, entries) {
-  if (indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
-    return entries.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH);
-  }
-  if (indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
-    return entries.sort(compareIndexAscending);
-  }
-  throw new Error(`Unknown conversation index ${indexKey}`);
-}
-function redisIndexKey(indexKey) {
-  const prefix = getChatConfig().state.keyPrefix;
-  return [...prefix ? [prefix] : [], indexKey].join(":");
-}
-function parseRedisIndexEntries(values) {
-  if (!Array.isArray(values)) {
-    return [];
-  }
-  const entries = [];
-  for (let index = 0; index < values.length; index += 2) {
-    const conversationId = toOptionalString(values[index]);
-    const score = typeof values[index + 1] === "number" ? values[index + 1] : Number(values[index + 1]);
-    if (!conversationId || !Number.isFinite(score)) {
-      continue;
-    }
-    entries.push({ conversationId, score });
-  }
-  return entries;
-}
-function redisConversationIndexStore(client) {
-  const upsertBoundedActivityScript = `
-    redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
-    redis.call("PEXPIRE", KEYS[1], ARGV[3])
-    local extra = redis.call("ZCARD", KEYS[1]) - tonumber(ARGV[4])
-    if extra > 0 then
-      redis.call("ZREMRANGEBYRANK", KEYS[1], 0, extra - 1)
-    end
-    return 1
-  `;
-  return {
-    async list(args) {
-      const key = redisIndexKey(args.indexKey);
-      const limit = args.limit;
-      const offset = Math.max(0, args.offset ?? 0);
-      if (limit === 0) {
-        return [];
-      }
-      const values = args.scoreMax !== void 0 ? await client.sendCommand([
-        "ZRANGEBYSCORE",
-        key,
-        "-inf",
-        String(args.scoreMax),
-        "WITHSCORES",
-        ...limit !== void 0 || offset > 0 ? ["LIMIT", String(offset), String(limit ?? 1e9)] : []
-      ]) : await client.sendCommand([
-        args.order === "asc" ? "ZRANGE" : "ZREVRANGE",
-        key,
-        String(offset),
-        String(
-          limit === void 0 ? -1 : offset + Math.max(0, limit - 1)
-        ),
-        "WITHSCORES"
-      ]);
-      return parseRedisIndexEntries(values);
-    },
-    async remove(args) {
-      await client.sendCommand([
-        "ZREM",
-        redisIndexKey(args.indexKey),
-        args.conversationId
-      ]);
-    },
-    async upsert(args) {
-      const key = redisIndexKey(args.indexKey);
-      if (args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
-        await client.sendCommand([
-          "EVAL",
-          upsertBoundedActivityScript,
-          "1",
-          key,
-          String(args.score),
-          args.conversationId,
-          String(JUNIOR_THREAD_STATE_TTL_MS),
-          String(CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH)
-        ]);
-        return;
-      }
-      if (args.indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
-        await client.sendCommand([
-          "ZADD",
-          key,
-          String(args.score),
-          args.conversationId
-        ]);
-        await client.sendCommand([
-          "PEXPIRE",
-          key,
-          String(JUNIOR_THREAD_STATE_TTL_MS)
-        ]);
-        return;
-      }
-      throw new Error(`Unknown conversation index ${args.indexKey}`);
-    }
-  };
-}
-function emulatedConversationIndexStore(state) {
-  const readIndex = async (indexKey) => uniqueIndexEntries(await state.get(indexKey));
-  const writeIndex = async (indexKey, entries) => {
-    await state.set(indexKey, entries, JUNIOR_THREAD_STATE_TTL_MS);
-  };
-  return {
-    async list(args) {
-      const entries = (await readIndex(args.indexKey)).filter(
-        (entry) => args.scoreMax === void 0 ? true : entry.score <= args.scoreMax
-      ).sort(
-        args.order === "asc" ? compareIndexAscending : compareIndexDescending
-      );
-      const offset = Math.max(0, args.offset ?? 0);
-      return entries.slice(
-        offset,
-        args.limit === void 0 ? entries.length : offset + args.limit
-      );
-    },
-    async remove(args) {
-      await withIndexLock(state, args.indexKey, async () => {
-        const entries = await readIndex(args.indexKey);
-        const next = entries.filter(
-          (entry) => entry.conversationId !== args.conversationId
-        );
-        if (next.length === entries.length) {
-          return;
-        }
-        await writeIndex(args.indexKey, next);
-      });
-    },
-    async upsert(args) {
-      await withIndexLock(state, args.indexKey, async () => {
-        const entries = await readIndex(args.indexKey);
-        const withoutCurrent = entries.filter(
-          (entry) => entry.conversationId !== args.conversationId
-        );
-        const next = retainedIndexEntries(args.indexKey, [
-          ...withoutCurrent,
-          { conversationId: args.conversationId, score: args.score }
-        ]);
-        await writeIndex(args.indexKey, next);
-      });
-    }
-  };
-}
-async function getConversationIndexStore(state) {
-  const redisStateAdapter = await getDefaultRedisStateAdapterFor(state);
-  if (redisStateAdapter) {
-    return redisConversationIndexStore(redisStateAdapter.getClient());
-  }
-  return emulatedConversationIndexStore(state);
-}
-async function upsertIndexEntry(args) {
-  const index = await getConversationIndexStore(args.state);
-  await index.upsert({
-    conversationId: args.conversationId,
-    indexKey: args.indexKey,
-    score: args.score
-  });
-}
-async function removeIndexEntry(args) {
-  const index = await getConversationIndexStore(args.state);
-  await index.remove({
-    conversationId: args.conversationId,
-    indexKey: args.indexKey
-  });
-}
-async function acquireMutationLock(state, conversationId) {
-  const startedAtMs = now();
-  while (true) {
-    const lock = await state.acquireLock(
-      mutationLockKey(conversationId),
-      CONVERSATION_MUTATION_LOCK_TTL_MS
-    );
-    if (lock) {
-      return lock;
-    }
-    if (now() - startedAtMs >= CONVERSATION_MUTATION_WAIT_MS) {
-      throw new Error(
-        `Could not acquire conversation mutation lock for ${conversationId}`
-      );
-    }
-    await sleep(CONVERSATION_MUTATION_RETRY_MS);
-  }
-}
-async function withConversationMutation(args, callback) {
-  const state = await getConnectedState(args.state);
-  const lock = await acquireMutationLock(state, args.conversationId);
-  try {
-    return await callback(state, lock);
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function readConversation(state, conversationId) {
-  const raw = await state.get(conversationKey(conversationId));
-  if (raw == null) {
-    return void 0;
-  }
-  const conversation = normalizeConversation(conversationId, raw);
-  if (!conversation) {
-    throw new InvalidConversationRecordError(conversationId);
-  }
-  return conversation;
-}
-async function writeConversation(state, lock, conversation) {
-  const execution = executionWithPendingMessages(
-    conversation.execution,
-    conversation.execution.pendingMessages
-  );
-  const next = {
-    ...conversation,
-    execution
-  };
-  const fenced = await state.extendLock(
-    lock,
-    CONVERSATION_MUTATION_LOCK_TTL_MS
-  );
-  if (!fenced) {
-    throw new ConversationMutationFencedError(next.conversationId);
-  }
-  const hasSlackDestination = next.destination?.platform === "slack";
-  const stored = {
-    ...next,
-    execution: {
-      ...next.execution,
-      pendingMessages: next.execution.pendingMessages.map(
-        (message) => storeMessage(
-          message,
-          hasSlackDestination && (message.source === "slack" || message.source === "resource_event" || message.source === "plugin" || message.source === "scheduler")
-        )
-      )
-    }
-  };
-  await state.set(
-    conversationKey(next.conversationId),
-    stored,
-    JUNIOR_THREAD_STATE_TTL_MS
-  );
-  await upsertIndexEntry({
-    state,
-    indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
-    conversationId: next.conversationId,
-    score: next.lastActivityAtMs
-  });
-  if (!hasRunnableWork(next)) {
-    await removeIndexEntry({
-      state,
-      indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-      conversationId: next.conversationId
-    });
-    return;
-  }
-  await upsertIndexEntry({
-    state,
-    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-    conversationId: next.conversationId,
-    score: next.execution.updatedAtMs ?? next.updatedAtMs
-  });
-}
-function assertSameOptionalConversationDestination(args) {
-  if (!args.next || !args.current) {
-    return;
-  }
-  if (sameDestination(args.current, args.next)) {
-    return;
-  }
-  throw new Error(
-    `Conversation destination changed for ${args.conversationId}`
-  );
-}
-function conversationWorkState(conversation) {
-  const lease = conversation.execution.lease;
-  return {
-    ...conversation,
-    lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
-    ...lease ? {
-      lease: {
-        acquiredAtMs: lease.acquiredAtMs,
-        lastCheckInAtMs: lease.lastCheckInAtMs,
-        leaseExpiresAtMs: lease.expiresAtMs,
-        leaseToken: lease.token
-      }
-    } : void 0,
-    messages: pendingMessages(conversation),
-    needsRun: hasRunnableWork(conversation)
-  };
-}
-async function getConversation(args) {
-  const state = await getConnectedState(args.state);
-  return await readConversation(state, args.conversationId);
-}
-async function getConversationWorkState(args) {
-  const conversation = await getConversation(args);
-  return conversation ? conversationWorkState(conversation) : void 0;
-}
-function hasRunnableConversationWork(conversation) {
-  return hasRunnableWork(conversation);
-}
-async function appendInboundMessageWithAdmission(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(
-    { conversationId: args.message.conversationId, state: args.state },
-    async (state, lock) => {
-      const existing = await readConversation(
-        state,
-        args.message.conversationId
-      );
-      const current = existing ?? emptyConversation({
-        conversationId: args.message.conversationId,
-        destination: args.message.destination,
-        nowMs,
-        source: args.message.source
-      });
-      if (existing) {
-        assertSameOptionalConversationDestination({
-          conversationId: args.message.conversationId,
-          current: current.destination,
-          next: args.message.destination
-        });
-      }
-      const existingPending = current.execution.pendingMessages.some(
-        (message) => message.inboundMessageId === args.message.inboundMessageId
-      );
-      const existingMessage = current.execution.inboundMessageIds.includes(
-        args.message.inboundMessageId
-      );
-      if (existingMessage) {
-        if (!existingPending) {
-          return { status: "duplicate" };
-        }
-        const nextStatus = current.execution.status === "idle" ? "pending" : current.execution.status;
-        await writeConversation(
-          state,
-          lock,
-          withExecutionUpdate(
-            current,
-            {
-              ...current.execution,
-              status: nextStatus,
-              pendingMessages: current.execution.pendingMessages.map(
-                (message) => message.inboundMessageId === args.message.inboundMessageId ? upgradedPendingMessage(message, args.message) : message
-              )
-            },
-            nowMs
-          )
-        );
-        return { status: "duplicate" };
-      }
-      if (args.exclusive && hasRunnableWork(current)) {
-        return { status: "active" };
-      }
-      let status;
-      if (current.execution.lease) {
-        status = current.execution.status === "running" ? "running" : "paused";
-      } else if (current.execution.status === "paused" && args.message.delivery === "defer") {
-        status = "paused";
-      } else {
-        status = "pending";
-      }
-      const next = {
-        ...current,
-        destination: current.destination ?? args.message.destination,
-        source: current.source ?? args.message.source,
-        lastActivityAtMs: nowMs
-      };
-      await writeConversation(
-        state,
-        lock,
-        withExecutionUpdate(
-          next,
-          {
-            ...current.execution,
-            status,
-            inboundMessageIds: [
-              ...current.execution.inboundMessageIds,
-              args.message.inboundMessageId
-            ],
-            pendingMessages: [
-              ...current.execution.pendingMessages,
-              args.message
-            ].sort(compareMessages)
-          },
-          nowMs
-        )
-      );
-      return { status: "appended" };
-    }
-  );
-}
-async function appendInboundMessage(args) {
-  const result = await appendInboundMessageWithAdmission({
-    ...args,
-    exclusive: false
-  });
-  if (result.status === "active") {
-    throw new Error("Non-exclusive mailbox append returned active");
-  }
-  return result;
-}
-async function appendExclusiveInboundMessage(args) {
-  return await appendInboundMessageWithAdmission({
-    ...args,
-    exclusive: true
-  });
-}
-async function requestConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const existing = await readConversation(state, args.conversationId);
-    if (existing) {
-      assertSameOptionalConversationDestination({
-        conversationId: args.conversationId,
-        current: existing.destination,
-        next: args.destination
-      });
-    }
-    const current = existing ?? emptyConversation({
-      conversationId: args.conversationId,
-      destination: args.destination,
-      nowMs
-    });
-    const status = current.execution.lease ? "paused" : "pending";
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        {
-          ...current,
-          destination: current.destination ?? args.destination
-        },
-        {
-          ...current.execution,
-          status
-        },
-        nowMs
-      )
-    );
-    return { status: existing === void 0 ? "created" : "updated" };
-  });
-}
-async function markConversationWorkEnqueued(args) {
-  const nowMs = args.nowMs ?? now();
-  await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current) {
-      return;
-    }
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lastEnqueuedAtMs: nowMs
-        },
-        nowMs
-      )
-    );
-  });
-}
-async function clearConsumedConversationWake(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || hasRunnableWork(current) || current.execution.lastEnqueuedAtMs === void 0) {
-      return false;
-    }
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lastEnqueuedAtMs: void 0
-        },
-        nowMs
-      )
-    );
-    return true;
-  });
-}
-async function startConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current) {
-      return { status: "no_work" };
-    }
-    if (isLeaseActive(current.execution.lease, nowMs)) {
-      return {
-        status: "active",
-        leaseExpiresAtMs: current.execution.lease.expiresAtMs
-      };
-    }
-    if (!hasRunnableWork(current)) {
-      return { status: "no_work" };
-    }
-    const lease = {
-      token: randomUUID(),
-      acquiredAtMs: nowMs,
-      lastCheckInAtMs: nowMs,
-      expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
-    };
-    const startsNewRun = current.execution.runId === void 0;
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lease,
-          status: current.execution.status === "paused" ? "paused" : "running",
-          runId: current.execution.runId ?? randomUUID(),
-          lastEnqueuedAtMs: void 0,
-          retryCount: startsNewRun ? 0 : current.execution.retryCount
-        },
-        nowMs
-      )
-    );
-    return {
-      status: "acquired",
-      leaseToken: lease.token,
-      leaseExpiresAtMs: lease.expiresAtMs
-    };
-  });
-}
-async function checkInConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return false;
-    }
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lease: {
-            ...current.execution.lease,
-            lastCheckInAtMs: nowMs,
-            expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
-          }
-        },
-        nowMs
-      )
-    );
-    return true;
-  });
-}
-async function drainConversationMailbox(args) {
-  const nowMs = args.nowMs ?? now();
-  const pending = await withConversationMutation(args, async (state) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      throw new Error(
-        `Conversation lease is not held for ${args.conversationId}`
-      );
-    }
-    return pendingMessages(current);
-  });
-  if (pending.length === 0) {
-    return { changed: false, messages: [] };
-  }
-  const result = await args.handle(pending);
-  const pendingIds = new Set(
-    pending.map((message) => message.inboundMessageId)
-  );
-  const acknowledgedIds = new Set(
-    result ?? pending.map((message) => message.inboundMessageId)
-  );
-  for (const inboundMessageId of acknowledgedIds) {
-    if (!pendingIds.has(inboundMessageId)) {
-      throw new Error(
-        `Conversation mailbox drain result is not pending for ${args.conversationId}`
-      );
-    }
-  }
-  if (acknowledgedIds.size === 0) {
-    return { changed: false, messages: [] };
-  }
-  await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      throw new Error(
-        `Conversation lease is not held for ${args.conversationId}`
-      );
-    }
-    const pendingMessages2 = current.execution.pendingMessages.filter(
-      (message) => !acknowledgedIds.has(message.inboundMessageId)
-    );
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          status: current.execution.status === "pending" && pendingMessages2.length === 0 ? "running" : current.execution.status,
-          lastProgressAtMs: nowMs,
-          retryCount: 0,
-          pendingMessages: pendingMessages2
-        },
-        nowMs
-      )
-    );
-  });
-  return {
-    changed: true,
-    messages: pending.filter(
-      (message) => acknowledgedIds.has(message.inboundMessageId)
-    )
-  };
-}
-async function ackMessages(args) {
-  const nowMs = args.nowMs ?? now();
-  const inboundMessageIds = new Set(args.inboundMessageIds);
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return false;
-    }
-    if (inboundMessageIds.size === 0) {
-      return true;
-    }
-    const pendingMessages2 = current.execution.pendingMessages.filter(
-      (message) => !inboundMessageIds.has(message.inboundMessageId)
-    );
-    if (pendingMessages2.length === current.execution.pendingMessages.length) {
-      return true;
-    }
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lastProgressAtMs: nowMs,
-          retryCount: 0,
-          pendingMessages: pendingMessages2
-        },
-        nowMs
-      )
-    );
-    return true;
-  });
-}
-function isHumanFacingMessage(message) {
-  return message.source === "web" || message.source === "slack";
-}
-async function stopConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || !hasRunnableWork(current)) {
-      return { status: "no_work" };
-    }
-    const runId = current.execution.runId ?? randomUUID();
-    const inboundMessageIds = current.execution.pendingMessages.filter(isHumanFacingMessage).map((message) => message.inboundMessageId);
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          runId,
-          stop: { inboundMessageIds, runId }
-        },
-        nowMs
-      )
-    );
-    return { runId, status: "requested" };
-  });
-}
-async function completeConversationStop(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return { status: "lost_lease", removedInboundMessageIds: [] };
-    }
-    const stop = current.execution.stop;
-    if (!stop || stop.runId !== args.runId) {
-      return { status: "none", removedInboundMessageIds: [] };
-    }
-    const stoppedInboundMessageIds = new Set(stop.inboundMessageIds);
-    const removedInboundMessageIds = [];
-    const pendingMessages2 = current.execution.pendingMessages.filter(
-      (message) => {
-        const shouldStop = stoppedInboundMessageIds.has(
-          message.inboundMessageId
-        );
-        if (shouldStop) {
-          removedInboundMessageIds.push(message.inboundMessageId);
-        }
-        return !shouldStop;
-      }
-    );
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lastEnqueuedAtMs: pendingMessages2.length === 0 ? void 0 : current.execution.lastEnqueuedAtMs,
-          pendingMessages: pendingMessages2,
-          stop: void 0
-        },
-        nowMs
-      )
-    );
-    return { status: "cleared", removedInboundMessageIds };
-  });
-}
-async function cancelHumanFacingPendingMessages(args) {
-  const nowMs = args.nowMs ?? now();
-  const requestedIds = args.inboundMessageIds === void 0 ? void 0 : new Set(args.inboundMessageIds);
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current) {
-      return { cancelledInboundMessageIds: [] };
-    }
-    const cancelledInboundMessageIds = [];
-    const pendingMessages2 = [];
-    for (const message of current.execution.pendingMessages) {
-      const isRequested = requestedIds === void 0 || requestedIds.has(message.inboundMessageId);
-      const isInSnapshot = args.receivedBeforeMs === void 0 || message.receivedAtMs <= args.receivedBeforeMs;
-      if (isHumanFacingMessage(message) && isRequested && isInSnapshot) {
-        cancelledInboundMessageIds.push(message.inboundMessageId);
-        continue;
-      }
-      pendingMessages2.push(message);
-    }
-    if (cancelledInboundMessageIds.length === 0) {
-      return { cancelledInboundMessageIds };
-    }
-    const becomesIdle = current.execution.status === "pending" && pendingMessages2.length === 0;
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lastEnqueuedAtMs: pendingMessages2.length === 0 ? void 0 : current.execution.lastEnqueuedAtMs,
-          pendingMessages: pendingMessages2,
-          retryCount: becomesIdle ? 0 : current.execution.retryCount,
-          runId: becomesIdle ? void 0 : current.execution.runId,
-          status: becomesIdle ? "idle" : current.execution.status,
-          stop: becomesIdle ? void 0 : current.execution.stop
-        },
-        nowMs
-      )
-    );
-    return { cancelledInboundMessageIds };
-  });
-}
-async function requestAnotherSlice(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return false;
-    }
-    assertSameOptionalConversationDestination({
-      conversationId: args.conversationId,
-      current: current.destination,
-      next: args.destination
-    });
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          status: "paused"
-        },
-        nowMs
-      )
-    );
-    return true;
-  });
-}
-async function beginConversationResume(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken || current.execution.status !== "paused") {
-      return false;
-    }
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          status: "running"
-        },
-        nowMs
-      )
-    );
-    return true;
-  });
-}
-async function releaseConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return false;
-    }
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lease: void 0,
-          status: current.execution.status === "running" ? "pending" : current.execution.status
-        },
-        nowMs
-      )
-    );
-    return true;
-  });
-}
-async function recordConversationRetry(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return "lost_lease";
-    }
-    const count = (current.execution.retryCount ?? 0) + 1;
-    const stopped = count >= CONVERSATION_WORK_MAX_RETRIES;
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lastEnqueuedAtMs: void 0,
-          lease: stopped ? void 0 : current.execution.lease,
-          retryCount: count,
-          pendingMessages: stopped ? [] : current.execution.pendingMessages,
-          runId: stopped ? void 0 : current.execution.runId,
-          status: stopped ? "failed" : "paused",
-          stop: stopped ? void 0 : current.execution.stop
-        },
-        nowMs
-      )
-    );
-    return stopped ? "stopped" : "recorded";
-  });
-}
-async function completeConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return "lost_lease";
-    }
-    const hasPending = pendingMessages(current).length > 0;
-    const needsRun = current.execution.status === "paused" || args.resumeIfStopped === true && current.execution.stop !== void 0;
-    const runnable = needsRun || hasPending;
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lease: void 0,
-          status: needsRun ? "paused" : hasPending ? "pending" : "idle",
-          lastProgressAtMs: args.madeProgress === false ? current.execution.lastProgressAtMs : nowMs,
-          retryCount: runnable || args.madeProgress === false ? current.execution.retryCount : 0,
-          runId: runnable ? current.execution.runId : void 0,
-          stop: runnable ? current.execution.stop : void 0
-        },
-        nowMs
-      )
-    );
-    return runnable ? "pending" : "completed";
-  });
-}
-async function recordAttemptFailure(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return {
-        status: "lost_lease",
-        pendingCount: 0,
-        deadLetteredMessages: [],
-        retryCount: 0
-      };
-    }
-    const pendingIds = new Set(
-      current.execution.pendingMessages.map(
-        (message) => message.inboundMessageId
-      )
-    );
-    if (args.inboundMessageIds.length === 0 || args.inboundMessageIds.some((id) => !pendingIds.has(id))) {
-      return {
-        status: "skipped",
-        pendingCount: current.execution.pendingMessages.length,
-        deadLetteredMessages: [],
-        retryCount: current.execution.retryCount ?? 0
-      };
-    }
-    const retryCount = (current.execution.retryCount ?? 0) + 1;
-    const retriesExhausted = retryCount >= CONVERSATION_WORK_MAX_RETRIES;
-    const attemptedIds = new Set(args.inboundMessageIds);
-    const deadLetteredMessages = [];
-    const pendingMessages2 = [];
-    for (const message of current.execution.pendingMessages) {
-      if (!attemptedIds.has(message.inboundMessageId)) {
-        if (retriesExhausted) {
-          deadLetteredMessages.push(message);
-        } else {
-          pendingMessages2.push(message);
-        }
-        continue;
-      }
-      const attempted = {
-        ...message,
-        attemptCount: (message.attemptCount ?? 0) + 1
-      };
-      if (retriesExhausted || attempted.attemptCount >= CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS) {
-        deadLetteredMessages.push(attempted);
-        continue;
-      }
-      pendingMessages2.push(attempted);
-    }
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          retryCount,
-          pendingMessages: pendingMessages2
-        },
-        nowMs
-      )
-    );
-    return {
-      status: "recorded",
-      pendingCount: pendingMessages2.length,
-      deadLetteredMessages,
-      retryCount
-    };
-  });
-}
-async function deadLetterAttempt(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current || current.execution.lease?.token !== args.leaseToken) {
-      return "lost_lease";
-    }
-    const runnable = pendingMessages(current).length > 0;
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lease: void 0,
-          status: runnable ? "pending" : "failed",
-          runId: runnable ? current.execution.runId : void 0,
-          stop: runnable ? current.execution.stop : void 0
-        },
-        nowMs
-      )
-    );
-    return runnable ? "pending" : "failed";
-  });
-}
-async function clearExpiredConversationLease(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state, lock) => {
-    const current = await readConversation(state, args.conversationId);
-    if (!current?.execution.lease || current.execution.lease.expiresAtMs > nowMs) {
-      return "not_expired";
-    }
-    const retryCount = (current.execution.retryCount ?? 0) + 1;
-    const stopped = retryCount >= CONVERSATION_WORK_MAX_RETRIES;
-    await writeConversation(
-      state,
-      lock,
-      withExecutionUpdate(
-        current,
-        {
-          ...current.execution,
-          lastEnqueuedAtMs: void 0,
-          lease: void 0,
-          retryCount,
-          pendingMessages: stopped ? [] : current.execution.pendingMessages,
-          runId: stopped ? void 0 : current.execution.runId,
-          status: stopped ? "failed" : "paused",
-          stop: stopped ? void 0 : current.execution.stop
-        },
-        nowMs
-      )
-    );
-    return stopped ? "stopped" : "requeued";
-  });
-}
-async function removeActiveConversation(args) {
-  const state = await getConnectedState(args.state);
-  await removeIndexEntry({
-    state,
-    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-    conversationId: args.conversationId
-  });
-}
-async function listActiveConversationIds(args = {}) {
-  const state = await getConnectedState(args.state);
-  const index = await getConversationIndexStore(state);
-  const entries = await index.list({
-    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-    limit: args.limit,
-    order: "asc",
-    scoreMax: args.staleBeforeMs
-  });
-  return entries.map((entry) => entry.conversationId);
-}
-
-// src/chat/task-execution/store.ts
-function metadataStore(options) {
-  return options.conversationStore ?? getConversationStore();
-}
-function duplicateInboundNudgeIdempotencyKey(message, nowMs) {
-  return `duplicate:${message.conversationId}:${message.inboundMessageId}:${nowMs}`;
-}
-function hasRecentEnqueueMarker(conversation, nowMs) {
-  const lastEnqueuedAtMs = conversation.execution.lastEnqueuedAtMs;
-  return typeof lastEnqueuedAtMs === "number" && lastEnqueuedAtMs + CONVERSATION_WORK_STALE_ENQUEUE_MS > nowMs;
-}
-function now2() {
-  return Date.now();
-}
-async function recordExecutionMetadata(args) {
-  const conversation = await getConversation({
-    conversationId: args.conversationId,
-    state: args.state
-  });
-  if (!conversation) {
-    return;
-  }
-  await metadataStore(args).recordExecution({
-    channelName: conversation.channelName,
-    conversationId: conversation.conversationId,
-    createdAtMs: conversation.createdAtMs,
-    destination: conversation.destination,
-    execution: {
-      lastCheckpointAtMs: conversation.execution.lastCheckpointAtMs,
-      lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
-      runId: conversation.execution.runId,
-      status: conversation.execution.status,
-      updatedAtMs: conversation.execution.updatedAtMs
-    },
-    lastActivityAtMs: conversation.lastActivityAtMs,
-    metrics: null,
-    actor: conversation.actor,
-    source: conversation.source,
-    title: conversation.title,
-    updatedAtMs: conversation.updatedAtMs
-  });
-}
-async function getConversation2(args) {
-  return await getConversation(args);
-}
-async function getConversationWorkState2(args) {
-  return await getConversationWorkState(args);
-}
-async function recordConversationRetry2(args) {
-  const result = await recordConversationRetry(args);
-  await recordExecutionMetadata(args);
-  return result;
-}
-function countPendingConversationMessages(conversation) {
-  return conversation.execution.pendingMessages.length;
-}
-function hasRunnableConversationWork2(conversation) {
-  return conversation.execution.status !== "idle" || countPendingConversationMessages(conversation) > 0;
-}
-async function ensureConversationWake(args) {
-  const nowMs = args.nowMs ?? now2();
-  const conversation = await getConversation({
-    conversationId: args.conversationId,
-    state: args.state
-  });
-  if (!conversation || !hasRunnableConversationWork2(conversation)) {
-    return { status: "no_work" };
-  }
-  if (args.replaceExistingWake !== true && conversation.execution.lease && conversation.execution.lease.expiresAtMs > nowMs) {
-    return { status: "lease_active" };
-  }
-  if (args.replaceExistingWake !== true && hasRecentEnqueueMarker(conversation, nowMs)) {
-    return { status: "already_enqueued" };
-  }
-  const queueResult = await args.queue.send(
-    {
-      schemaVersion: CONVERSATION_QUEUE_SCHEMA_VERSION,
-      conversationId: args.conversationId
-    },
-    {
-      delayMs: args.delayMs,
-      idempotencyKey: args.idempotencyKey
-    }
-  );
-  await markConversationWorkEnqueued2({
-    conversationId: args.conversationId,
-    conversationStore: args.conversationStore,
-    nowMs,
-    state: args.state
-  });
-  return { status: "enqueued", queueMessageId: queueResult?.messageId };
-}
-async function enqueueAfterAppend(args) {
-  const nowMs = args.nowMs ?? now2();
-  const appendResult = args.appendResult;
-  if (appendResult.status === "active") return appendResult;
-  let idempotencyKey = args.message.inboundMessageId;
-  if (appendResult.status === "duplicate") {
-    const conversation = await getConversation({
-      conversationId: args.message.conversationId,
-      state: args.state
-    });
-    if (!conversation) {
-      return appendResult;
-    }
-    if (hasRecentEnqueueMarker(conversation, nowMs)) {
-      await recordExecutionMetadata({
-        conversationId: args.message.conversationId,
-        conversationStore: args.conversationStore,
-        state: args.state
-      });
-      return appendResult;
-    }
-    const duplicateStillPending = conversation.execution.pendingMessages.some(
-      (message) => message.inboundMessageId === args.message.inboundMessageId
-    );
-    if (!duplicateStillPending) {
-      await recordExecutionMetadata({
-        conversationId: args.message.conversationId,
-        conversationStore: args.conversationStore,
-        state: args.state
-      });
-      return appendResult;
-    }
-    idempotencyKey = duplicateInboundNudgeIdempotencyKey(args.message, nowMs);
-  }
-  const wake = await ensureConversationWake({
-    conversationId: args.message.conversationId,
-    conversationStore: args.conversationStore,
-    idempotencyKey,
-    nowMs,
-    queue: args.queue,
-    state: args.state
-  });
-  if (wake.status !== "enqueued") {
-    await recordExecutionMetadata({
-      conversationId: args.message.conversationId,
-      conversationStore: args.conversationStore,
-      state: args.state
-    });
-  }
-  return {
-    ...appendResult,
-    ...wake.status === "enqueued" ? { queueMessageId: wake.queueMessageId } : void 0
-  };
-}
-async function appendAndEnqueueInboundMessage(args) {
-  const nowMs = args.nowMs ?? now2();
-  const result = await enqueueAfterAppend({
-    ...args,
-    appendResult: await appendInboundMessage({
-      message: args.message,
-      nowMs,
-      state: args.state
-    }),
-    nowMs
-  });
-  if (result.status === "active") {
-    throw new Error("Non-exclusive mailbox enqueue returned active");
-  }
-  return result;
-}
-async function appendAndEnqueueExclusiveInboundMessage(args) {
-  const nowMs = args.nowMs ?? now2();
-  return await enqueueAfterAppend({
-    ...args,
-    appendResult: await appendExclusiveInboundMessage({
-      message: args.message,
-      nowMs,
-      state: args.state
-    }),
-    nowMs
-  });
-}
-async function stopConversationWork2(args) {
-  const result = await stopConversationWork(args);
-  if (result.status === "requested") {
-    await recordExecutionMetadata(args);
-  }
-  return result;
-}
-async function completeConversationStop2(args) {
-  const result = await completeConversationStop(args);
-  if (result.status === "cleared") {
-    await recordExecutionMetadata(args);
-  }
-  return result;
-}
-async function clearConsumedConversationWake2(args) {
-  const result = await clearConsumedConversationWake(args);
-  if (result) {
-    await recordExecutionMetadata(args);
-  }
-  return result;
-}
-async function requestConversationWork2(args) {
-  const result = await requestConversationWork(args);
-  await recordExecutionMetadata({
-    conversationId: args.conversationId,
-    conversationStore: args.conversationStore,
-    state: args.state
-  });
-  return result;
-}
-async function markConversationWorkEnqueued2(args) {
-  await markConversationWorkEnqueued(args);
-  await recordExecutionMetadata(args);
-}
-async function startConversationWork2(args) {
-  const result = await startConversationWork(args);
-  await recordExecutionMetadata(args);
-  return result;
-}
-async function checkInConversationWork2(args) {
-  const result = await checkInConversationWork(args);
-  if (result) {
-    await recordExecutionMetadata(args);
-  }
-  return result;
-}
-async function drainConversationMailbox2(args) {
-  const result = await drainConversationMailbox(args);
-  if (result.changed) {
-    await recordExecutionMetadata(args);
-  }
-  return result.messages;
-}
-async function ackMessages2(args) {
-  const result = await ackMessages(args);
-  await recordExecutionMetadata(args);
-  return result;
-}
-async function cancelHumanFacingPendingMessages2(args) {
-  const result = await cancelHumanFacingPendingMessages(args);
-  if (result.cancelledInboundMessageIds.length > 0) {
-    await recordExecutionMetadata(args);
-  }
-  return result;
-}
-async function requestAnotherSlice2(args) {
-  const result = await requestAnotherSlice(args);
-  await recordExecutionMetadata(args);
-  return result;
-}
-async function beginConversationResume2(args) {
-  const result = await beginConversationResume(args);
-  if (result) {
-    await recordExecutionMetadata(args);
-  }
-  return result;
-}
-async function releaseConversationWork2(args) {
-  const result = await releaseConversationWork(args);
-  await recordExecutionMetadata(args);
-  return result;
-}
-async function completeConversationWork2(args) {
-  const result = await completeConversationWork(args);
-  await recordExecutionMetadata(args);
-  return result;
-}
-async function recordAttemptFailure2(args) {
-  const result = await recordAttemptFailure(args);
-  if (result.status === "recorded") {
-    await recordExecutionMetadata(args);
-  }
-  return result;
-}
-async function deadLetterAttempt2(args) {
-  const result = await deadLetterAttempt(args);
-  await recordExecutionMetadata(args);
-  return result;
-}
-async function clearExpiredConversationLease2(args) {
-  const result = await clearExpiredConversationLease(args);
-  await recordExecutionMetadata(args);
-  return result;
-}
-async function removeActiveConversation2(args) {
-  return await removeActiveConversation(args);
-}
-async function listActiveConversationIds2(args = {}) {
-  return await listActiveConversationIds(args);
-}
-
-export {
-  isInvalidConversationRecordError,
-  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
-  CONVERSATION_WORK_STALE_ENQUEUE_MS,
-  CONVERSATION_WORK_MAX_RETRIES,
-  isFinalAttempt,
-  hasRunnableConversationWork,
-  getConversation2 as getConversation,
-  getConversationWorkState2 as getConversationWorkState,
-  recordConversationRetry2 as recordConversationRetry,
-  countPendingConversationMessages,
-  hasRunnableConversationWork2,
-  ensureConversationWake,
-  appendAndEnqueueInboundMessage,
-  appendAndEnqueueExclusiveInboundMessage,
-  stopConversationWork2 as stopConversationWork,
-  completeConversationStop2 as completeConversationStop,
-  clearConsumedConversationWake2 as clearConsumedConversationWake,
-  requestConversationWork2 as requestConversationWork,
-  startConversationWork2 as startConversationWork,
-  checkInConversationWork2 as checkInConversationWork,
-  drainConversationMailbox2 as drainConversationMailbox,
-  ackMessages2 as ackMessages,
-  cancelHumanFacingPendingMessages2 as cancelHumanFacingPendingMessages,
-  requestAnotherSlice2 as requestAnotherSlice,
-  beginConversationResume2 as beginConversationResume,
-  releaseConversationWork2 as releaseConversationWork,
-  completeConversationWork2 as completeConversationWork,
-  recordAttemptFailure2 as recordAttemptFailure,
-  deadLetterAttempt2 as deadLetterAttempt,
-  clearExpiredConversationLease2 as clearExpiredConversationLease,
-  removeActiveConversation2 as removeActiveConversation,
-  listActiveConversationIds2 as listActiveConversationIds
-};