@sentry/junior 0.137.0 → 0.139.0

package/dist/chunk-MQ5RYATN.js

@@ -0,0 +1,1523 @@
+import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
+import {
+  getConversationStore,
+  parseDestination,
+  sameDestination
+} from "./chunk-QTBKPZDA.js";
+import {
+  getDefaultRedisStateAdapterFor,
+  getStateAdapter
+} from "./chunk-MXTVUV3I.js";
+import {
+  getChatConfig
+} from "./chunk-75I3UBIL.js";
+import {
+  parseStoredSlackActor
+} from "./chunk-HZF5P5UN.js";
+import {
+  isRecord,
+  toOptionalNumber,
+  toOptionalString
+} from "./chunk-2ECYPYKP.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";
+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"
+]);
+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();
+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) ? {} : { 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 === "awaiting_resume" || value === "failed" || value === "idle" || value === "pending" || value === "running") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeMessage(value, schemaVersion) {
+  const candidate = schemaVersion === 1 && isRecord(value) && value.delivery === void 0 ? {
+    ...value,
+    delivery: "defer"
+  } : value;
+  const parsed = inboundMessageSchema.safeParse(candidate);
+  return parsed.success ? parsed.data : void 0;
+}
+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 normalizeExecution(conversationId, value, schemaVersion) {
+  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, schemaVersion);
+      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 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: toOptionalString(value.runId),
+    updatedAtMs: toOptionalNumber(value.updatedAtMs)
+  };
+}
+function normalizeConversation(conversationId, value) {
+  if (!isRecord(value) || value.schemaVersion !== 1 && value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) {
+    return void 0;
+  }
+  const schemaVersion = value.schemaVersion;
+  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,
+    schemaVersion
+  );
+  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) => message.destination ? !destination || !sameDestination(message.destination, destination) : Boolean(destination)
+  )) {
+    return void 0;
+  }
+  return {
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+    conversationId,
+    createdAtMs,
+    lastActivityAtMs,
+    updatedAtMs,
+    execution,
+    ...destination ? { destination } : {},
+    ...toOptionalString(value.title) ? { title: toOptionalString(value.title) } : {},
+    ...toOptionalString(value.channelName) ? { channelName: toOptionalString(value.channelName) } : {},
+    ...normalizeActor(value.actor) ? { actor: normalizeActor(value.actor) } : {},
+    ...normalizeSource(value.source) ? { source: normalizeSource(value.source) } : {}
+  };
+}
+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 } : {},
+    ...args.source ? { source: args.source } : {},
+    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);
+  }
+  await state.set(
+    conversationKey(next.conversationId),
+    next,
+    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.current && !args.next) {
+    return;
+  }
+  if (args.current && args.next && 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
+      }
+    } : {},
+    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;
+}
+async function appendInboundMessage(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" };
+      }
+      const status = current.execution.lease && current.execution.status === "running" ? "running" : current.execution.lease ? "awaiting_resume" : "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 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 ? "awaiting_resume" : "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 === "awaiting_resume" ? "awaiting_resume" : "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;
+  });
+}
+async function requestConversationContinuation(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: "awaiting_resume"
+        },
+        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 !== "awaiting_resume") {
+      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" : "awaiting_resume"
+        },
+        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 === "awaiting_resume";
+    const runnable = needsRun || hasPending;
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: needsRun ? "awaiting_resume" : 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
+        },
+        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
+        },
+        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" : "awaiting_resume"
+        },
+        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 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 hasRunnableConversationWork(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 || !hasRunnableConversationWork(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(
+    {
+      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 appendAndEnqueueInboundMessage(args) {
+  const nowMs = args.nowMs ?? now2();
+  const appendResult = await appendInboundMessage({
+    message: args.message,
+    nowMs,
+    state: args.state
+  });
+  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 } : {}
+  };
+}
+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 requestConversationContinuation2(args) {
+  const result = await requestConversationContinuation(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,
+  getConversationWorkState2 as getConversationWorkState,
+  recordConversationRetry2 as recordConversationRetry,
+  countPendingConversationMessages,
+  hasRunnableConversationWork,
+  ensureConversationWake,
+  appendAndEnqueueInboundMessage,
+  clearConsumedConversationWake2 as clearConsumedConversationWake,
+  requestConversationWork2 as requestConversationWork,
+  startConversationWork2 as startConversationWork,
+  checkInConversationWork2 as checkInConversationWork,
+  drainConversationMailbox2 as drainConversationMailbox,
+  ackMessages2 as ackMessages,
+  requestConversationContinuation2 as requestConversationContinuation,
+  beginConversationResume2 as beginConversationResume,
+  releaseConversationWork2 as releaseConversationWork,
+  completeConversationWork2 as completeConversationWork,
+  recordAttemptFailure2 as recordAttemptFailure,
+  deadLetterAttempt2 as deadLetterAttempt,
+  clearExpiredConversationLease2 as clearExpiredConversationLease,
+  removeActiveConversation2 as removeActiveConversation,
+  listActiveConversationIds2 as listActiveConversationIds
+};