@bastani/atomic 0.9.44-alpha.1 → 0.9.44-alpha.3

package/dist/builtin/workflows/src/extension/local-worker-entry.mjs

@@ -1661,6 +1661,17 @@ function removeProcessExitCleanup(cleanup) {
   if (processExitCleanups.delete(cleanup) && processExitCleanups.size === 0)
     process.off("exit", runProcessExitCleanups);
 }
+function writtenHandle(event) {
+  if (event.type === RUN_EVENT_TYPES.promptAsked || event.type === RUN_EVENT_TYPES.promptReleased)
+    return event.payload.handle;
+  if (event.type === RUN_EVENT_TYPES.checkpointRecorded || event.type === RUN_EVENT_TYPES.messageSettled || event.type === RUN_EVENT_TYPES.messageDelivered)
+    return;
+  return event.payload;
+}
+function snapshotNeedsHistory(tail) {
+  const handle = writtenHandle(tail.snapshot.event);
+  return handle !== undefined && (handle.pendingStageMessageChange !== undefined || hasPendingStageDeliveryDelta(handle.pendingStageMessages));
+}
 function* invoke(action) {
   try {
     const result = action();
@@ -1773,11 +1784,11 @@ class JournalDurableBackend {
       const payload = event.payload;
       this.projection.archivePendingStageDeliveryReceipt(entry.runId, payload.messageId, payload.delivery, payload.accounting);
     } else if (event.type === RUN_EVENT_TYPES.promptAsked || event.type === RUN_EVENT_TYPES.promptReleased) {
-      this.projection.applyWorkflowSnapshot(event.payload.handle);
+      this.projection.applyWorkflowSnapshot(decodeHandle(event.payload.handle, this.projection.getWorkflow(entry.runId)?.pendingStageMessages));
       this.prompts.set(entry.runId, new PromptReservationState(event.payload.handle.pendingPrompts, event.payload.prompts));
     } else {
-      const handle = event.payload;
       const previous = this.projection.getWorkflow(entry.runId);
+      const handle = decodeHandle(event.payload, previous?.pendingStageMessages);
       this.projection.applyWorkflowSnapshot(handle);
       if (event.type === RUN_EVENT_TYPES.runStarted || previous?.pendingPrompts !== handle.pendingPrompts)
         this.prompts.delete(entry.runId);
@@ -1897,6 +1908,20 @@ class JournalDurableBackend {
   }
   *append(runId, event, options) {
     const lease = yield* this.ownership(runId);
+    const base = this.sequences.get(runId);
+    const pinned = options?.expectSeq;
+    const encoded = base !== undefined && (pinned === undefined || pinned === base) && event.type !== RUN_EVENT_TYPES.runStarted ? encodeHandleEvent(event, this.projection.getWorkflow(runId)?.pendingStageMessages) : undefined;
+    if (encoded !== undefined) {
+      try {
+        return yield* this.write(runId, lease, encoded, { ...options, expectSeq: base });
+      } catch (error) {
+        if (!(error instanceof JournalCasConflictError) || pinned !== undefined)
+          throw error;
+      }
+    }
+    yield* this.write(runId, lease, event, options);
+  }
+  *write(runId, lease, event, options) {
     try {
       const outcome = yield* invoke(() => this.journal.append(lease, event, options));
       const nextSeq = (this.sequences.get(runId) ?? 0) + 1;
@@ -2073,11 +2098,12 @@ class JournalDurableBackend {
     for (const message of messages)
       if (message.runId !== logicalRunId)
         throw new JournalMessageScopeError(logicalRunId, message.runId);
-    yield* this.snapshot({
+    const next = {
       ...handle,
       pendingStageMessages: replacePendingStageMessagesForRun(handle.pendingStageMessages ?? [], logicalRunId, messages),
       updatedAt: Math.max(Date.now(), handle.updatedAt + 1)
-    }, RUN_EVENT_TYPES.messageQueued);
+    };
+    yield* this.snapshot(next, RUN_EVENT_TYPES.messageQueued);
     return true;
   }
   async archivePendingStageMessage(runId, message) {
@@ -2171,7 +2197,7 @@ class JournalDurableBackend {
       if (summarized !== undefined && summarized.seq === version.seq && summarized.at === version.at)
         return;
       const tail = yield* invoke(() => journal.snapshotTail(runId));
-      if (tail !== undefined)
+      if (tail !== undefined && !snapshotNeedsHistory(tail))
         return this.summarize(runId, tail);
       if (summarized === undefined && version.seq === 0)
         return;
@@ -2397,7 +2423,182 @@ class JournalDurableBackend {
     }
   }
 }
-var PROCESS_HOLDER_ID, processExitCleanups, JournalOwnershipError, JournalBackendClosedError, JournalOperationAbortedError, JournalExecutionRetiredError, JournalMessageScopeError;
+function identity(message) {
+  return JSON.stringify([message.runId, message.id]);
+}
+function uniqueByIdentity(messages) {
+  const result = new Map;
+  const repeated = new Set;
+  for (const message of messages) {
+    const key = identity(message);
+    if (result.has(key))
+      repeated.add(key);
+    result.set(key, message);
+  }
+  for (const key of repeated)
+    result.delete(key);
+  return result;
+}
+function isDeltaEncoded(message) {
+  return message.deliveryDelta !== undefined;
+}
+function deliveryDelta(base, deliveries) {
+  const drop = [];
+  let kept = 0;
+  base.forEach((delivery, index) => {
+    if (kept < deliveries.length && JSON.stringify(delivery) === JSON.stringify(deliveries[kept]))
+      kept++;
+    else
+      drop.push(index);
+  });
+  const add = deliveries.slice(kept);
+  return drop.length === 0 ? { add } : { drop, add };
+}
+function pendingStageFields(message) {
+  return Object.keys(message);
+}
+function copyField(target, source, key) {
+  target[key] = source[key];
+}
+function isRemovedField(message, key) {
+  return message[key] === undefined;
+}
+function json(message) {
+  let text = entryJson.get(message);
+  if (text === undefined) {
+    text = JSON.stringify(message);
+    entryJson.set(message, text);
+  }
+  return text;
+}
+function patchEntry(index, base, message) {
+  const set = {};
+  const unset = pendingStageFields(base).filter((key) => base[key] !== undefined && isRemovedField(message, key));
+  for (const key of pendingStageFields(message)) {
+    if (message[key] === undefined || key === "deliveries")
+      continue;
+    if (JSON.stringify(message[key]) !== JSON.stringify(base[key]))
+      copyField(set, message, key);
+  }
+  let delta;
+  if (message.deliveries !== undefined) {
+    if (base.deliveries === undefined)
+      set.deliveries = message.deliveries;
+    else if (JSON.stringify(base.deliveries) !== JSON.stringify(message.deliveries))
+      delta = deliveryDelta(base.deliveries, message.deliveries);
+  }
+  return {
+    patch: index,
+    ...Object.keys(set).length === 0 ? {} : { set },
+    ...unset.length === 0 ? {} : { unset },
+    ...delta === undefined ? {} : { deliveryDelta: delta }
+  };
+}
+function encodePendingStageList(previous, next) {
+  const positions = new Map;
+  const repeated = new Set;
+  previous.forEach((message, index) => {
+    const key = identity(message);
+    if (positions.has(key))
+      repeated.add(key);
+    positions.set(key, index);
+  });
+  for (const key of repeated)
+    positions.delete(key);
+  const items = [];
+  let reused = 0;
+  for (const message of next) {
+    const index = positions.get(identity(message));
+    const base = index === undefined ? undefined : previous[index];
+    if (base === undefined) {
+      items.push(message);
+      continue;
+    }
+    reused++;
+    const patched = base === message || json(base) === json(message) ? undefined : patchEntry(index, base, message);
+    if (patched === undefined || Object.keys(patched).length === 1) {
+      const last = items.at(-1);
+      if (Array.isArray(last) && last[0] + last[1] === index)
+        last[1]++;
+      else
+        items.push([index, 1]);
+      continue;
+    }
+    items.push(JSON.stringify(patched).length < json(message).length ? patched : message);
+  }
+  return reused > 0 ? items : undefined;
+}
+function decodePendingStageList(previous, items) {
+  const base = (index) => {
+    if (!Number.isInteger(index) || index < 0 || index >= previous.length)
+      throw new Error(`atomic-workflows: journal pending-stage change names missing entry ${index}`);
+    return previous[index];
+  };
+  const result = [];
+  for (const item of items) {
+    if (Array.isArray(item)) {
+      const [start, count] = item;
+      for (let index = start;index < start + count; index++)
+        result.push(base(index));
+    } else if (typeof item.patch === "number") {
+      const { patch, set, unset, deliveryDelta: delta } = item;
+      const entry = { ...base(patch), ...set };
+      for (const key of unset ?? [])
+        delete entry[key];
+      if (delta !== undefined) {
+        const dropped = new Set(delta.drop ?? []);
+        const deliveries = base(patch).deliveries ?? [];
+        entry.deliveries = [...deliveries.filter((_, index) => !dropped.has(index)), ...delta.add];
+      }
+      result.push(entry);
+    } else
+      result.push(item);
+  }
+  return result;
+}
+function encodeHandleEvent(event, previous) {
+  const handle = writtenHandle(event);
+  if (handle?.pendingStageMessages === undefined || previous === undefined)
+    return;
+  const change = encodePendingStageList(previous, handle.pendingStageMessages);
+  if (change === undefined)
+    return;
+  const { pendingStageMessages: _full, ...rest } = handle;
+  const encoded = { ...rest, pendingStageMessageChange: change };
+  if (event.type === RUN_EVENT_TYPES.promptAsked || event.type === RUN_EVENT_TYPES.promptReleased)
+    return { ...event, payload: { ...event.payload, handle: encoded } };
+  return { ...event, payload: encoded };
+}
+function decodeHandle(handle, previous) {
+  const { pendingStageMessageChange: change, ...rest } = handle;
+  if (change !== undefined)
+    return { ...rest, pendingStageMessages: decodePendingStageList(previous ?? [], change) };
+  if (!hasPendingStageDeliveryDelta(handle.pendingStageMessages))
+    return handle;
+  return {
+    ...handle,
+    pendingStageMessages: decodePendingStageDeliveries(previous ?? [], handle.pendingStageMessages ?? [])
+  };
+}
+function decodePendingStageDeliveries(previous, messages) {
+  if (!messages.some(isDeltaEncoded))
+    return messages;
+  const bases = uniqueByIdentity(previous);
+  return messages.map((message) => {
+    if (!isDeltaEncoded(message))
+      return message;
+    const base = bases.get(identity(message))?.deliveries;
+    if (base === undefined)
+      throw new Error(`atomic-workflows: journal delivery change for ${identity(message)} has no base entry`);
+    const { deliveryDelta, ...rest } = message;
+    const dropped = new Set(deliveryDelta.drop ?? []);
+    return { ...rest, deliveries: [...base.filter((_, index) => !dropped.has(index)), ...deliveryDelta.add] };
+  });
+}
+function hasPendingStageDeliveryDelta(messages) {
+  return messages?.some(isDeltaEncoded) === true;
+}
+var PROCESS_HOLDER_ID, processExitCleanups, JournalOwnershipError, JournalBackendClosedError, JournalOperationAbortedError, JournalExecutionRetiredError, JournalMessageScopeError, entryJson;
 var init_journal_backend = __esm(() => {
   init_workflow_instance_ownership_error();
   init_backend();
@@ -2455,6 +2656,7 @@ var init_journal_backend = __esm(() => {
       this.name = "JournalMessageScopeError";
     }
   };
+  entryJson = new WeakMap;
 });
 
 // dist/builtin/workflows/src/durable/journal/legacy-journal-tables.ts
@@ -57447,7 +57649,20 @@ function createWorkflowBoundarySegmentsResolver(runs) {
   };
 }
 function workflowBoundaryHops(runs, runId) {
+  return boundaryHopsFrom(new Map(runs.map((run) => [run.id, run])), runId);
+}
+function createWorkflowBoundaryHopsResolver(runs) {
   const runById = new Map(runs.map((run) => [run.id, run]));
+  const cache = new Map;
+  return (runId) => {
+    if (cache.has(runId))
+      return cache.get(runId);
+    const hops = boundaryHopsFrom(runById, runId);
+    cache.set(runId, hops);
+    return hops;
+  };
+}
+function boundaryHopsFrom(runById, runId) {
   const hops = [];
   let current = runById.get(runId);
   while (current !== undefined && current.parentRunId !== undefined) {
@@ -57473,6 +57688,35 @@ function workflowStagePathVariants(hops, stageSegments) {
 function stageMatchesPathPattern(patternSegments, hops, stageSegments) {
   return workflowStagePathVariants(hops, stageSegments).some((candidate) => matchStagePathSegments(patternSegments, candidate));
 }
+function createStagePathPatternIndex(patterns) {
+  const byFirstSegment = new Map;
+  const globFirst = [];
+  patterns.forEach((pattern, index) => {
+    const first = pattern[0];
+    if (first === undefined || first.includes("*")) {
+      globFirst.push(index);
+      return;
+    }
+    const bucket = byFirstSegment.get(first);
+    if (bucket === undefined)
+      byFirstSegment.set(first, [index]);
+    else
+      bucket.push(index);
+  });
+  return {
+    matching(hops, stageSegments) {
+      if (patterns.length === 0)
+        return [];
+      const variants = workflowStagePathVariants(hops, stageSegments);
+      const candidates = new Set(globFirst);
+      for (const variant of variants) {
+        for (const index of byFirstSegment.get(variant[0]) ?? [])
+          candidates.add(index);
+      }
+      return [...candidates].sort((left, right) => left - right).filter((index) => variants.some((variant) => matchStagePathSegments(patterns[index], variant)));
+    }
+  };
+}
 var init_pending_stage_status = __esm(() => {
   init_store_internal();
   init_workflow_stage_target();
@@ -57483,24 +57727,63 @@ function stickyStageDeliveryStatuses(runs, rootRunId, availableBackend) {
   const root = runs.find((run) => run.id === rootRunId);
   const entries = (root?.pendingStageMessages ?? []).filter((entry) => entry.sticky === true);
   const result = [];
+  const patternByTarget = new Map;
+  const patterns = [];
+  const entriesByPattern = [];
+  const ownEntries = [];
+  entries.forEach((entry, index) => {
+    const target = entry.targetPath ?? entry.stageKey;
+    let pattern = patternByTarget.get(target);
+    if (pattern === undefined) {
+      const parsed = parseWorkflowStageTarget(target);
+      pattern = parsed?.rootRunId === rootRunId ? patterns.push(parsed.segments) - 1 : -1;
+      if (pattern >= 0)
+        entriesByPattern.push([]);
+      patternByTarget.set(target, pattern);
+    }
+    if (pattern < 0)
+      return;
+    entriesByPattern[pattern].push(index);
+    ownEntries.push(index);
+  });
+  if (ownEntries.length === 0)
+    return result;
+  const patternIndex = createStagePathPatternIndex(patterns);
+  const deliveriesByEntry = new Map;
+  const entryReceipts = (index, runId, stageId) => {
+    let byStage = deliveriesByEntry.get(index);
+    if (byStage === undefined) {
+      byStage = new Map;
+      for (const delivery of entries[index].deliveries ?? []) {
+        const key = `${delivery.runId}\x00${delivery.stageId}`;
+        const list = byStage.get(key);
+        if (list === undefined)
+          byStage.set(key, [delivery]);
+        else
+          list.push(delivery);
+      }
+      deliveriesByEntry.set(index, byStage);
+    }
+    return byStage.get(`${runId}\x00${stageId}`) ?? [];
+  };
   availableBackend = availableRunDurableBackend(runs, rootRunId) ?? availableBackend;
   const backend = availableBackend === undefined ? undefined : durableBackendForRun(availableBackend, runs, rootRunId);
+  const runById = new Map(runs.map((run) => [run.id, run]));
+  const hopsFor = createWorkflowBoundaryHopsResolver(runs);
   for (const run of runs) {
-    if (run.id !== rootRunId && run.rootRunId !== rootRunId && durableRootRunIdForRun(runs, run.id) !== rootRunId)
+    const durableRootRunId = reciprocalWorkflowRootRunId(runById, run.id);
+    if (run.id !== rootRunId && run.rootRunId !== rootRunId && durableRootRunId !== rootRunId)
       continue;
-    const resolved = durableRootRunIdForRun(runs, run.id) === rootRunId;
-    const hops = workflowBoundaryHops(runs, run.id);
+    const resolved = durableRootRunId === rootRunId;
+    const hops = hopsFor(run.id);
     for (const stage of run.stages) {
       if (stage.nodeKind === "tool" || stage.replayKey?.startsWith("prompt:") === true || stage.replayKey?.startsWith("workflow:") === true || stage.workflowChildRun !== undefined || stage.workflowChild !== undefined)
         continue;
-      for (const entry of entries) {
+      const matchedEntries = resolved && hops ? patternIndex.matching(hops, [stage.id, stage.name]).flatMap((pattern) => entriesByPattern[pattern]).sort((left, right) => left - right) : ownEntries;
+      for (const index of matchedEntries) {
+        const entry = entries[index];
         const target = entry.targetPath ?? entry.stageKey;
-        const parsed = parseWorkflowStageTarget(target);
-        if (!parsed || parsed.rootRunId !== rootRunId)
-          continue;
-        if (resolved && hops && !stageMatchesPathPattern(parsed.segments, hops, [stage.id, stage.name]))
-          continue;
-        const receipts = (entry.deliveries ?? []).filter((delivery) => delivery.runId === run.id && delivery.stageId === stage.id);
+        const receipts = entryReceipts(index, run.id, stage.id);
         const delivered = backend?.hasCachedPendingStageDeliveryReceipt?.(rootRunId, entry.id, {
           runId: run.id,
           stageId: stage.id,
@@ -57818,20 +58101,27 @@ function possibleStageRows(runs, rootRunId, rootRun, backend) {
   if (isTerminalRunStatus(rootRun.status))
     return [];
   const stickyQueued = (rootRun.pendingStageMessages ?? []).filter((entry) => entry.sticky === true && entry.status === "queued");
+  const segmentsByTarget = new Map;
   const stickySegments = (entry) => {
-    const parsed = parseWorkflowStageTarget(entry.targetPath ?? entry.stageKey);
-    return parsed?.rootRunId === rootRunId ? parsed.segments : undefined;
+    const target = entry.targetPath ?? entry.stageKey;
+    if (segmentsByTarget.has(target))
+      return segmentsByTarget.get(target);
+    const parsed = parseWorkflowStageTarget(target);
+    const segments = parsed?.rootRunId === rootRunId ? parsed.segments : undefined;
+    segmentsByTarget.set(target, segments);
+    return segments;
   };
   const scanEntries = stickyQueued.filter((entry) => {
     const segments = stickySegments(entry);
     return !(segments !== undefined && segments.length === 1 && segments[0] === "**");
   });
+  const liveStageMatches = materializedStageMatcher(runs, rootRunId);
   const rows = [];
   for (const scanEntry of rootRun.possibleStages ?? []) {
     const rowSegments = splitStagePathSegments(scanEntry);
     if (rowSegments.length === 0 || rowSegments.some((segment) => segment.length === 0))
       continue;
-    if (!rowSegments.some((segment) => segment.includes("*")) && materializedStageMatches(runs, rootRunId, rowSegments)) {
+    if (!rowSegments.some((segment) => segment.includes("*")) && liveStageMatches(rowSegments)) {
       continue;
     }
     rows.push({
@@ -57852,28 +58142,43 @@ function possibleStageRows(runs, rootRunId, rootRun, backend) {
     }).length
   });
   const statuses = stickyStageDeliveryStatuses(runs, rootRunId, backend);
-  for (const target of new Set(statuses.map((status) => status.target))) {
-    if (rows.some((row) => row.target === target))
+  const statusesByTarget = new Map;
+  for (const status of statuses) {
+    const forTarget = statusesByTarget.get(status.target);
+    if (forTarget === undefined)
+      statusesByTarget.set(status.target, [status]);
+    else
+      forTarget.push(status);
+  }
+  const queuedByTarget = new Map;
+  for (const entry of stickyQueued) {
+    const target = entry.targetPath ?? entry.stageKey;
+    queuedByTarget.set(target, (queuedByTarget.get(target) ?? 0) + 1);
+  }
+  const rowTargets = new Set(rows.map((row) => row.target));
+  for (const target of statusesByTarget.keys()) {
+    if (rowTargets.has(target))
       continue;
-    rows.push({
-      target,
-      queuedCount: stickyQueued.filter((entry) => (entry.targetPath ?? entry.stageKey) === target).length,
-      deliveryOnly: true
-    });
+    rowTargets.add(target);
+    rows.push({ target, queuedCount: queuedByTarget.get(target) ?? 0, deliveryOnly: true });
   }
   for (let index = 0;index < rows.length; index++) {
     const row = rows[index];
-    const deliveryStates = statuses.filter((status) => status.target === row.target);
-    if (deliveryStates.length > 0)
+    const deliveryStates = statusesByTarget.get(row.target);
+    if (deliveryStates !== undefined)
       rows[index] = { ...row, deliveryStates };
   }
   return rows;
 }
-function materializedStageMatches(runs, rootRunId, entrySegments) {
-  for (const run of runs) {
-    if (durableRootRunIdForRun(runs, run.id) !== rootRunId)
-      continue;
-    const hops = workflowBoundaryHops(runs, run.id);
+function materializedStageMatcher(runs, rootRunId) {
+  const runById = new Map(runs.map((run) => [run.id, run]));
+  const hopsFor = createWorkflowBoundaryHopsResolver(runs);
+  const invocationRuns = runs.filter((run) => reciprocalWorkflowRootRunId(runById, run.id) === rootRunId);
+  return (entrySegments) => materializedStageMatches(invocationRuns, hopsFor, entrySegments);
+}
+function materializedStageMatches(invocationRuns, hopsFor, entrySegments) {
+  for (const run of invocationRuns) {
+    const hops = hopsFor(run.id);
     if (hops === undefined)
       continue;
     for (const stage of run.stages) {
@@ -58148,10 +58453,12 @@ async function recordConfirmedStickyDeliveries(activeStore, event) {
 }
 function matchingLiveStages(runs, rootRunId, patternSegments) {
   const matches = [];
+  const runById = new Map(runs.map((run) => [run.id, run]));
+  const hopsFor = createWorkflowBoundaryHopsResolver(runs);
   for (const run of runs) {
-    if (durableRootRunIdForRun(runs, run.id) !== rootRunId)
+    if (reciprocalWorkflowRootRunId(runById, run.id) !== rootRunId)
       continue;
-    const hops = workflowBoundaryHops(runs, run.id);
+    const hops = hopsFor(run.id);
     if (hops === undefined)
       continue;
     for (const stage of run.stages) {
@@ -58287,11 +58594,26 @@ function writeMessage(socket, msg, callback) {
 }
 function createMessageReader(onMessage, onError) {
   let buffer = Buffer.alloc(0);
+  let pending = [];
+  let pendingLength = 0;
+  let awaitedLength = 0;
   return (data) => {
-    buffer = Buffer.concat([buffer, data]);
+    if (pendingLength + data.length < awaitedLength) {
+      pending.push(data);
+      pendingLength += data.length;
+      return;
+    }
+    buffer = pending.length === 0 ? Buffer.concat([buffer, data]) : Buffer.concat([...pending, data]);
+    pending = [];
+    pendingLength = 0;
+    awaitedLength = 0;
     while (buffer.length >= 4) {
       const length = buffer.readUInt32BE(0);
       if (buffer.length < 4 + length) {
+        pending = [buffer];
+        pendingLength = buffer.length;
+        awaitedLength = 4 + length;
+        buffer = Buffer.alloc(0);
         break;
       }
       const payload = buffer.subarray(4, 4 + length);
@@ -58403,7 +58725,8 @@ function buildSendSignature(to, options) {
     attachments: canonicalizeAttachmentsForSendSignature(options.attachments) ?? [],
     replyTo: options.replyTo ?? null,
     expectsReply: options.expectsReply ?? false,
-    replyError: options.replyError ?? null
+    replyError: options.replyError ?? null,
+    ...options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery }
   });
 }
 
@@ -58589,6 +58912,8 @@ function isMessage(value2) {
     return false;
   if (message.expectsReply !== undefined && typeof message.expectsReply !== "boolean")
     return false;
+  if (message.delivery !== undefined && message.delivery !== "steer" && message.delivery !== "followUp" && message.delivery !== "interrupt")
+    return false;
   if (message.replyError !== undefined && typeof message.replyError !== "string")
     return false;
   if (message.source !== undefined && !isMessageSource(message.source))
@@ -59798,6 +60123,7 @@ var init_client = __esm(() => {
         timestamp: Date.now(),
         replyTo: options.replyTo,
         expectsReply: options.expectsReply,
+        ...options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery },
         replyError: options.replyError,
         source: this._messageSource,
         content: { text: options.text, attachments: options.attachments }