blun-king-cli 9.1.536 → 9.1.561

package/bin/assistant-message-offload-policy.cjs

@@ -4,6 +4,7 @@ const {
   hasHistoricalOffloadPressure,
   historyTextChars,
 } = require('./history-offload-pressure-policy.cjs');
+const { hasContextPressure } = require('./context-pressure-policy.cjs');
 
 const ASSISTANT_MESSAGE_MAX_CHARS = 4_000;
 const ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES = 20;
@@ -50,7 +51,8 @@ function shouldOffloadHistoricalAssistantMessage(options = {}) {
     || historyIndex >= historyLength
   ) return false;
   const cutoff = Math.max(0, historyLength - ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES);
-  return hasHistoricalOffloadPressure({ historyLength, historyChars })
+  return hasContextPressure(options)
+    && hasHistoricalOffloadPressure({ historyLength, historyChars })
     && historyIndex < cutoff
     && textChars > ASSISTANT_MESSAGE_MAX_CHARS;
 }

package/bin/compaction-transaction-policy.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+
+function toolCallId(call) {
+  return typeof call?.id === 'string' && call.id.length > 0 ? call.id : undefined;
+}
+
+function assertBalancedToolPairs(messages, label = 'compaction history') {
+  const pending = new Set();
+  for (const message of messages) {
+    if (message?.role === 'assistant') {
+      for (const call of message.toolCalls ?? []) {
+        const id = toolCallId(call);
+        if (id === undefined) throw new Error(`${label} contains a tool call without an id`);
+        if (pending.has(id)) throw new Error(`${label} contains duplicate tool call id ${id}`);
+        pending.add(id);
+      }
+      continue;
+    }
+    if (message?.role !== 'tool') continue;
+    const id = typeof message.toolCallId === 'string' ? message.toolCallId : undefined;
+    if (id === undefined || !pending.delete(id)) {
+      throw new Error(`${label} contains an orphan tool result${id ? ` ${id}` : ''}`);
+    }
+  }
+  if (pending.size > 0) {
+    throw new Error(`${label} contains ${pending.size} tool call(s) without results`);
+  }
+  return true;
+}
+
+function createCompactionTransaction({ source, turnId, tokensBefore, messageCountBefore }) {
+  const transaction = {
+    id: randomUUID(),
+    source,
+    turnId: turnId ?? null,
+    tokensBefore: positiveInteger(tokensBefore, 'tokensBefore'),
+    messageCountBefore: positiveInteger(messageCountBefore, 'messageCountBefore'),
+    state: 'started',
+  };
+  return {
+    transaction,
+    record: {
+      type: 'compaction/start',
+      compaction_id: transaction.id,
+      source: transaction.source,
+      turn_id: transaction.turnId,
+      size_before: transaction.tokensBefore,
+      message_count_before: transaction.messageCountBefore,
+      unit: 'tokens',
+    },
+  };
+}
+
+function summarizeCompactionTransaction(transaction, input) {
+  if (transaction?.state !== 'started') {
+    throw new Error('compaction/summary requires exactly one open compaction/start');
+  }
+  if (typeof input.summary !== 'string' || input.summary.trim().length === 0) {
+    throw new Error('compaction/summary requires non-empty model-visible summary text');
+  }
+  assertBalancedToolPairs(input.historyBefore, 'history before compaction');
+  assertBalancedToolPairs(input.historyAfter, 'history after compaction');
+  transaction.state = 'summarized';
+  transaction.tokensAfter = positiveInteger(input.tokensAfter, 'tokensAfter');
+  transaction.messageCountAfter = positiveInteger(input.messageCountAfter, 'messageCountAfter');
+  return {
+    type: 'compaction/summary',
+    compaction_id: transaction.id,
+    source: transaction.source,
+    turn_id: transaction.turnId,
+    summary: input.summary,
+    shadowed_token_count: transaction.tokensBefore,
+    size_before: transaction.tokensBefore,
+    size_after: transaction.tokensAfter,
+    message_count_before: transaction.messageCountBefore,
+    message_count_after: transaction.messageCountAfter,
+    tool_pairing_balanced_before: true,
+    tool_pairing_balanced_after: true,
+    unit: 'tokens',
+  };
+}
+
+function endCompactionTransaction(transaction, { status, error } = {}) {
+  if (transaction?.state === 'ended') return undefined;
+  if (transaction?.state !== 'started' && transaction?.state !== 'summarized') {
+    throw new Error('compaction/end requires an open compaction/start');
+  }
+  const normalizedStatus = status ?? 'success';
+  if (normalizedStatus === 'success' && transaction.state !== 'summarized') {
+    throw new Error('successful compaction/end requires one compaction/summary');
+  }
+  if (!['success', 'cancelled', 'failed'].includes(normalizedStatus)) {
+    throw new Error(`unsupported compaction status ${normalizedStatus}`);
+  }
+  transaction.state = 'ended';
+  return {
+    type: 'compaction/end',
+    compaction_id: transaction.id,
+    source: transaction.source,
+    turn_id: transaction.turnId,
+    status: normalizedStatus,
+    ...(transaction.tokensAfter === undefined ? {} : { size_after: transaction.tokensAfter }),
+    ...(typeof error === 'string' && error.length > 0 ? { error } : {}),
+    unit: 'tokens',
+  };
+}
+
+module.exports = {
+  assertBalancedToolPairs,
+  createCompactionTransaction,
+  endCompactionTransaction,
+  summarizeCompactionTransaction,
+};

package/bin/context-performance-policy.cjs

@@ -3,12 +3,9 @@
 const DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS = 256_000;
 const DEFAULT_COMPACTION_BLOCK_MAX_TOKENS = 288_000;
 
-function capCompactionThreshold(threshold, phase) {
+function capCompactionThreshold(threshold, _phase) {
   if (threshold === undefined) return undefined;
-  const maximum = phase === "block"
-    ? DEFAULT_COMPACTION_BLOCK_MAX_TOKENS
-    : DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS;
-  return Math.min(threshold, maximum);
+  return threshold;
 }
 
 module.exports = {

package/bin/context-pressure-policy.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const DEFAULT_CONTEXT_PRESSURE_RATIO = 0.75;
+
+function hasContextPressure(options = {}) {
+  if (typeof options.underPressure === 'boolean') return options.underPressure;
+  const overridePercent = Number((options.env ?? process.env).BLUN_CONTEXT_PRESSURE_PERCENT);
+  const pressureRatio = Number.isFinite(overridePercent)
+    && overridePercent > 0
+    && overridePercent <= 100
+    ? overridePercent / 100
+    : DEFAULT_CONTEXT_PRESSURE_RATIO;
+  return !Number.isFinite(options.contextUsageRatio)
+    || options.contextUsageRatio >= pressureRatio;
+}
+
+module.exports = {
+  DEFAULT_CONTEXT_PRESSURE_RATIO,
+  hasContextPressure,
+};

package/bin/cron-run-output.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+const fs = require('node:fs');
+
+const DEFAULT_MAX_CHARS = 16_384;
+
+function eventStepId(event, activeStepId) {
+  if (typeof event?.uuid === 'string') return event.uuid;
+  if (typeof event?.stepUuid === 'string') return event.stepUuid;
+  return activeStepId;
+}
+
+function readCronFinalMessage(wirePath, stepId, maxChars = DEFAULT_MAX_CHARS) {
+  if (typeof stepId !== 'string' || stepId.length === 0) return null;
+  if (!Number.isSafeInteger(maxChars) || maxChars < 1) throw new TypeError('maxChars must be positive');
+  let text = '';
+  let activeStepId = null;
+  const lines = fs.readFileSync(wirePath, 'utf8').split(/\r?\n/u);
+  for (const line of lines) {
+    if (line.length === 0) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record?.type !== 'context.append_loop_event') continue;
+    const event = record.event;
+    if (event?.type === 'step.begin') {
+      activeStepId = event.uuid;
+      continue;
+    }
+    if (event?.type === 'step.end') {
+      if (eventStepId(event, activeStepId) === stepId) activeStepId = null;
+      continue;
+    }
+    if (event?.type !== 'content.part' || eventStepId(event, activeStepId) !== stepId) continue;
+    if (event.part?.type === 'text' && typeof event.part.text === 'string') text += event.part.text;
+  }
+  if (text.length === 0) return null;
+  if (text.length <= maxChars) return {text, truncated: false, chars: text.length};
+  return {text: `${text.slice(0, maxChars)}\n...[truncated]`, truncated: true, chars: text.length};
+}
+
+module.exports = {DEFAULT_MAX_CHARS, readCronFinalMessage};

package/bin/cron-run-store.cjs

@@ -0,0 +1,145 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const {
+  isValidCronRunReceipt,
+  markCronJobDeleted,
+  transitionCronRunReceipt,
+} = require('./scoped-cron-run-policy.cjs');
+
+const RUN_ID_RE = /^[0-9a-f]{16}$/u;
+
+function atomicWriteJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), {recursive: true, mode: 0o700});
+  const tempPath = `${filePath}.tmp.${process.pid}.${crypto.randomBytes(4).toString('hex')}`;
+  fs.writeFileSync(tempPath, `${JSON.stringify(value)}\n`, {encoding: 'utf8', mode: 0o600, flag: 'wx'});
+  fs.renameSync(tempPath, filePath);
+}
+
+function createCronRunStore(sessionDir, options = {}) {
+  const rootDir = path.join(sessionDir, 'cron-runs');
+  const now = options.now || (() => Date.now());
+  const runs = new Map();
+
+  function filePath(runId) {
+    if (!RUN_ID_RE.test(runId)) throw new TypeError('Invalid cron run id');
+    return path.join(rootDir, `${runId}.json`);
+  }
+
+  function persist(receipt) {
+    atomicWriteJson(filePath(receipt.runId), receipt);
+  }
+
+  function create(receipt) {
+    if (!isValidCronRunReceipt(receipt) || receipt.status !== 'buffered') {
+      throw new TypeError('Invalid new cron run receipt');
+    }
+    if (runs.has(receipt.runId)) throw new Error(`Cron run already exists: ${receipt.runId}`);
+    runs.set(receipt.runId, receipt);
+    persist(receipt);
+    return receipt;
+  }
+
+  function replace(receipt) {
+    if (!isValidCronRunReceipt(receipt)) throw new TypeError('Invalid cron run receipt');
+    if (!runs.has(receipt.runId)) throw new Error(`Unknown cron run: ${receipt.runId}`);
+    runs.set(receipt.runId, receipt);
+    persist(receipt);
+    return receipt;
+  }
+
+  function transition(runId, status, details) {
+    const current = runs.get(runId);
+    if (current === undefined) throw new Error(`Unknown cron run: ${runId}`);
+    return replace(transitionCronRunReceipt(current, status, details));
+  }
+
+  function markJobDeletedById(jobId) {
+    const changed = [];
+    for (const receipt of runs.values()) {
+      if (receipt.jobId !== jobId || receipt.jobDeleted === true) continue;
+      changed.push(replace(markCronJobDeleted(receipt)));
+    }
+    return changed;
+  }
+
+  function load() {
+    runs.clear();
+    if (!fs.existsSync(rootDir)) return {loaded: 0, lost: 0, lostRunIds: []};
+    let loaded = 0;
+    let lost = 0;
+    const lostRunIds = [];
+    for (const entry of fs.readdirSync(rootDir, {withFileTypes: true})) {
+      if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+      const runId = entry.name.slice(0, -5);
+      if (!RUN_ID_RE.test(runId)) continue;
+      try {
+        const receipt = JSON.parse(fs.readFileSync(path.join(rootDir, entry.name), 'utf8'));
+        if (!isValidCronRunReceipt(receipt) || receipt.runId !== runId) continue;
+        let restored = receipt;
+        if (receipt.status === 'buffered' || receipt.status === 'running') {
+          restored = transitionCronRunReceipt(receipt, 'lost', {
+            endedAt: new Date(now()).toISOString(),
+          });
+          persist(restored);
+          lost += 1;
+          lostRunIds.push(runId);
+        }
+        runs.set(runId, restored);
+        loaded += 1;
+      } catch {}
+    }
+    return {loaded, lost, lostRunIds};
+  }
+
+  return Object.freeze({
+    create,
+    get: (runId) => runs.get(runId),
+    list: () => [...runs.values()],
+    load,
+    markJobDeletedById,
+    replace,
+    transition,
+  });
+}
+
+function createMemoryCronRunStore() {
+  const runs = new Map();
+  function replace(receipt) {
+    if (!isValidCronRunReceipt(receipt)) throw new TypeError('Invalid cron run receipt');
+    if (!runs.has(receipt.runId)) throw new Error(`Unknown cron run: ${receipt.runId}`);
+    runs.set(receipt.runId, receipt);
+    return receipt;
+  }
+  return Object.freeze({
+    create(receipt) {
+      if (!isValidCronRunReceipt(receipt) || receipt.status !== 'buffered') {
+        throw new TypeError('Invalid new cron run receipt');
+      }
+      if (runs.has(receipt.runId)) throw new Error(`Cron run already exists: ${receipt.runId}`);
+      runs.set(receipt.runId, receipt);
+      return receipt;
+    },
+    get: (runId) => runs.get(runId),
+    list: () => [...runs.values()],
+    load: () => ({loaded: 0, lost: 0, lostRunIds: []}),
+    markJobDeletedById(jobId) {
+      const changed = [];
+      for (const receipt of runs.values()) {
+        if (receipt.jobId !== jobId || receipt.jobDeleted === true) continue;
+        changed.push(replace(markCronJobDeleted(receipt)));
+      }
+      return changed;
+    },
+    replace,
+    transition(runId, status, details) {
+      const current = runs.get(runId);
+      if (current === undefined) throw new Error(`Unknown cron run: ${runId}`);
+      return replace(transitionCronRunReceipt(current, status, details));
+    },
+  });
+}
+
+module.exports = {createCronRunStore, createMemoryCronRunStore};

package/bin/default-model-output-budget-policy.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+const DEFAULT_MODEL_ALIAS = 'blun/king';
+const DEFAULT_MAX_OUTPUT_SIZE = 128000;
+
+function applyDefaultModelOutputBudget(config) {
+  const models = config?.models;
+  const model = models?.[DEFAULT_MODEL_ALIAS];
+
+  if (!model || model.maxOutputSize !== undefined) return config;
+
+  return {
+    ...config,
+    models: {
+      ...models,
+      [DEFAULT_MODEL_ALIAS]: {
+        ...model,
+        maxOutputSize: DEFAULT_MAX_OUTPUT_SIZE,
+      },
+    },
+  };
+}
+
+module.exports = {
+  DEFAULT_MAX_OUTPUT_SIZE,
+  DEFAULT_MODEL_ALIAS,
+  applyDefaultModelOutputBudget,
+};

package/bin/durable-task-resume-policy.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const INTERRUPTED_TOOL_REMINDER = [
+  "The previous process ended during this agent's work.",
+  'An in-flight tool call may have completed without its result being observed.',
+  'Inspect current state before repeating any side effect.',
+].join(' ');
+
+const TASK_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-z]{8}$/u;
+const DIGEST_PATTERN = /^[0-9a-f]{64}$/u;
+const FAILURE_CATEGORIES = new Set(['validation', 'conflict', 'launcher', 'persistence', 'unknown']);
+const INTENT_KEYS = new Set([
+  'version',
+  'status',
+  'sourceTaskId',
+  'replacementTaskId',
+  'agentId',
+  'resumeRootTaskId',
+  'requestDigest',
+  'createdAt',
+  'startedAt',
+]);
+
+function contractError(message, category = 'validation') {
+  const error = new Error(message);
+  error.code = 'ERR_DURABLE_TASK_RESUME';
+  error.category = FAILURE_CATEGORIES.has(category) ? category : 'unknown';
+  return error;
+}
+
+function assertTaskId(value, field = 'task ID') {
+  if (typeof value !== 'string' || !TASK_ID_PATTERN.test(value)) {
+    throw contractError(`${field} is invalid`);
+  }
+  return value;
+}
+
+function assertText(value, field, maxBytes) {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw contractError(`${field} is required`);
+  }
+  if (Buffer.byteLength(value, 'utf8') > maxBytes) {
+    throw contractError(`${field} is too large`);
+  }
+  return value;
+}
+
+function requestDigest(prompt, description) {
+  assertText(prompt, 'prompt', 32 * 1024);
+  assertText(description, 'description', 1024);
+  return crypto.createHash('sha256')
+    .update(JSON.stringify({ prompt, description }))
+    .digest('hex');
+}
+
+function isResumedSuccessor(task) {
+  return task.status === 'completed'
+    && task.resumed === true
+    && typeof task.replacesTaskId === 'string'
+    && typeof task.resumeRootTaskId === 'string';
+}
+
+function validateResumeSource(task) {
+  if (!task
+      || task.kind !== 'agent'
+      || typeof task.agentId !== 'string'
+      || task.agentId.length === 0
+      || (task.status !== 'lost' && !isResumedSuccessor(task))) {
+    throw contractError('Task is not a recoverable agent task. Only a lost agent task or a completed TaskResume successor can be resumed.');
+  }
+  assertTaskId(task.taskId);
+  return task;
+}
+
+function createPreparedIntent({ source, replacementTaskId, digest, now }) {
+  validateResumeSource(source);
+  assertTaskId(replacementTaskId, 'replacement task ID');
+  if (replacementTaskId === source.taskId) {
+    throw contractError('Replacement task ID must differ from source task ID', 'conflict');
+  }
+  if (typeof digest !== 'string' || !DIGEST_PATTERN.test(digest)) {
+    throw contractError('request digest is invalid');
+  }
+  if (!Number.isFinite(now)) throw contractError('intent timestamp is invalid');
+  return {
+    version: 1,
+    status: 'prepared',
+    sourceTaskId: source.taskId,
+    replacementTaskId,
+    agentId: source.agentId,
+    resumeRootTaskId: source.resumeRootTaskId || source.taskId,
+    requestDigest: digest,
+    createdAt: now,
+  };
+}
+
+function isResumeIntent(value) {
+  if (!value || typeof value !== 'object') return false;
+  if (Object.keys(value).some((key) => !INTENT_KEYS.has(key))) return false;
+  if (value.version !== 1 || (value.status !== 'prepared' && value.status !== 'started')) return false;
+  if (!TASK_ID_PATTERN.test(value.sourceTaskId) || !TASK_ID_PATTERN.test(value.replacementTaskId)) return false;
+  if (typeof value.agentId !== 'string' || value.agentId.length === 0) return false;
+  if (!TASK_ID_PATTERN.test(value.resumeRootTaskId) || !DIGEST_PATTERN.test(value.requestDigest)) return false;
+  if (!Number.isFinite(value.createdAt)) return false;
+  if (value.status === 'started' && !Number.isFinite(value.startedAt)) return false;
+  return true;
+}
+
+function decorateTaskInfo(task, intent) {
+  if (!task || !intent || intent.sourceTaskId !== task.taskId) return task;
+  return { ...task, replacementTaskId: intent.replacementTaskId };
+}
+
+function failureCategory(error) {
+  return FAILURE_CATEGORIES.has(error && error.category) ? error.category : 'launcher';
+}
+
+module.exports = {
+  INTERRUPTED_TOOL_REMINDER,
+  TASK_ID_PATTERN,
+  contractError,
+  createPreparedIntent,
+  decorateTaskInfo,
+  failureCategory,
+  isResumeIntent,
+  requestDigest,
+  validateResumeSource,
+};

package/bin/durable-task-resume-runtime.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+const {
+  INTERRUPTED_TOOL_REMINDER,
+  contractError,
+  createPreparedIntent,
+  failureCategory,
+  requestDigest,
+  validateResumeSource,
+} = require('./durable-task-resume-policy.cjs');
+
+class DurableTaskResumeRuntime {
+  constructor(adapters) {
+    this.adapters = adapters;
+    this.inFlightSources = new Set();
+  }
+
+  async resolveIntent(source, digest, now) {
+    const existing = this.adapters.getIntent(source.taskId);
+    if (existing) {
+      const successor = this.adapters.getTask(existing.replacementTaskId);
+      if (successor || existing.status === 'started') {
+        throw contractError(`Task ${source.taskId} already has successor ${existing.replacementTaskId}`, 'conflict');
+      }
+      if (existing.requestDigest !== digest) {
+        throw contractError('Resume request differs from prepared intent', 'conflict');
+      }
+      return existing;
+    }
+    const replacementTaskId = this.adapters.reserveTaskId('agent');
+    const intent = createPreparedIntent({ source, replacementTaskId, digest, now });
+    await this.adapters.writeIntent(intent);
+    this.adapters.emitEvent({
+      type: 'background.task.resume_requested',
+      sourceTaskId: intent.sourceTaskId,
+      replacementTaskId: intent.replacementTaskId,
+      agentId: intent.agentId,
+    });
+    return intent;
+  }
+
+  async resume(input) {
+    const runSignal = input.controller ? input.controller.signal : input.signal;
+    runSignal.throwIfAborted();
+    if (this.inFlightSources.has(input.taskId)) {
+      throw contractError(`Task ${input.taskId} already has a resume request in flight`, 'conflict');
+    }
+    this.inFlightSources.add(input.taskId);
+    try {
+      const source = validateResumeSource(this.adapters.getTask(input.taskId));
+      const digest = requestDigest(input.prompt, input.description);
+      const now = this.adapters.now();
+      let intent;
+      try {
+        intent = await this.resolveIntent(source, digest, now);
+        runSignal.throwIfAborted();
+        const handle = await this.adapters.resumeAgent(intent.agentId, {
+          parentToolCallId: input.parentToolCallId,
+          prompt: input.prompt,
+          description: input.description,
+          runInBackground: true,
+          responseFormat: undefined,
+          toolScope: input.toolScope,
+          signal: runSignal,
+          systemReminder: INTERRUPTED_TOOL_REMINDER,
+        });
+        if (!handle || handle.agentId !== intent.agentId) {
+          throw contractError('Resume launcher changed the preserved agent identity', 'launcher');
+        }
+        const metadata = {
+          timeoutMinutes: input.timeoutMinutes,
+          parentToolCallId: input.parentToolCallId,
+          controller: input.controller,
+          replacesTaskId: intent.sourceTaskId,
+          resumeRootTaskId: intent.resumeRootTaskId,
+        };
+        const task = this.adapters.createTask(handle, input.description, metadata);
+        const registeredTaskId = this.adapters.registerTask(task, {
+          detached: true,
+          taskId: intent.replacementTaskId,
+        });
+        if (registeredTaskId !== intent.replacementTaskId) {
+          throw contractError('Background manager did not honor the reserved replacement task ID', 'launcher');
+        }
+        await this.adapters.awaitTaskPersisted(registeredTaskId);
+        await this.adapters.markIntentStarted(intent.sourceTaskId, now);
+        this.adapters.emitEvent({
+          type: 'background.task.resumed',
+          sourceTaskId: intent.sourceTaskId,
+          replacementTaskId: intent.replacementTaskId,
+          agentId: intent.agentId,
+        });
+        return {
+          taskId: registeredTaskId,
+          agentId: intent.agentId,
+          replacesTaskId: intent.sourceTaskId,
+          resumeRootTaskId: intent.resumeRootTaskId,
+          status: 'running',
+        };
+      } catch (error) {
+        if (intent) {
+          this.adapters.emitEvent({
+            type: 'background.task.resume_failed',
+            sourceTaskId: intent.sourceTaskId,
+            replacementTaskId: intent.replacementTaskId,
+            category: failureCategory(error),
+          });
+        }
+        throw error;
+      }
+    } finally {
+      this.inFlightSources.delete(input.taskId);
+    }
+  }
+}
+
+module.exports = { DurableTaskResumeRuntime };