libfx 0.0.13-dev.1472.g2c7a4f83f06f → 0.0.13-dev.1510.ga878d4900a6a

package/node.cjs

@@ -53,6 +53,7 @@ __export(exports_node, {
   listModels: () => listModels,
   memory: () => memory,
   supportsJspi: () => supportsJspi,
+  wakeHandler: () => wakeHandler,
   xtermAdapter: () => xtermAdapter
 });
 module.exports = __toCommonJS(exports_node);
@@ -214,8 +215,10 @@ var idRule = "1 to 128 letters, digits, '.', '_' or '-'";
 var newId = (prefix) => `${prefix}_${crypto.randomUUID().replaceAll("-", "")}`;
 var defaultReserveMs = 30000;
 var defaultLeaseMs = 15000;
+var queueHeld = (backend, deadline) => !backend.livenessKnown && backend.queueLeases === true && deadline !== null;
+var heldToDeadline = (backend, deadline) => backend.livenessKnown || queueHeld(backend, deadline);
 function leaseEnd(backend, deadline) {
-  if (backend.livenessKnown)
+  if (heldToDeadline(backend, deadline))
     return deadline;
   const renewed = Date.now() + backend.leaseMs;
   return deadline === null ? renewed : Math.min(renewed, deadline);
@@ -285,6 +288,7 @@ function foldSessionLog(entries, { now = 0, alive = () => null } = {}) {
   const records = [];
   let openTurn = typeof base?.openTurn?.id === "string" ? { id: base.openTurn.id, at: Number(base.openTurn.at) || 0, context: base.openTurn.context ?? null, settings: base.openTurn.settings ?? null } : null;
   let lastTurnId = base?.lastTurnId ?? null;
+  let agent = typeof base?.agent === "string" ? base.agent : base && base.through != null ? defaultAgentName : null;
   let yielded = base?.yielded === true;
   const contexts = new Map;
   const settingsOf = new Map;
@@ -316,6 +320,7 @@ function foldSessionLog(entries, { now = 0, alive = () => null } = {}) {
       maxCursor = position;
     switch (entry?.k) {
       case "input":
+        agent ??= typeof entry.agent === "string" ? entry.agent : defaultAgentName;
         if (seenInputs.has(entry.key))
           break;
         seenInputs.add(entry.key);
@@ -332,7 +337,7 @@ function foldSessionLog(entries, { now = 0, alive = () => null } = {}) {
           break;
         head = cursor;
         if (entry.k === "lease") {
-          lease = { holder: entry.holder, epoch: entry.epoch, expiresAt: entry.expiresAt ?? null, pid: entry.pid, host: entry.host, cursor };
+          lease = { holder: entry.holder, epoch: entry.epoch, expiresAt: entry.expiresAt ?? null, pid: entry.pid, host: entry.host, delivery: entry.delivery, cursor };
           if (Number.isSafeInteger(entry.epoch) && entry.epoch > epoch)
             epoch = entry.epoch;
         } else if (entry.k === "release") {
@@ -427,6 +432,7 @@ function foldSessionLog(entries, { now = 0, alive = () => null } = {}) {
     cutoffs: openTurn === null ? 0 : cut.cutoffs,
     openFailed,
     lastTurnId,
+    agent,
     yielded,
     pending,
     steers,
@@ -452,11 +458,19 @@ function leaseStands(lease, now, alive) {
     return false;
   return true;
 }
+function deliveryOf(meta) {
+  const messageId = meta?.messageId;
+  const attempt = meta?.attempt;
+  return typeof messageId === "string" && messageId.length > 0 && Number.isSafeInteger(attempt) && attempt > 0 ? { messageId, attempt } : null;
+}
+function redelivers(delivery, lease) {
+  const held = lease?.delivery;
+  return Boolean(delivery && held && held.messageId === delivery.messageId && Number.isSafeInteger(held.attempt) && delivery.attempt >= held.attempt);
+}
 function createMemoryBackend({ maxDurationMs, reserveMs } = {}) {
   const sessions = new Map;
   const holders = liveHolders;
-  const handlers = [];
-  let turnOf = 0;
+  const handlers = new Map;
   const timers = new Set;
   const sessionFor = (id) => {
     let session = sessions.get(id);
@@ -473,21 +487,28 @@ function createMemoryBackend({ maxDurationMs, reserveMs } = {}) {
     }, ms);
     timers.add(timer);
   };
-  const deliver = (message, attempt) => {
-    if (handlers.length === 0)
-      return later(() => deliver(message, attempt), 10);
-    const handler = handlers[turnOf++ % handlers.length];
-    Promise.resolve().then(() => handler(message, { attempt })).then((result) => {
+  const deliver = (message, attempt, messageId = newId("qmsg")) => {
+    if (handlers.size === 0)
+      return later(() => deliver(message, attempt, messageId), 10);
+    const group = handlers.get(agentOf(message));
+    if (!group) {
+      if (attempt < 48)
+        later(() => deliver(message, attempt + 1, messageId), 1000);
+      return;
+    }
+    const handler = group.members[group.turn++ % group.members.length];
+    Promise.resolve().then(() => handler(message, { messageId, attempt })).then((result) => {
       if (Number.isFinite(result?.timeoutSeconds))
-        later(() => deliver(message, attempt + 1), result.timeoutSeconds * 1000);
+        later(() => deliver(message, attempt + 1, messageId), result.timeoutSeconds * 1000);
     }, () => {
       if (attempt < 48)
-        later(() => deliver(message, attempt + 1), 1000);
+        later(() => deliver(message, attempt + 1, messageId), 1000);
     });
   };
   return {
     name: "memory",
     livenessKnown: true,
+    runInRequest: false,
     queueDurable: false,
     pollMs: null,
     reserveMs: reserveMs ?? defaultReserveMs,
@@ -580,13 +601,11 @@ function createMemoryBackend({ maxDurationMs, reserveMs } = {}) {
         later(() => deliver(message, 1), delaySeconds * 1000);
       }
     },
-    listen(fn) {
-      handlers.push(fn);
+    listen(fn, name = defaultAgentName) {
+      const group = joinGroup(handlers, name, fn);
       return () => {
-        const index = handlers.indexOf(fn);
-        if (index >= 0)
-          handlers.splice(index, 1);
-        if (handlers.length > 0)
+        leaveGroup(handlers, name, group, fn);
+        if (handlers.size > 0)
           return;
         for (const timer of timers)
           clearTimeout(timer);
@@ -598,6 +617,9 @@ function createMemoryBackend({ maxDurationMs, reserveMs } = {}) {
 var logStep = "fx.log";
 var uiStreamOf = (runId) => `${runId.replace(/^wrun_/, "strm_")}_user_bGliZngtdWk`;
 var queuePrefix = "__libfx_wkf_workflow_";
+var defaultAgentName = "default";
+var agentNameRule = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var agentOf = (message) => typeof message?.agent === "string" ? message.agent : defaultAgentName;
 var queueName = `${queuePrefix}session`;
 var eventIdPattern = /^[a-z]+_(\d{26})$/;
 function ulid(now = Date.now()) {
@@ -610,6 +632,13 @@ function ulid(now = Date.now()) {
     random += alphabet[byte % 32];
   return time + random;
 }
+function chainedKind(k) {
+  return k === "lease" || k === "release" || k === "record";
+}
+var inBandAtRunCreation = 1;
+function inBandSuperseded(error) {
+  return error?.name === "InBandSupersededError" || error?.code === "in-band-superseded" || error?.status === 412;
+}
 function slotOf(event) {
   const match = eventIdPattern.exec(String(event?.eventId ?? ""));
   if (!match)
@@ -635,7 +664,56 @@ var missingStreamFastMs = 2000;
 var firstPageEvents = 10;
 var laterPageEvents = 100;
 var listenersOf = new WeakMap;
-function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, holderInfo, livenessKnown = false, queueDurable = false, maxDurationMs, owned = true }) {
+function joinGroup(groups, name, member) {
+  let group = groups.get(name);
+  if (!group)
+    groups.set(name, group = { members: [], turn: 0 });
+  group.members.push(member);
+  return group;
+}
+function leaveGroup(groups, name, group, member) {
+  const index = group.members.indexOf(member);
+  if (index >= 0)
+    group.members.splice(index, 1);
+  if (group.members.length === 0 && groups.get(name) === group)
+    groups.delete(name);
+}
+function noAgentNamed(name) {
+  return Object.assign(new Error(`no libfx agent named ${JSON.stringify(name)} runs in this process; the queue delivers this again`), { code: "FX_NO_AGENT", agent: name });
+}
+var agentsByName = globalThis[Symbol.for("libfx.durableAgents")] ??= new Map;
+async function agentNamed(name, matches) {
+  const group = agentsByName.get(name);
+  if (!group)
+    return null;
+  const { members } = group;
+  const first = group.turn++;
+  for (let index = 0;index < members.length; index += 1) {
+    const member = members[(first + index) % members.length];
+    if (!matches(await member.durability()))
+      continue;
+    const created = await member.open();
+    if (typeof created.deliverHere === "function")
+      return created;
+  }
+  return null;
+}
+var agentSharing = (name, durability) => agentNamed(name, (other) => other === durability);
+var agentOnRoute = async (name, durability) => await agentSharing(name, durability) ?? agentNamed(name, (other) => other !== durability && other.name === durability.name && typeof other.world === "function" && other.create === undefined);
+function wakeHandler() {
+  return async (request) => {
+    for (const group of agentsByName.values()) {
+      for (const member of group.members) {
+        const created = await member.open();
+        if (created.viaRoute === true)
+          return created.queueHandler(request);
+      }
+    }
+    return new Response("no libfx agent in this process takes queue deliveries from a route", { status: 503 });
+  };
+}
+function createWorldBackend(world, durability) {
+  const { name, reserveMs, pollMs, leaseMs, alive, holderInfo, livenessKnown = false, queueLeases = false, runInRequest = queueLeases, waitUntil, queueDurable = false, maxDurationMs, owned = true } = durability;
   const spec = world.specVersion === undefined ? {} : { specVersion: world.specVersion };
   const created = new Set;
   const creating = new Map;
@@ -651,7 +729,7 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
     pagination: { sortOrder: "desc", limit, ...cursor ? { cursor } : {} },
     resolveData: "all"
   });
-  const deliverTo = async (handle, message) => {
+  const deliverTo = async (handle, message, meta) => {
     const input = message?.input;
     if (!input || typeof input !== "object")
       return;
@@ -660,13 +738,24 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
         return;
       throw new Error("no libfx agent is listening; the queue delivers this again");
     }
-    const result = await handle(input);
+    const result = await handle(input, meta);
+    if (result?.redeliver === true)
+      throw new Error("libfx asks the queue to deliver this message again");
     return Number.isFinite(result?.timeoutSeconds) ? { timeoutSeconds: result.timeoutSeconds } : undefined;
   };
-  const queueHandler = world.createQueueHandler(queuePrefix, (message) => deliverTo(handler, message));
+  const queueHandler = world.createQueueHandler(queuePrefix, async (message, meta) => {
+    const named = agentOf(message?.input);
+    const agent = await agentOnRoute(named, durability);
+    if (!agent)
+      throw noAgentNamed(named);
+    return agent.deliverHere(message, meta);
+  });
   const backend = {
     name,
     livenessKnown,
+    queueLeases,
+    runInRequest: queueLeases && runInRequest,
+    waitUntil: waitUntil ?? null,
     queueDurable,
     pollMs: pollMs ?? 1000,
     reserveMs: reserveMs ?? defaultReserveMs,
@@ -677,10 +766,14 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
     validSessionId: (id) => typeof id === "string" && /^wrun_[0-9A-Za-z]{10,64}$/.test(id),
     deadline: () => null,
     holderInfo: holderInfo ?? (() => ({})),
-    alive(lease) {
+    alive(lease, delivery = null) {
+      if (liveHolders.has(lease.holder))
+        return true;
       const mine = holderInfo?.() ?? {};
       if (mine.pid !== undefined && lease.pid === mine.pid && lease.host === mine.host)
-        return liveHolders.has(lease.holder);
+        return false;
+      if (redelivers(delivery, lease))
+        return false;
       return alive ? alive(lease) : null;
     },
     holding(holder, held) {
@@ -708,6 +801,21 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
     },
     async session(runId) {
       let known = 0;
+      const inBandAt = new Map;
+      let inBand = world.capabilities?.inBandFence === true;
+      const noteInBand = (cursor, count) => {
+        inBandAt.delete(cursor);
+        inBandAt.set(cursor, count);
+        if (inBandAt.size > 16)
+          inBandAt.delete(inBandAt.keys().next().value);
+      };
+      const noteSnapshot = (snapshot, cursor) => {
+        if (!inBand || cursor === undefined || inBandAt.has(cursor) || !Number.isSafeInteger(snapshot?.seqInBand))
+          return;
+        if (cursor !== "null" && !(Number(cursor) <= snapshot.seq))
+          return;
+        noteInBand(cursor, snapshot.seqInBand);
+      };
       const ensureRun = () => {
         if (created.has(runId))
           return Promise.resolve();
@@ -741,34 +849,45 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
       const newestFirst = async (stopBelow, stopAtCheckpoint) => {
         const events = [];
         let through = null;
+        let snapshot;
+        let newestChained;
+        const done = (head) => {
+          noteSnapshot(snapshot, newestChained ?? head);
+          return { events, through };
+        };
         for (let cursor, limit = firstPageEvents;; limit = laterPageEvents) {
           let page;
           try {
             page = await listEvents(runId, cursor, limit);
           } catch (error) {
-            if (missingRun(error))
-              return { events, through };
-            throw error;
+            if (!missingRun(error))
+              throw error;
+            if (stopBelow === 0)
+              noteSnapshot({ seq: 0, seqInBand: inBandAtRunCreation }, "null");
+            return { events, through };
           }
+          snapshot ??= page.snapshot;
           for (const event of page.data) {
             const slot = slotOf(event);
             if (slot > known)
               known = slot;
             if (slot <= stopBelow)
-              return { events, through };
+              return done(undefined);
             if (through !== null && slot <= through)
-              return { events, through };
+              return done(through === 0 ? "null" : String(through));
             const entry = logEntryOf(event);
             if (!entry)
               continue;
             created.add(runId);
+            if (newestChained === undefined && chainedKind(entry.k))
+              newestChained = String(slot);
             events.push({ cursor: String(slot), entry });
             if (stopAtCheckpoint && through === null && entry.k === "checkpoint") {
               through = entry.through === null || entry.through === undefined ? 0 : Number(entry.through);
             }
           }
           if (!page.hasMore)
-            return { events, through };
+            return done(stopBelow > 0 ? undefined : through ? String(through) : "null");
           cursor = page.cursor;
         }
       };
@@ -783,16 +902,50 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
         },
         async append(entry) {
           await ensureRun();
-          const chained = entry.k === "lease" || entry.k === "release" || entry.k === "record";
+          const chained = chainedKind(entry.k);
           const after = chained ? entry.a === null || entry.a === undefined ? 0 : Number(entry.a) : known;
-          const result = await world.events.create(runId, {
+          const continues = entry.a === null || entry.a === undefined ? "null" : String(entry.a);
+          let expected = chained && inBand ? inBandAt.get(continues) : undefined;
+          const event = {
             eventType: "step_created",
             correlationId: `step_${ulid()}`,
             eventData: { stepName: logStep, input: encoder.encode(JSON.stringify(entry)) }
-          }, { eventCount: after });
+          };
+          let result;
+          for (let recounted = false;; ) {
+            try {
+              result = await world.events.create(runId, event, expected === undefined ? { eventCount: after } : { eventCount: after, inBand: true, expectedSeqInBand: expected });
+              break;
+            } catch (error) {
+              if (expected === undefined)
+                throw error;
+              if (inBandSuperseded(error)) {
+                inBandAt.delete(continues);
+                if (!recounted && Number.isSafeInteger(error?.seqInBand)) {
+                  const { events: since } = await newestFirst(after, false);
+                  const rivals = since.filter(({ entry: other }) => chainedKind(other.k) && (other.a ?? null) === (entry.a ?? null));
+                  const ours = rivals.find(({ entry: other }) => other.key !== undefined && other.key === entry.key && other.k === entry.k);
+                  if (ours)
+                    return ours.cursor;
+                  if (rivals.length === 0) {
+                    recounted = true;
+                    expected = error.seqInBand;
+                    continue;
+                  }
+                }
+                throw new FencedError(`another worker continued session ${runId}`);
+              }
+              if (!(error?.status >= 400 && error?.status < 500) || error?.status === 409)
+                throw error;
+              inBand = false;
+              expected = undefined;
+            }
+          }
           const slot = slotOf(result.event);
           if (slot > known)
             known = slot;
+          if (expected !== undefined && result.allocated !== undefined)
+            noteInBand(String(slot), expected + result.allocated);
           changed(runId);
           if (!chained || slot === after + 1)
             return String(slot);
@@ -802,7 +955,7 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
             const otherSlot = event.entry ? Number(event.cursor) : slotOf(event);
             if (!other || otherSlot <= after || otherSlot >= slot)
               continue;
-            const otherChained = other.k === "lease" || other.k === "release" || other.k === "record";
+            const otherChained = chainedKind(other.k);
             if (!otherChained || (other.a ?? null) !== (entry.a ?? null))
               continue;
             if (other.key !== undefined && other.key === entry.key && other.k === entry.k)
@@ -875,14 +1028,18 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
     },
     queue: {
       async send(message, { delaySeconds = 0, idempotencyKey } = {}) {
-        await world.queue(queueName, { runId: message.sessionId, requestId: message.messageId, input: message }, {
+        const sent = await world.queue(queueName, { runId: message.sessionId, requestId: message.messageId, input: message }, {
           ...idempotencyKey ? { idempotencyKey } : {},
           ...delaySeconds > 0 ? { delaySeconds } : {}
         });
+        return typeof sent?.messageId === "string" && sent.messageId.length > 0 ? { messageId: sent.messageId } : {};
       }
     },
     queueHandler,
-    listen(fn) {
+    durability,
+    viaRoute: route,
+    deliverHere: (message, meta) => deliverTo(handler, message, meta),
+    listen(fn, name = defaultAgentName) {
       handler = fn;
       if (route)
         return () => {
@@ -891,20 +1048,26 @@ function createWorldBackend(world, { name, reserveMs, pollMs, leaseMs, alive, ho
         };
       let listeners = listenersOf.get(world);
       if (!listeners) {
-        listeners = { handlers: [], turn: 0 };
+        listeners = new Map;
         listenersOf.set(world, listeners);
-        world.registerHandler(queuePrefix, world.createQueueHandler(queuePrefix, (message) => {
-          const { handlers } = listeners;
-          return deliverTo(handlers.length === 0 ? null : handlers[listeners.turn++ % handlers.length], message);
+        world.registerHandler(queuePrefix, world.createQueueHandler(queuePrefix, async (message, meta) => {
+          const named = agentOf(message?.input);
+          const group = listeners.get(named);
+          if (group)
+            return deliverTo(group.members[group.turn++ % group.members.length], message, meta);
+          const agent = await agentSharing(named, durability);
+          if (agent)
+            return agent.deliverHere(message, meta);
+          if (listeners.size === 0)
+            return deliverTo(null, message, meta);
+          throw noAgentNamed(named);
         }));
       }
-      listeners.handlers.push(fn);
+      const group = joinGroup(listeners, name, fn);
       return () => {
         if (handler === fn)
           handler = null;
-        const index = listeners.handlers.indexOf(fn);
-        if (index >= 0)
-          listeners.handlers.splice(index, 1);
+        leaveGroup(listeners, name, group, fn);
       };
     },
     async close() {
@@ -946,8 +1109,9 @@ var errorSummary = (error) => ({ name: error?.name ?? "Error", message: String(e
 var isFenced = (error) => error?.code === "FX_FENCED";
 function messageEntries(state, message) {
   const entries = [];
+  const named = typeof message.agent === "string" ? { agent: message.agent } : {};
   if (message.seed && state.checkpoint === null && state.records.length === 0) {
-    entries.push({ k: "checkpoint", through: null, data: message.seed });
+    entries.push({ k: "checkpoint", through: null, data: message.seed, ...named });
   }
   const key = `${message.type}:${message.messageId}`;
   const known = state.inputKeys.has(key) || state.consumed.has(message.messageId);
@@ -957,6 +1121,7 @@ function messageEntries(state, message) {
       key,
       type: message.type,
       messageId: message.messageId,
+      ...named,
       ...message.input === undefined ? {} : { input: message.input },
       ...typeof message.target === "string" ? { target: message.target } : {},
       ...(message.type === "prompt" || message.type === "steer") && message.context !== undefined ? { context: message.context } : {},
@@ -1000,6 +1165,8 @@ function gatedLog(log, ready, claimError) {
 var hardStopMs = 2000;
 var durableInternals = Symbol.for("libfx.durableInternals");
 var runningBackstopSeconds = 2;
+var deliveryDeadline = (backend) => backend.deadline() ?? (backend.maxDurationMs === null ? null : Date.now() + backend.maxDurationMs);
+var inlineBackstopMarginSeconds = 5;
 
 class SessionWorker {
   constructor(agent, backend, sessionId) {
@@ -1010,24 +1177,32 @@ class SessionWorker {
     this.deliveries = 0;
     this.holder = null;
   }
-  fold(entries) {
-    return foldSessionLog(entries, { now: Date.now(), alive: (lease) => this.backend.alive(lease) });
+  fold(entries, delivery = null) {
+    return foldSessionLog(entries, { now: Date.now(), alive: (lease) => this.backend.alive(lease, delivery) });
   }
-  async consume(message) {
+  async consume(message, delivery = null) {
     const log = await this.backend.session(this.sessionId);
     await this.backend.refreshDeadline?.();
     const deadline = this.backend.deadline() ?? (this.backend.maxDurationMs === null ? null : Date.now() + this.backend.maxDurationMs);
     let entries = await log.read();
-    let state = this.fold(entries);
+    let state = this.fold(entries, delivery);
+    const owner = state.agent ?? agentOf(message);
+    if (owner !== this.agent.name) {
+      await this.backend.queue.send({ ...message, agent: owner }, {
+        idempotencyKey: `${message.sessionId}:${message.type}:${message.messageId}:to:${owner}`
+      });
+      this.agent.emit("session.forwarded", { sessionId: this.sessionId, agent: owner });
+      return;
+    }
     for (let claims = 0;claims < 8; claims += 1) {
-      const early = this.running || state.lease ? null : earlyStart(entries, state, message, (items) => this.fold(items));
+      const early = this.running || state.lease ? null : earlyStart(entries, state, message, (items) => this.fold(items, delivery));
       let outcome;
       if (early) {
-        outcome = await this.claim(log, state, deadline, early);
+        outcome = await this.claim(log, state, deadline, early, delivery);
       } else {
         if (await recordMessage(log, state, message) > 0) {
           entries = await log.read();
-          state = this.fold(entries);
+          state = this.fold(entries, delivery);
         }
         if (this.running)
           return { timeoutSeconds: runningBackstopSeconds };
@@ -1040,22 +1215,22 @@ class SessionWorker {
           const left = state.lease.expiresAt ? Math.ceil((state.lease.expiresAt - Date.now()) / 1000) + 1 : 5;
           return { timeoutSeconds: Math.max(1, Math.min(maxBackstopSeconds, left)) };
         }
-        outcome = await this.claim(log, state, deadline, null);
+        outcome = await this.claim(log, state, deadline, null, delivery);
       }
       if (outcome === "yielded")
         return { timeoutSeconds: 0 };
       if (outcome === "failed")
-        return { timeoutSeconds: 1 };
+        return queueHeld(this.backend, deadline) ? { redeliver: true } : { timeoutSeconds: 1 };
       if (outcome === "fenced") {
         this.agent.emit("session.fenced", { sessionId: this.sessionId, epoch: state.lastEpoch + 1 });
         return;
       }
       entries = await log.read();
-      state = this.fold(entries);
+      state = this.fold(entries, delivery);
     }
     return { timeoutSeconds: 1 };
   }
-  async claim(log, state, deadline, early) {
+  async claim(log, state, deadline, early, delivery = null) {
     this.running = true;
     this.holder = newId("wkr");
     const lease = {
@@ -1064,7 +1239,8 @@ class SessionWorker {
       holder: this.holder,
       epoch: state.lastEpoch + 1,
       expiresAt: leaseEnd(this.backend, deadline),
-      ...this.backend.holderInfo()
+      ...this.backend.holderInfo(),
+      ...delivery ? { delivery } : {}
     };
     this.backend.holding(this.holder, true);
     try {
@@ -1186,19 +1362,20 @@ class SessionWorker {
           pending: now.unconsumed.filter((input) => input.cursor <= Number(through)),
           recent: now.recent,
           lastTurnId: now.lastTurnId,
+          ...now.agent === null ? {} : { agent: now.agent },
           ...now.openTurn ? { openTurn: now.openTurn, yielded: now.yielded } : {},
-          lease: { holder: this.holder, epoch: lease.epoch, expiresAt: leaseExpiresAt, pid: lease.pid, host: lease.host }
+          lease: { holder: this.holder, epoch: lease.epoch, expiresAt: leaseExpiresAt, pid: lease.pid, host: lease.host, ...lease.delivery ? { delivery: lease.delivery } : {} }
         });
       }
     };
     let turnNow = null;
     let renew = null;
-    if (!this.backend.livenessKnown) {
+    if (!heldToDeadline(this.backend, deadline)) {
       renew = setInterval(() => {
         if (released || failed || this.stopping)
           return;
         leaseExpiresAt = leaseEnd(this.backend, deadline);
-        chained({ k: "lease", holder: this.holder, epoch: lease.epoch, expiresAt: leaseExpiresAt, ...this.backend.holderInfo() }).catch((error) => {
+        chained({ k: "lease", holder: this.holder, epoch: lease.epoch, expiresAt: leaseExpiresAt, ...this.backend.holderInfo(), ...lease.delivery ? { delivery: lease.delivery } : {} }).catch((error) => {
           if (isFenced(error))
             turnNow?.cancel({ reason: "handoff" });
         });
@@ -1362,11 +1539,14 @@ class SessionWorker {
         if (state.lastLease?.holder !== this.holder && !failed)
           return "fenced";
       }
-      await harness.close();
-      harness = null;
-      if (failed)
+      if (failed) {
+        await harness.close();
+        harness = null;
         return broken();
+      }
       await release();
+      agent.track(harness.close().catch(() => {}));
+      harness = null;
       return failed ? broken() : "done";
     } finally {
       if (hardStop)
@@ -1467,8 +1647,7 @@ class SessionWorker {
   }
 }
 var internalEvent = new Set(["turn_start", "turn_resume", "turn_yield", "turn_end", "idle"]);
-function uiRanker() {
-  let high = 0;
+function uiRanker(high = 0) {
   return (event) => {
     if (!Number.isSafeInteger(event?.epoch))
       return true;
@@ -1587,9 +1766,18 @@ function turnView({ messageId, resumeRequest = null, start }) {
       settle.resolve(repeated ? { ...value, repeated: true } : value);
     wake();
   };
-  (async () => {
+  const started = start();
+  started.catch(() => {});
+  let following = false;
+  const follow = () => {
+    if (following)
+      return;
+    following = true;
+    read();
+  };
+  const read = async () => {
     try {
-      const { log, from, settled, attaching, endWithinMs, unsure } = await start();
+      const { log, from, settled, attaching, endWithinMs, unsure } = await started;
       repeated = settled?.repeated === true || endWithinMs !== undefined && !unsure;
       if (settled) {
         const { messageId: _id, ...rest } = settled;
@@ -1654,7 +1842,7 @@ function turnView({ messageId, resumeRequest = null, start }) {
     } catch (error) {
       finish(null, error);
     }
-  })();
+  };
   async function* iterate(raw) {
     for (let index = 0;; index += 1) {
       while (index >= events.length) {
@@ -1678,11 +1866,16 @@ function turnView({ messageId, resumeRequest = null, start }) {
     get messageId() {
       return id;
     },
-    result,
+    get result() {
+      follow();
+      return result;
+    },
     [Symbol.asyncIterator]() {
+      follow();
       return iterate(false);
     },
     get readable() {
+      follow();
       const iterator = iterate(true);
       return new ReadableStream({
         async pull(controller) {
@@ -1709,10 +1902,13 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
     if (!options || typeof options !== "object" || Array.isArray(options)) {
       throw new TypeError(`${name}() options must be an object`);
     }
-    const { durability, ...harnessOptions } = options;
+    const { durability, name: agentName = defaultAgentName, ...harnessOptions } = options;
     if (durability !== undefined && !isDurability(durability)) {
       throw new TypeError("durability must come from memory(), local(), vercel() or world()");
     }
+    if (typeof agentName !== "string" || !agentNameRule.test(agentName)) {
+      throw new TypeError(`${name}() name must be 1 to 64 letters, digits, ".", "_" or "-", starting with a letter or digit`);
+    }
     const plugged = harness(harnessOptions);
     const seed = plugged.seed === undefined ? undefined : toBase64(plugged.seed);
     const emit = (type, detail = {}) => {
@@ -1721,7 +1917,12 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
       } catch {}
     };
     const agent = {
+      name: agentName,
       emit,
+      track(work) {
+        active.add(work);
+        work.finally(() => active.delete(work));
+      },
       openHarness: (sessionId, store, run, ready) => plugged.open({
         sessionId,
         store,
@@ -1732,6 +1933,7 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
       })
     };
     let backendPromise = null;
+    let durabilityPromise = null;
     let chosenDurability = null;
     let unlisten = null;
     let closed = false;
@@ -1741,33 +1943,48 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
       if (closed)
         return Promise.reject(new Error(`${label} is closed`));
       backendPromise ??= (async () => {
-        const chosen = durability ?? await defaultDurability();
+        const chosen = await durabilityOf();
         chosenDurability = chosen;
         const created = await createBackend(chosen);
         await created.start?.();
-        unlisten = created.listen((message) => {
-          let worker = workers.get(message.sessionId);
-          if (!worker) {
-            worker = new SessionWorker(agent, created, message.sessionId);
-            workers.set(message.sessionId, worker);
-          }
-          worker.deliveries += 1;
-          const work = worker.consume(message);
-          active.add(work);
-          work.catch((error) => {
-            emit("session.error", { sessionId: message.sessionId, error: errorSummary(error) });
-          }).finally(() => {
-            active.delete(work);
-            worker.deliveries -= 1;
-            if (worker.deliveries === 0 && !worker.running && workers.get(message.sessionId) === worker)
-              workers.delete(message.sessionId);
-          });
-          return work;
-        });
+        unlisten = created.listen((message, meta) => receive(created, message, deliveryOf(meta)), agentName);
         return created;
       })();
       return backendPromise;
     };
+    const durabilityOf = () => durabilityPromise ??= durability ? Promise.resolve(durability) : defaultDurability();
+    const member = { open: backend, durability: durabilityOf };
+    const registered = joinGroup(agentsByName, agentName, member);
+    const receive = (created, message, delivery, { inRequest = false } = {}) => {
+      let worker = workers.get(message.sessionId);
+      if (!worker) {
+        worker = new SessionWorker(agent, created, message.sessionId);
+        workers.set(message.sessionId, worker);
+      }
+      worker.deliveries += 1;
+      let work = worker.consume(message, delivery);
+      if (inRequest) {
+        work = work.then(async (result) => {
+          if (Number.isFinite(result?.timeoutSeconds)) {
+            await created.queue.send(message, {
+              idempotencyKey: `${message.sessionId}:${message.type}:${message.messageId}:${newId("again")}`,
+              ...result.timeoutSeconds > 0 ? { delaySeconds: result.timeoutSeconds } : {}
+            });
+          }
+          return result;
+        });
+      }
+      active.add(work);
+      work.catch((error) => {
+        emit("session.error", { sessionId: message.sessionId, error: errorSummary(error) });
+      }).finally(() => {
+        active.delete(work);
+        worker.deliveries -= 1;
+        if (worker.deliveries === 0 && !worker.running && workers.get(message.sessionId) === worker)
+          workers.delete(message.sessionId);
+      });
+      return work;
+    };
     const openSession = (requestedId, sessionOptions = {}) => {
       if (requestedId !== undefined && !validId(requestedId))
         throw new TypeError(`session id must be ${idRule}`);
@@ -1789,19 +2006,33 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
         return { created, id };
       });
       resolved.catch(() => {});
-      const send = async (message) => {
+      const send = async (message, { inRequest = false } = {}) => {
         const { created, id: sessionId } = await resolved;
         const extra = {
           ...seeded ? {} : { seed },
           ...context === undefined ? {} : { context },
           ...settings === undefined ? {} : { settings }
         };
-        const full = { ...message, ...extra, sessionId };
+        const full = { ...message, ...extra, agent: agentName, sessionId };
         if (!created.queueDurable) {
           const log = await created.session(sessionId);
           await recordMessage(log, foldSessionLog(await log.read()), full);
         }
-        await created.queue.send(full, { idempotencyKey: `${sessionId}:${message.type}:${message.messageId}` });
+        const idempotencyKey = `${sessionId}:${message.type}:${message.messageId}`;
+        if (inRequest && created.runInRequest) {
+          await created.refreshDeadline?.();
+          const deadline = deliveryDeadline(created);
+          if (deadline !== null) {
+            const delaySeconds = Math.ceil(Math.max(0, deadline - Date.now()) / 1000) + inlineBackstopMarginSeconds;
+            const { messageId: backstop } = await created.queue.send(full, { idempotencyKey, delaySeconds }) ?? {};
+            seeded = true;
+            const delivery = backstop ? { messageId: backstop, attempt: 0 } : null;
+            const work = receive(created, full, delivery, { inRequest: true }).then(() => {}, () => {});
+            created.waitUntil?.(work);
+            return;
+          }
+        }
+        await created.queue.send(full, { idempotencyKey });
         seeded = true;
       };
       const startTurn = (type, messageId, input, retried = false, aborted = false) => {
@@ -1823,7 +2054,7 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
                 from = await log.ui.length();
                 const [state] = await Promise.all([
                   log.read().then(foldSessionLog),
-                  send({ type, messageId, ...input === undefined ? {} : { input } }).then(() => accept.resolve({ messageId, sessionId }))
+                  send({ type, messageId, ...input === undefined ? {} : { input } }, { inRequest: type === "prompt" }).then(() => accept.resolve({ messageId, sessionId }))
                 ]);
                 const outcome = await retryOutcome(log, state, messageId, from, { sent: true });
                 if (outcome.settled)
@@ -1849,7 +2080,7 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
                 return { settled: { messageId, stopReason: "cancelled", usage: {} } };
               }
               from ??= await log.ui.length();
-              await send({ type, messageId, ...input === undefined ? {} : { input } });
+              await send({ type, messageId, ...input === undefined ? {} : { input } }, { inRequest: type === "prompt" });
               accept.resolve({ messageId, sessionId });
               return { log, from, attaching };
             } catch (error) {
@@ -1899,12 +2130,40 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
           let reader = null;
           let buffered = "";
           let next = 0;
-          const shows = uiRanker();
+          let shows = uiRanker();
+          const open = async (ui) => {
+            if (cursor === 0)
+              return ui.read(0).getReader();
+            const at = ui.read(cursor - 1).getReader();
+            let first = "";
+            for (;; ) {
+              const index = first.indexOf(`
+`);
+              if (index >= 0) {
+                let epoch = null;
+                try {
+                  epoch = JSON.parse(first.slice(0, index))?.epoch;
+                } catch {}
+                if (!Number.isSafeInteger(epoch))
+                  break;
+                shows = uiRanker(epoch);
+                buffered = first.slice(index + 1);
+                next = cursor;
+                return at;
+              }
+              const { value, done } = await at.read();
+              if (done)
+                return at;
+              first += decoder.decode(value, { stream: true });
+            }
+            at.cancel().catch(() => {});
+            return ui.read(0).getReader();
+          };
           return new ReadableStream({
             async pull(controller) {
               if (!reader) {
                 const { created, id: sessionId } = await resolved;
-                reader = (await created.session(sessionId)).ui.read(0).getReader();
+                reader = await open((await created.session(sessionId)).ui);
               }
               for (;; ) {
                 const index = buffered.indexOf(`
@@ -1974,7 +2233,12 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
     const durableAgent = {
       [durableInternals]: {
         stopAtDeadline: (sessionId) => workers.get(sessionId)?.stopNow?.(),
+        settled: async (sessionId) => {
+          await workers.get(sessionId)?.settled?.();
+        },
+        deliver: async (message, delivery) => receive(await backend(), message, delivery),
         liveWorkers: () => workers.size,
+        openLog: async (sessionId) => (await backend()).session(sessionId),
         lastLease: async (sessionId) => {
           const log = await (await backend()).session(sessionId);
           return foldSessionLog(await log.read()).lastLease;
@@ -1993,6 +2257,9 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
       async newSessionId() {
         return (await backend()).newSessionId();
       },
+      get name() {
+        return agentName;
+      },
       get sessionId() {
         return defaultSession?.id ?? null;
       },
@@ -2016,6 +2283,7 @@ function createDurableAgentFactory({ harness, defaultDurability, name = "createA
         if (closed)
           return;
         closed = true;
+        leaveGroup(agentsByName, agentName, registered, member);
         while (active.size > 0)
           await Promise.allSettled([...active]);
         if (backendPromise) {
@@ -2484,6 +2752,7 @@ var maxApiKeyBytes = 64 * 1024;
 var maxModelBytes = 1024;
 var maxEffortBytes = 64;
 var maxUrlBytes = 16 * 1024;
+var unfinishedToolOutput = "fx stopped while this tool was running, so it may have partly run. Check its effects before running it again.";
 var maxModelCatalogBytes = 4 * 1024 * 1024;
 var maxModelCatalogEntries = 1e4;
 var streamReadsPerTaskYield = 32;
@@ -2721,12 +2990,20 @@ function journalAppendError(cause) {
 function withoutSupersededProgress(events) {
   const kept = new Array(events.length);
   let superseded = false;
+  let answered = false;
   for (let index = events.length - 1;index >= 0; index -= 1) {
     const event = events[index];
     const type = event?.type;
-    kept[index] = superseded && type === "turn_progress" && event.data != null ? { ...event, data: null } : event;
-    if (type === "turn_progress" || type === "turn_committed" || type === "turn_progress_cleared")
+    const dropped = event?.data != null && (type === "turn_progress" && superseded || type === "tool_result" && answered);
+    kept[index] = dropped ? { ...event, data: null } : event;
+    if (type === "turn_committed" || type === "turn_progress_cleared") {
       superseded = true;
+      answered = true;
+    } else if (type === "turn_progress") {
+      answered = true;
+      if (event.base === undefined)
+        superseded = true;
+    }
   }
   return kept;
 }
@@ -2836,9 +3113,9 @@ function journalMarks(events) {
     if (event?.type === "turn_progress") {
       if (typeof event.turnId === "string")
         marks.push({ start: event.turnId });
-      const steps = event.data?.execution?.tool_steps;
-      if (Array.isArray(steps))
-        marks.push({ step: `${steps.length}:${String(event.data.tool_state ?? "none")}` });
+      const steps = Number.isSafeInteger(event.steps) ? event.steps : event.data?.execution?.tool_steps?.length;
+      if (Number.isSafeInteger(steps))
+        marks.push({ step: `${steps}:${String(event.data?.tool_state ?? "none")}` });
     } else if (event?.type === "turn_committed" || event?.type === "turn_progress_cleared")
       marks.push({ end: true });
     else if (event?.type === "turn_yielded")
@@ -4779,6 +5056,7 @@ async function createFxEngine(options = {}) {
   let coreExitError = null;
   const isCurrentTurn = (turn) => turn && activeTurn === turn && !turn.cancelled && !closing;
   const persistence = options.persistence ?? null;
+  const wantsMarks = persistence?.marks === true || persistence?.[journalMarksWanted] === true;
   const checkpointAfterBytes = options.checkpointAfterBytes ?? defaultCheckpointAfterBytes;
   let journalHead = null;
   let appendedSeq = 0;
@@ -4786,12 +5064,12 @@ async function createFxEngine(options = {}) {
   let appendTail = Promise.resolve();
   const writerId = crypto.randomUUID();
   const journal = persistence && {
-    append(events) {
+    append(events, barrier) {
       const data = encodeJournalRecord(events);
       const lastSeq = events.at(-1)?.seq;
-      const marks = persistence[journalMarksWanted] === true ? { marks: journalMarks(events) } : {};
+      const marks = wantsMarks ? { marks: journalMarks(events) } : {};
       const appended = appendTail.then(async () => {
-        const result = await persistence.append({ expected: journalHead, idempotencyKey: `${writerId}:${events[0]?.seq}`, data, ...marks });
+        const result = await persistence.append({ expected: journalHead, idempotencyKey: `${writerId}:${events[0]?.seq}`, data, barrier, ...marks });
         if (!validCursor(result?.cursor))
           throw new TypeError("persistence.append() must resolve to { cursor }");
         journalHead = result.cursor;
@@ -4807,12 +5085,15 @@ async function createFxEngine(options = {}) {
   let openTurnId = null;
   let lastTurnId = null;
   let ambiguousCalls = [];
-  const rerunIds = (onAmbiguous) => {
+  const settleAmbiguous = (onAmbiguous) => {
     const calls = ambiguousCalls;
     ambiguousCalls = [];
-    if (onAmbiguous === undefined)
-      return [];
-    return calls.filter((call) => onAmbiguous({ executionId: call.id, name: call.name, input: parsedToolInput(call.arguments) }) === "rerun").map((call) => call.id);
+    const rerun = onAmbiguous === undefined ? [] : calls.filter((call) => onAmbiguous({ executionId: call.id, name: call.name, input: parsedToolInput(call.arguments) }) === "rerun").map((call) => call.id);
+    return { rerun, answered: calls.filter((call) => !rerun.includes(call.id)) };
+  };
+  const resumeOpenTurn = (promptOptions) => {
+    const { rerun, answered } = settleAmbiguous(promptOptions.onAmbiguous);
+    return normalizeTurn(startTurn(null, { ...promptOptions, [resumeTurn]: true, [rerunCallIds]: rerun }), answered);
   };
   const followUps = [];
   const runNextFollowUp = (resuming = false) => {
@@ -4834,6 +5115,8 @@ async function createFxEngine(options = {}) {
   let journalQueue = [];
   let journalFlushScheduled = false;
   const journalPending = new Set;
+  let journalInFlight = null;
+  let journalBarrier = false;
   let journalFailure = null;
   let handedOff = false;
   const handedOffError = () => new Error("this agent handed its session off; open it again to continue");
@@ -4873,7 +5156,7 @@ async function createFxEngine(options = {}) {
     journalFailureReported = true;
     return journalFailure;
   };
-  const queueJournalEvents = (events) => {
+  const queueJournalEvents = (events, barrier = false) => {
     if (journalFailure || !Array.isArray(events) || events.length === 0)
       return;
     if (handedOff) {
@@ -4882,6 +5165,8 @@ async function createFxEngine(options = {}) {
       return;
     }
     journalQueue.push(...events);
+    if (barrier || events.some((event) => event?.type === "input_accepted" || event?.type === "input_withdrawn"))
+      journalBarrier = true;
     if (events.every((event) => event?.type === "session_config"))
       return;
     if (journalFlushScheduled)
@@ -4891,14 +5176,16 @@ async function createFxEngine(options = {}) {
   };
   function flushJournal() {
     journalFlushScheduled = false;
-    if (journalFailure || journalQueue.length === 0)
+    if (journalFailure || journalInFlight || journalQueue.length === 0)
       return;
     const batch = journalQueue;
     journalQueue = [];
-    emit("journal.append", { events: batch.length });
+    const barrier = journalBarrier;
+    journalBarrier = false;
+    emit("journal.append", { events: batch.length, barrier });
     let appended;
     try {
-      appended = Promise.resolve(journal.append(batch));
+      appended = Promise.resolve(journal.append(batch, barrier));
     } catch (error) {
       appended = Promise.reject(error);
     }
@@ -4912,7 +5199,12 @@ async function createFxEngine(options = {}) {
       emit("journal.error", { error: error instanceof Error ? error.name : "Error" });
       rejectInputWaiters([...inputWaiters.keys()], journalFailure);
       activeTurn?.cancel();
-    }).finally(() => journalPending.delete(settled));
+    }).finally(() => {
+      journalPending.delete(settled);
+      journalInFlight = null;
+      flushJournal();
+    });
+    journalInFlight = settled;
     journalPending.add(settled);
   }
   let journalClosed = null;
@@ -4922,6 +5214,8 @@ async function createFxEngine(options = {}) {
   }
   async function journalSettled() {
     for (;; ) {
+      if (journalQueue.length > 0)
+        journalBarrier = true;
       if (journalFlushScheduled || journalQueue.length > 0)
         flushJournal();
       if (journalPending.size === 0)
@@ -5202,7 +5496,7 @@ async function createFxEngine(options = {}) {
     emit("acp.receive", { message });
     if (message.method === "libfx/journal_append") {
       if (journal && message.params?.sessionId === sessionId) {
-        queueJournalEvents(message.params.events);
+        queueJournalEvents(message.params.events, message.params.barrier === true);
       }
       return;
     }
@@ -5282,7 +5576,11 @@ async function createFxEngine(options = {}) {
     sessionId = sessionResult.sessionId;
     if (initialCheckpoint) {
       const [checkpointAttachment] = attachBytes([initialCheckpoint]);
-      const restored = await request("libfx/restore", { sessionId, checkpointAttachment });
+      const restored = await request("libfx/restore", { sessionId, checkpointAttachment }).catch((error) => {
+        if (/newer fx/.test(error?.message ?? ""))
+          throw new FxJournalVersionError(error.message);
+        throw error;
+      });
       compareCheckpointMeta(restored?.checkpointMeta);
     }
     if (journal) {
@@ -5373,7 +5671,7 @@ async function createFxEngine(options = {}) {
       if (turnId !== undefined && journal) {
         if (resumable && turnId === openTurnId) {
           resumable = false;
-          return normalizeTurn(startTurn(null, { ...promptOptions, [resumeTurn]: true, [rerunCallIds]: rerunIds(promptOptions.onAmbiguous) }));
+          return resumeOpenTurn(promptOptions);
         }
         if (turnId === lastTurnId)
           return endedTurn(turnId);
@@ -5394,7 +5692,7 @@ async function createFxEngine(options = {}) {
       checkOnAmbiguous(promptOptions.onAmbiguous);
       if (resumable) {
         resumable = false;
-        return normalizeTurn(startTurn(null, { ...promptOptions, [resumeTurn]: true, [rerunCallIds]: rerunIds(promptOptions.onAmbiguous) }));
+        return resumeOpenTurn(promptOptions);
       }
       const next = followUps.find((entry) => entry.held);
       if (!next)
@@ -5494,7 +5792,7 @@ async function createFxEngine(options = {}) {
     }
   };
   return agent;
-  function normalizeTurn(rawTurn) {
+  function normalizeTurn(rawTurn, answered = []) {
     const toolNames = new Map;
     const started = new Set;
     const eventFor = (update) => {
@@ -5555,6 +5853,9 @@ async function createFxEngine(options = {}) {
       },
       [Symbol.asyncIterator]() {
         const iterator = async function* () {
+          for (const call of answered) {
+            yield { type: "tool_end", id: call.id, name: call.name, content: unfinishedToolOutput, isError: true };
+          }
           for await (const update of rawTurn) {
             const event = eventFor(update);
             if (event)
@@ -5934,6 +6235,7 @@ async function createFxEngine(options = {}) {
 
 // sdk/fx-harness.js
 var encoder5 = new TextEncoder;
+var durableCheckpointAfterBytes = 64 * 1024;
 function fxHarness({ createEngine, defaultApiKey = async () => {
   return;
 } }) {
@@ -5958,7 +6260,7 @@ function fxHarness({ createEngine, defaultApiKey = async () => {
           [credentialMemory]: credentials,
           persistence: { ...store, [journalMarksWanted]: true },
           inputsDurable: true,
-          checkpointAfterBytes: 0,
+          checkpointAfterBytes: durableCheckpointAfterBytes,
           ...context === undefined || context === null ? {} : { toolContext: context }
         });
         return fxSession(engine, idempotent);
@@ -6080,9 +6382,16 @@ function claimedTools(tools, ready) {
 }
 function idempotentTools(tools) {
   const names = new Set;
-  for (const tool of toolEntries(tools))
-    if (tool?.idempotent === true && typeof tool.name === "string")
+  for (const [index, tool] of toolEntries(tools).entries()) {
+    if (!tool || typeof tool !== "object" || tool.providerExecuted === true)
+      continue;
+    if (typeof tool.idempotent !== "boolean") {
+      const name = typeof tool.name === "string" ? tool.name : index;
+      throw new TypeError(`tool ${name} must set idempotent: true if running a call twice is safe, or idempotent: false if it is not`);
+    }
+    if (tool.idempotent && typeof tool.name === "string")
       names.add(tool.name);
+  }
   return names;
 }
 function checkpointBytesOf(value) {
@@ -6107,7 +6416,7 @@ function snapshotOf(checkpoint) {
 }
 
 // sdk/node.js
-var libfxApiVersion = 2;
+var libfxApiVersion = 3;
 var nativeCoreApiVersion = 4;
 var fetchOperationStale = 0;
 var fetchOperationApplied = 1;
@@ -6792,14 +7101,26 @@ async function createWithFallback(surface, nativeMethod, wasmFactory, defaultWas
 async function createFxEngine2(options = {}) {
   return createWithFallback("agent", "createCore", createFxEngine, defaultCoreWasm, options);
 }
-async function environmentDurability() {
+var environments = new Map;
+function environmentDurability() {
+  const dir = process.env.VERCEL ? null : process.env.FX_SESSIONS_DIR || import_node_path.resolve(import_node_os.tmpdir(), "libfx", "sessions");
+  const key = dir ?? "vercel";
+  if (!environments.has(key)) {
+    environments.set(key, chooseEnvironmentDurability(dir).catch((error) => {
+      environments.delete(key);
+      throw error;
+    }));
+  }
+  return environments.get(key);
+}
+async function chooseEnvironmentDurability(dir) {
   const load = (asset) => import((asset.protocol === "" ? bundledAssetUrl(asset) : asset).href);
-  if (process.env.VERCEL) {
+  if (dir === null) {
     const { vercel } = await load(new URL("./durable/vercel.mjs", __libfxModuleUrl));
     return vercel();
   }
   const { local } = await load(new URL("./durable/local.mjs", __libfxModuleUrl));
-  return local({ dir: process.env.FX_SESSIONS_DIR || import_node_path.resolve(import_node_os.tmpdir(), "libfx", "sessions") });
+  return local({ dir });
 }
 var createFxAgent = createDurableAgentFactory({
   name: "createFxAgent",