@relayfx/sdk 0.3.6 → 0.3.7

package/dist/{index-e02krw55.js → index-8awt651b.js}

@@ -16,7 +16,7 @@ import {
   exports_tool_executor,
   exports_tool_output,
   exports_turn_policy
-} from "./index-8fpd6kvj.js";
+} from "./index-t5bbk8cp.js";
 import {
   ClientError,
   CommandReplyInvalid,
@@ -51,7 +51,7 @@ import {
   followExecutionFrom,
   inputSchemaRef,
   outputSchemaRef
-} from "./index-mtvz1bjn.js";
+} from "./index-pw46cfne.js";
 import {
   __export
 } from "./index-nb39b5ae.js";
@@ -717,7 +717,7 @@ __export(exports_tool_runtime, {
 });
 
 // ../runtime/src/tool/tool-runtime-contract.ts
-import { Context as Context10, Layer as Layer10, Schema as Schema10 } from "effect";
+import { Context as Context10, Effect as Effect10, Layer as Layer10, Schema as Schema10 } from "effect";
 
 class ToolNotRegistered extends Schema10.TaggedErrorClass()("ToolNotRegistered", {
   tool_name: exports_shared_schema.NonEmptyString
@@ -755,7 +755,7 @@ class ToolCallInfo extends Context10.Service()("@relayfx/runtime/tool/tool-runti
 
 class Service12 extends Context10.Service()("@relayfx/runtime/tool/tool-runtime-contract/Service") {
 }
-var testLayer8 = (implementation) => Layer10.succeed(Service12, Service12.of(implementation));
+var testLayer8 = (implementation) => Layer10.succeed(Service12, Service12.of({ ...implementation, prepare: implementation.prepare ?? (() => Effect10.void) }));
 // ../store-sql/src/address/address-book-repository.ts
 var exports_address_book_repository = {};
 __export(exports_address_book_repository, {
@@ -3175,6 +3175,7 @@ __export(exports_execution_event_repository, {
   findByCursor: () => findByCursor,
   executionEventsChannel: () => executionEventsChannel,
   appendedSignals: () => appendedSignals,
+  appendNext: () => appendNext,
   append: () => append,
   Service: () => Service25,
   ExecutionEventRow: () => ExecutionEventRow,
@@ -3183,7 +3184,7 @@ __export(exports_execution_event_repository, {
   ExecutionEventCursorNotFound: () => ExecutionEventCursorNotFound,
   DuplicateExecutionEvent: () => DuplicateExecutionEvent
 });
-import { Context as Context23, Effect as Effect24, Filter, Layer as Layer23, Option as Option2, PubSub as PubSub2, Schema as Schema22, Stream as Stream2 } from "effect";
+import { Context as Context23, Effect as Effect24, Filter, Layer as Layer23, Option as Option2, PubSub as PubSub2, Schema as Schema22, Semaphore as Semaphore2, Stream as Stream2 } from "effect";
 import { SqlClient as SqlClient13 } from "effect/unstable/sql/SqlClient";
 
 // ../store-sql/src/database/notification-bus.ts
@@ -3319,6 +3320,7 @@ var duplicateError = (input) => DuplicateExecutionEvent.make({
   sequence: input.sequence,
   cursor: input.cursor
 });
+var hasSamePayload = (existing, input) => existing.id === input.id && existing.execution_id === input.execution_id && existing.child_execution_id === input.child_execution_id && existing.type === input.type && existing.cursor === input.cursor && exports_shared_schema.canonicalEquals(existing.content ?? null, input.content ?? null) && exports_shared_schema.canonicalEquals(existing.data ?? {}, input.data ?? {});
 var assertAppendable = (events, input) => {
   const duplicate = events.find((event) => event.sequence === input.sequence || event.cursor === input.cursor);
   if (duplicate !== undefined) {
@@ -3382,15 +3384,15 @@ var layer18 = Layer23.effect(Service25, Effect24.gen(function* () {
         ${timestampParam(sql, input.created_at)}
       )
     `;
-  const insertEvent = sql.onDialectOrElse({
-    mysql: () => (tenantId, input) => sql.withTransaction(Effect24.gen(function* () {
-      yield* insertStatement(tenantId, input);
-      return yield* selectByCursor(tenantId, input.cursor);
-    })),
-    orElse: () => (tenantId, input) => sql`
-        ${insertStatement(tenantId, input)}
-        RETURNING ${columns}
-      `
+  const lockExecution = (tenantId, executionId) => sql.onDialectOrElse({
+    mysql: () => sql`UPDATE relay_executions SET updated_at=updated_at WHERE tenant_id=${tenantId} AND id=${executionId}`.pipe(Effect24.andThen(sql`SELECT id FROM relay_executions WHERE tenant_id=${tenantId} AND id=${executionId}`)),
+    orElse: () => sql`UPDATE relay_executions SET updated_at=updated_at WHERE tenant_id=${tenantId} AND id=${executionId} RETURNING id`
+  });
+  const lockExistingExecution = Effect24.fn("ExecutionEventRepository.lockExistingExecution")(function* (tenantId, executionId) {
+    const rows = yield* lockExecution(tenantId, executionId);
+    if (rows[0] === undefined) {
+      return yield* ExecutionEventRepositoryError.make({ message: `Execution not found: ${executionId}` });
+    }
   });
   const listConditions = (tenantId, input) => [
     sql`tenant_id = ${tenantId}`,
@@ -3407,28 +3409,68 @@ var layer18 = Layer23.effect(Service25, Effect24.gen(function* () {
   const decodeEvents = (rows) => Effect24.forEach(rows, decodeRow7).pipe(Effect24.map((decoded) => decoded.map(toEvent)));
   const append = Effect24.fn("ExecutionEventRepository.append")(function* (input) {
     const tenantId = yield* current();
-    const previousRows = yield* selectLatest(tenantId, input.execution_id).pipe(Effect24.mapError(toRepositoryError8));
-    const previous = previousRows[0] === undefined ? undefined : toEvent(yield* decodeRow7(previousRows[0]));
-    if (previous !== undefined && input.sequence === previous.sequence) {
-      return yield* duplicateError(input);
-    }
-    if (previous !== undefined && input.sequence < previous.sequence) {
-      return yield* ExecutionEventOrderViolation.make({
-        execution_id: input.execution_id,
-        sequence: input.sequence,
-        previous_sequence: previous.sequence
-      });
-    }
-    const duplicateCursorRows = yield* selectByCursor(tenantId, input.cursor).pipe(Effect24.mapError(toRepositoryError8));
-    if (duplicateCursorRows[0] !== undefined) {
-      return yield* duplicateError(input);
-    }
-    const rows = yield* insertEvent(tenantId, input).pipe(Effect24.mapError(toRepositoryError8));
-    const row = rows[0];
-    if (row === undefined) {
-      return yield* ExecutionEventRepositoryError.make({ message: "Execution event append returned no row" });
-    }
-    return toEvent(yield* decodeRow7(row));
+    return yield* sql.withTransaction(Effect24.gen(function* () {
+      yield* lockExistingExecution(tenantId, input.execution_id);
+      const previousRows = yield* selectLatest(tenantId, input.execution_id);
+      const previous = previousRows[0] === undefined ? undefined : toEvent(yield* decodeRow7(previousRows[0]));
+      if (previous !== undefined && input.sequence === previous.sequence)
+        return yield* duplicateError(input);
+      if (previous !== undefined && input.sequence < previous.sequence) {
+        return yield* ExecutionEventOrderViolation.make({
+          execution_id: input.execution_id,
+          sequence: input.sequence,
+          previous_sequence: previous.sequence
+        });
+      }
+      const duplicateCursorRows = yield* selectByCursor(tenantId, input.cursor);
+      if (duplicateCursorRows[0] !== undefined)
+        return yield* duplicateError(input);
+      yield* insertStatement(tenantId, input);
+      const rows = yield* selectByCursor(tenantId, input.cursor);
+      const row = rows[0];
+      if (row === undefined) {
+        return yield* ExecutionEventRepositoryError.make({ message: "Execution event append returned no row" });
+      }
+      return toEvent(yield* decodeRow7(row));
+    })).pipe(Effect24.mapError((error) => Schema22.is(DuplicateExecutionEvent)(error) || Schema22.is(ExecutionEventOrderViolation)(error) ? error : toRepositoryError8(error)));
+  });
+  const appendNext = Effect24.fn("ExecutionEventRepository.appendNext")(function* (input) {
+    const tenantId = yield* current();
+    return yield* sql.withTransaction(Effect24.gen(function* () {
+      yield* lockExistingExecution(tenantId, input.execution_id);
+      const existingRows = yield* selectByCursor(tenantId, input.cursor);
+      const existingRow = existingRows[0];
+      if (existingRow !== undefined) {
+        const existing = toEvent(yield* decodeRow7(existingRow));
+        if (hasSamePayload(existing, input))
+          return { event: existing, inserted: false };
+        return yield* duplicateError({ ...input, sequence: existing.sequence });
+      }
+      const sequenceRows = yield* sql`
+            SELECT COALESCE(MAX(sequence), -1) + 1 AS value
+            FROM relay_execution_events
+            WHERE tenant_id = ${tenantId} AND execution_id = ${input.execution_id}
+          `;
+      const sequenceRow = sequenceRows[0];
+      if (sequenceRow === undefined) {
+        return yield* ExecutionEventRepositoryError.make({
+          message: "Execution event sequence query returned no row"
+        });
+      }
+      const decodedSequence = yield* decodeAggregate(sequenceRow);
+      const { minimumSequence, ...eventInput } = input;
+      const event = {
+        ...eventInput,
+        sequence: Math.max(Number(decodedSequence.value), minimumSequence ?? 0)
+      };
+      yield* insertStatement(tenantId, event);
+      const rows = yield* selectByCursor(tenantId, input.cursor);
+      const row = rows[0];
+      if (row === undefined) {
+        return yield* ExecutionEventRepositoryError.make({ message: "Execution event append returned no row" });
+      }
+      return { event: toEvent(yield* decodeRow7(row)), inserted: true };
+    })).pipe(Effect24.mapError((error) => Schema22.is(DuplicateExecutionEvent)(error) ? error : toRepositoryError8(error)));
   });
   const list4 = Effect24.fn("ExecutionEventRepository.list")(function* (input) {
     const tenantId = yield* current();
@@ -3608,6 +3650,7 @@ var layer18 = Layer23.effect(Service25, Effect24.gen(function* () {
   return Service25.of({
     signalTransport: bus.transport,
     append,
+    appendNext,
     list: list4,
     findBySequenceOrCursor,
     findByCursor,
@@ -3624,14 +3667,47 @@ var layer18 = Layer23.effect(Service25, Effect24.gen(function* () {
 var layerWithBus = layer18.pipe(Layer23.provide(layerFromDialect));
 var memoryLayer16 = Layer23.effect(Service25, Effect24.gen(function* () {
   const events = new Map;
+  const locks = new Map;
   const signals = yield* PubSub2.unbounded();
+  const lockFor = Effect24.fn("ExecutionEventRepository.memory.lockFor")(function* (executionId) {
+    const candidate = yield* Semaphore2.make(1);
+    return yield* Effect24.sync(() => {
+      const existing = locks.get(executionId);
+      if (existing !== undefined)
+        return existing;
+      locks.set(executionId, candidate);
+      return candidate;
+    });
+  });
   return Service25.of({
     signalTransport: "in-process",
     append: Effect24.fn("ExecutionEventRepository.memory.append")(function* (input) {
-      const executionEvents = events.get(input.execution_id) ?? [];
-      yield* assertAppendable(executionEvents, input);
-      yield* Effect24.sync(() => events.set(input.execution_id, [...executionEvents, input]));
-      return input;
+      const lock = yield* lockFor(input.execution_id);
+      return yield* lock.withPermits(1)(Effect24.gen(function* () {
+        const executionEvents = events.get(input.execution_id) ?? [];
+        yield* assertAppendable(executionEvents, input);
+        yield* Effect24.sync(() => events.set(input.execution_id, [...executionEvents, input]));
+        return input;
+      }));
+    }),
+    appendNext: Effect24.fn("ExecutionEventRepository.memory.appendNext")(function* (input) {
+      const lock = yield* lockFor(input.execution_id);
+      return yield* lock.withPermits(1)(Effect24.gen(function* () {
+        const executionEvents = events.get(input.execution_id) ?? [];
+        const existing = executionEvents.find((event2) => event2.cursor === input.cursor);
+        if (existing !== undefined) {
+          if (hasSamePayload(existing, input))
+            return { event: existing, inserted: false };
+          return yield* duplicateError({ ...input, sequence: existing.sequence });
+        }
+        const { minimumSequence, ...eventInput } = input;
+        const event = {
+          ...eventInput,
+          sequence: Math.max(executionEvents.reduce((maximum, item) => Math.max(maximum, item.sequence), -1) + 1, minimumSequence ?? 0)
+        };
+        yield* Effect24.sync(() => events.set(input.execution_id, [...executionEvents, event]));
+        return { event, inserted: true };
+      }));
     }),
     list: Effect24.fn("ExecutionEventRepository.memory.list")(function* (input) {
       const executionEvents = events.get(input.executionId) ?? [];
@@ -3696,12 +3772,17 @@ var memoryLayer16 = Layer23.effect(Service25, Effect24.gen(function* () {
 }));
 var testLayer20 = (implementation) => Layer23.succeed(Service25, Service25.of({
   ...implementation,
+  appendNext: implementation.appendNext ?? ((input) => implementation.append({ ...input, sequence: 0 }).pipe(Effect24.map((event) => ({ event, inserted: true })), Effect24.catchTag("ExecutionEventOrderViolation", (error) => ExecutionEventRepositoryError.make({ message: String(error) })))),
   page: implementation.page ?? (() => Effect24.succeed({ events: [], hasMore: false }))
 }));
 var append = Effect24.fn("ExecutionEventRepository.append.call")(function* (input) {
   const repository = yield* Service25;
   return yield* repository.append(input);
 });
+var appendNext = Effect24.fn("ExecutionEventRepository.appendNext.call")(function* (input) {
+  const repository = yield* Service25;
+  return yield* repository.appendNext(input);
+});
 var list4 = Effect24.fn("ExecutionEventRepository.list.call")(function* (input) {
   const repository = yield* Service25;
   return yield* repository.list(input);
@@ -4409,7 +4490,7 @@ var layer20 = Layer25.effect(Service27, Effect26.gen(function* () {
 }));
 var testLayer22 = (implementation) => Layer25.succeed(Service27, Service27.of(implementation));
 // ../store-sql/src/idempotency/idempotency-repository.ts
-import { Context as Context26, Effect as Effect27, HashMap, Layer as Layer26, Option as Option5, Ref as Ref5, Schema as Schema25, Semaphore as Semaphore2 } from "effect";
+import { Context as Context26, Effect as Effect27, HashMap, Layer as Layer26, Option as Option5, Ref as Ref5, Schema as Schema25, Semaphore as Semaphore3 } from "effect";
 import { SqlClient as SqlClient16 } from "effect/unstable/sql/SqlClient";
 class IdempotencyRepositoryError extends Schema25.TaggedErrorClass()("IdempotencyRepositoryError", {
   message: Schema25.String
@@ -4528,7 +4609,7 @@ var layer21 = Layer26.effect(Service28, Effect27.gen(function* () {
 }));
 var memoryLayer19 = Layer26.effect(Service28, Effect27.gen(function* () {
   const records = yield* Ref5.make(HashMap.empty());
-  const semaphore = Semaphore2.makeUnsafe(1);
+  const semaphore = Semaphore3.makeUnsafe(1);
   const runOnce = Effect27.fn("IdempotencyRepository.memory.runOnce")(function* (input, create4) {
     return yield* semaphore.withPermits(1)(Effect27.gen(function* () {
       const id = operationId(input);
@@ -4623,9 +4704,13 @@ var consumeMessage = (message, input) => Object.assign({}, message, { drain_id:
 var layer22 = Layer27.effect(Service29, Effect28.gen(function* () {
   const sql = yield* SqlClient17;
   const lockExecution = sql.onDialectOrElse({
-    pg: () => (tenant, executionId) => sql`SELECT pg_advisory_xact_lock(hashtext(${`${tenant}:${executionId}:inbox`}))`.pipe(Effect28.asVoid),
-    mysql: () => (tenant, executionId) => sql`SELECT id FROM relay_executions WHERE tenant_id=${tenant} AND id=${executionId} FOR UPDATE`.pipe(Effect28.asVoid),
-    orElse: () => () => Effect28.void
+    mysql: () => (tenant, executionId) => sql`UPDATE relay_executions SET updated_at=updated_at WHERE tenant_id=${tenant} AND id=${executionId}`.pipe(Effect28.andThen(sql`SELECT id FROM relay_executions WHERE tenant_id=${tenant} AND id=${executionId}`)),
+    orElse: () => (tenant, executionId) => sql`UPDATE relay_executions SET updated_at=updated_at WHERE tenant_id=${tenant} AND id=${executionId} RETURNING id`
+  });
+  const lockExistingExecution = Effect28.fn("InboxRepository.lockExistingExecution")(function* (tenant, executionId) {
+    const rows = yield* lockExecution(tenant, executionId);
+    if (rows[0] === undefined)
+      return yield* InboxRepositoryError.make({ message: `Execution not found: ${executionId}` });
   });
   const appendEvent = (tenant, input, type, id, cursor, data) => Effect28.gen(function* () {
     const rows = yield* sql`SELECT COALESCE(MAX(sequence), -1) + 1 AS next_sequence FROM relay_execution_events WHERE tenant_id=${tenant} AND execution_id=${input.executionId}`;
@@ -4642,7 +4727,7 @@ var layer22 = Layer27.effect(Service29, Effect28.gen(function* () {
   const deliver = Effect28.fn("InboxRepository.deliver")(function* (input) {
     const tenant = yield* current();
     return yield* sql.withTransaction(Effect28.gen(function* () {
-      yield* lockExecution(tenant, input.executionId);
+      yield* lockExistingExecution(tenant, input.executionId);
       if (input.idempotencyKey !== undefined) {
         const found = yield* sql`SELECT ${sql.literal(columns)} FROM relay_inbox_messages WHERE tenant_id=${tenant} AND execution_id=${input.executionId} AND idempotency_key=${input.idempotencyKey}`;
         if (found[0] !== undefined)
@@ -4671,7 +4756,7 @@ var layer22 = Layer27.effect(Service29, Effect28.gen(function* () {
   const drain = Effect28.fn("InboxRepository.drain")(function* (input) {
     const tenant = yield* current();
     return yield* sql.withTransaction(Effect28.gen(function* () {
-      yield* lockExecution(tenant, input.executionId);
+      yield* lockExistingExecution(tenant, input.executionId);
       const old = yield* sql`SELECT message_sequences_json FROM relay_inbox_drains WHERE tenant_id=${tenant} AND execution_id=${input.executionId} AND drain_id=${input.drainId}`;
       let sequences;
       if (old[0] !== undefined)
@@ -6819,7 +6904,7 @@ __export(exports_skill_definition_repository, {
   Service: () => Service36,
   ExecutionSkillPinRow: () => ExecutionSkillPinRow
 });
-import { Context as Context34, Effect as Effect35, HashSet, Layer as Layer34, Schema as Schema33, Semaphore as Semaphore3 } from "effect";
+import { Context as Context34, Effect as Effect35, HashSet, Layer as Layer34, Schema as Schema33, Semaphore as Semaphore4 } from "effect";
 import { SqlClient as SqlClient24 } from "effect/unstable/sql/SqlClient";
 class SkillDefinitionRepositoryError extends Schema33.TaggedErrorClass()("SkillDefinitionRepositoryError", {
   message: Schema33.String
@@ -7108,7 +7193,7 @@ var layer29 = Layer34.effect(Service36, Effect35.gen(function* () {
   return Service36.of({ put: put3, get: get10, getRevision: getRevision2, list: list11, listRevisions: listRevisions2, pinExecution, listPins, getPinned });
 }));
 var memoryLayer27 = Layer34.sync(Service36, () => {
-  const semaphore = Semaphore3.makeUnsafe(1);
+  const semaphore = Semaphore4.makeUnsafe(1);
   const records = new Map;
   const revisions = new Map;
   const pins = new Map;
@@ -9622,7 +9707,8 @@ var afterSequence = (events, input) => {
   return Effect41.succeed(cursorEvent.sequence);
 };
 var replayAfter = (events, input, sequence) => events.filter((event) => event.execution_id === input.executionId).filter((event) => sequence === undefined || event.sequence > sequence).toSorted((left, right) => left.sequence - right.sequence).slice(0, limitOf(input));
-var sameEvent = (left, right) => left.id === right.id && left.execution_id === right.execution_id && left.child_execution_id === right.child_execution_id && left.type === right.type && left.sequence === right.sequence && left.cursor === right.cursor && exports_shared_schema.canonicalEquals(left.content ?? null, right.content ?? null) && exports_shared_schema.canonicalEquals(left.data ?? {}, right.data ?? {});
+var sameEventPayload = (left, right) => left.id === right.id && left.execution_id === right.execution_id && left.child_execution_id === right.child_execution_id && left.type === right.type && left.cursor === right.cursor && exports_shared_schema.canonicalEquals(left.content ?? null, right.content ?? null) && exports_shared_schema.canonicalEquals(left.data ?? {}, right.data ?? {});
+var sameEvent = (left, right) => left.sequence === right.sequence && sameEventPayload(left, right);
 var findExisting = (events, input) => events.find((event) => event.cursor === input.cursor || event.sequence === input.sequence);
 var duplicateEventError = (input) => EventLogError.make({ message: `DuplicateExecutionEvent:${input.execution_id}:${input.sequence}` });
 var orderViolationError = (input, previous) => EventLogError.make({
@@ -9727,6 +9813,20 @@ var layerFromRepository = Layer39.effect(Service41, Effect41.gen(function* () {
       yield* recordEventAppended(event.type);
       return event;
     }),
+    appendNext: Effect41.fn("EventLog.repository.appendNext")(function* (input) {
+      yield* Effect41.annotateCurrentSpan({
+        "relay.execution.id": input.execution_id,
+        "relay.event.id": input.id,
+        "relay.event.type": input.type
+      });
+      const result = yield* repository.appendNext(input).pipe(Effect41.mapError(mapRepositoryAppendError));
+      if (result.inserted) {
+        yield* PubSub5.publish(pubsub, result.event);
+        yield* repository.notifyAppended(result.event).pipe(Effect41.catch((error5) => Effect41.logWarning("EventLog append notify failed", error5)));
+        yield* recordEventAppended(result.event.type);
+      }
+      return result.event;
+    }),
     replay: Effect41.fn("EventLog.repository.replay")(function* (input) {
       yield* Effect41.annotateCurrentSpan("relay.execution.id", input.executionId);
       const replay = yield* loadReplay(input);
@@ -9783,6 +9883,34 @@ var memoryLayer32 = Layer39.effect(Service41, Effect41.gen(function* () {
       yield* recordEventAppended(input.type);
       return input;
     }),
+    appendNext: Effect41.fn("EventLog.memory.appendNext")(function* (input) {
+      const result = yield* Ref10.modify((store) => {
+        const existing = HashMap2.get(store, input.execution_id).pipe(Option6.getOrElse(() => []));
+        const duplicate = existing.find((event2) => event2.cursor === input.cursor);
+        if (duplicate !== undefined) {
+          const candidate = { ...input, sequence: duplicate.sequence };
+          if (!sameEvent(duplicate, candidate))
+            return [{ _tag: "error", error: duplicateEventError(candidate) }, store];
+          return [{ _tag: "event", event: duplicate, inserted: false }, store];
+        }
+        const { minimumSequence, ...eventInput } = input;
+        const event = {
+          ...eventInput,
+          sequence: Math.max((existing.at(-1)?.sequence ?? -1) + 1, minimumSequence ?? 0)
+        };
+        return [
+          { _tag: "event", event, inserted: true },
+          HashMap2.set(store, input.execution_id, [...existing, event])
+        ];
+      })(events);
+      if (result._tag === "error")
+        return yield* result.error;
+      if (result.inserted) {
+        yield* PubSub5.publish(pubsub, result.event);
+        yield* recordEventAppended(result.event.type);
+      }
+      return result.event;
+    }),
     replay: Effect41.fn("EventLog.memory.replay")(function* (input) {
       yield* Effect41.annotateCurrentSpan("relay.execution.id", input.executionId);
       const replay = yield* loadReplay(input);
@@ -9827,18 +9955,28 @@ var memoryLayer32 = Layer39.effect(Service41, Effect41.gen(function* () {
     })
   });
 }));
-var appendIdempotentTo = Function6.dual(2, (eventLog, input) => eventLog.append(input).pipe(Effect41.catchTag("EventLogError", (error5) => eventLog.findBySequenceOrCursor({
-  executionId: input.execution_id,
-  sequence: input.sequence,
-  cursor: input.cursor
-}).pipe(Effect41.flatMap((existing) => Option6.match(existing, {
+var appendIdempotentTo = Function6.dual(2, (eventLog, input) => eventLog.appendNext({
+  id: input.id,
+  execution_id: input.execution_id,
+  ...input.child_execution_id === undefined ? {} : { child_execution_id: input.child_execution_id },
+  type: input.type,
+  cursor: input.cursor,
+  ...input.content === undefined ? {} : { content: input.content },
+  ...input.data === undefined ? {} : { data: input.data },
+  created_at: input.created_at,
+  minimumSequence: input.sequence
+}).pipe(Effect41.catchTag("EventLogError", (error5) => eventLog.findByCursor({ executionId: input.execution_id, cursor: input.cursor }).pipe(Effect41.flatMap(Option6.match({
   onNone: () => Effect41.fail(error5),
-  onSome: (event) => sameEvent(event, input) ? Effect41.succeed(event) : Effect41.fail(error5)
+  onSome: (event) => sameEventPayload(event, input) ? Effect41.succeed(event) : Effect41.fail(error5)
 })), Effect41.mapError(() => error5)))));
 var append3 = Effect41.fn("EventLog.append.call")(function* (input) {
   const service = yield* Service41;
   return yield* service.append(input);
 });
+var appendNext2 = Effect41.fn("EventLog.appendNext.call")(function* (input) {
+  const service = yield* Service41;
+  return yield* service.appendNext(input);
+});
 var appendIdempotent = Effect41.fn("EventLog.appendIdempotent.call")(function* (input) {
   const service = yield* Service41;
   return yield* appendIdempotentTo(service, input);
@@ -9978,7 +10116,7 @@ var createTimeoutSchedule = Effect42.fn("WaitService.createTimeoutSchedule")(fun
 var complete = Effect42.fn("WaitService.complete")(function* (repository, eventLog, input, event) {
   const result = yield* repository.completeWait(input).pipe(Effect42.mapError(mapRepositoryError2));
   if (result.transitioned) {
-    yield* eventLog.append(event(result.wait)).pipe(Effect42.mapError(mapEventLogError));
+    yield* appendIdempotentTo(eventLog, event(result.wait)).pipe(Effect42.mapError(mapEventLogError));
   }
   return result;
 });
@@ -9998,7 +10136,7 @@ var layer34 = Layer40.effect(Service42, Effect42.gen(function* () {
       }
       yield* repository.acceptEnvelope({ envelope: input.envelope, waitId: input.waitId }).pipe(Effect42.mapError((error5) => WaitServiceError.make({ message: error5.message })));
       const wait = yield* repository.getWait(input.waitId).pipe(Effect42.mapError((error5) => WaitServiceError.make({ message: error5.message })), Effect42.flatMap((record2) => record2 === undefined ? Effect42.fail(WaitServiceError.make({ message: `Wait ${input.waitId} was not persisted` })) : Effect42.succeed(record2)));
-      yield* eventLog.append(waitCreatedEvent(input, wait)).pipe(Effect42.mapError(mapEventLogError));
+      yield* appendIdempotentTo(eventLog, waitCreatedEvent(input, wait)).pipe(Effect42.mapError(mapEventLogError));
       if (input.envelope.wait.timeout !== undefined) {
         yield* createTimeoutSchedule(schedules, input.waitId, wait, input.envelope.wait.timeout);
       }
@@ -10018,7 +10156,7 @@ var layer34 = Layer40.effect(Service42, Effect42.gen(function* () {
         ...input.correlationKey === undefined ? {} : { correlationKey: input.correlationKey },
         ...input.metadata === undefined ? {} : { metadata: input.metadata }
       }).pipe(Effect42.mapError((error5) => WaitServiceError.make({ message: error5.message })));
-      yield* eventLog.append(waitCreatedEvent(input, wait)).pipe(Effect42.mapError(mapEventLogError));
+      yield* appendIdempotentTo(eventLog, waitCreatedEvent(input, wait)).pipe(Effect42.mapError(mapEventLogError));
       if (input.timeout !== undefined) {
         yield* createTimeoutSchedule(schedules, input.waitId, wait, input.timeout);
       }
@@ -10136,11 +10274,17 @@ var requestedEvent = (input) => ({
   },
   created_at: input.createdAt
 });
-var sameToolEventPayload = (left, right) => left.id === right.id && left.execution_id === right.execution_id && left.child_execution_id === right.child_execution_id && left.type === right.type && left.cursor === right.cursor && left.created_at === right.created_at && exports_shared_schema.canonicalEquals(left.data ?? {}, right.data ?? {});
-var ensureToolEvent = (eventLog, event) => eventLog.findByCursor({ executionId: event.execution_id, cursor: event.cursor }).pipe(Effect43.mapError(mapEventLogError2), Effect43.flatMap(Option8.match({
-  onNone: () => appendIdempotentTo(eventLog, event).pipe(Effect43.mapError(mapEventLogError2), Effect43.asVoid),
-  onSome: (existing) => sameToolEventPayload(existing, event) ? Effect43.void : Effect43.fail(ToolRuntimeError.make({ message: "EventLogError" }))
-})));
+var ensureToolEvent = (eventLog, event) => eventLog.appendNext({
+  id: event.id,
+  execution_id: event.execution_id,
+  ...event.child_execution_id === undefined ? {} : { child_execution_id: event.child_execution_id },
+  type: event.type,
+  cursor: event.cursor,
+  ...event.content === undefined ? {} : { content: event.content },
+  ...event.data === undefined ? {} : { data: event.data },
+  created_at: event.created_at,
+  minimumSequence: event.sequence
+}).pipe(Effect43.mapError(mapEventLogError2), Effect43.asVoid);
 var resultEvent = (input, result, sequence) => ({
   id: Identifiers.eventId(input.executionId, input.call.id, "tool-result"),
   execution_id: input.executionId,
@@ -10268,6 +10412,7 @@ var resolveApproval = (waits, eventLog, input) => Effect43.gen(function* () {
     return yield* waitRequested(input, waitId2);
   }
   if (existing.state === "open") {
+    yield* appendIdempotentTo(eventLog, approvalRequestedEvent({ ...input, createdAt: existing.createdAt }, waitId2)).pipe(Effect43.mapError(mapEventLogError2));
     return yield* waitRequested(input, waitId2);
   }
   const approved = existing.state === "resolved" && existing.metadata.approved === true;
@@ -10283,8 +10428,9 @@ var recordRequested = (repository, eventLog, input, tool) => repository.ensureCa
   placement: tool.placement ?? { kind: "local" },
   createdAt: input.createdAt
 }).pipe(Effect43.mapError(mapRepositoryError3), Effect43.tap((call) => ensureToolEvent(eventLog, requestedEvent({ ...input, createdAt: call.createdAt }))));
-var repairResultEvent = (eventLog, input, record2) => eventLog.maxSequence(input.executionId).pipe(Effect43.mapError(mapEventLogError2), Effect43.flatMap((max) => ensureToolEvent(eventLog, resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result, (max ?? input.eventSequence) + 1))));
-var recordReceived = (repository, eventLog, input, result) => repository.recordResult({ executionId: input.executionId, result, createdAt: input.createdAt + 1 }).pipe(Effect43.catchTag("DuplicateToolResult", () => repository.getResult(input.executionId, result.call_id).pipe(Effect43.mapError(mapRepositoryError3), Effect43.flatMap((existing) => existing === undefined ? Effect43.fail(ToolRuntimeError.make({ message: "DuplicateToolResult" })) : Effect43.succeed(existing)))), Effect43.mapError(preserveRecordResultError), Effect43.flatMap((record2) => eventLog.maxSequence(input.executionId).pipe(Effect43.mapError(mapEventLogError2), Effect43.flatMap((max) => appendIdempotentTo(eventLog, resultEvent(input, record2.result, (max ?? input.eventSequence) + 1)).pipe(Effect43.mapError(mapEventLogError2))), Effect43.as(record2.result))));
+var repairResultEvent = (eventLog, input, record2) => ensureToolEvent(eventLog, resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result, input.eventSequence + 1));
+var persistReceived = (repository, input, result) => repository.recordResult({ executionId: input.executionId, result, createdAt: input.createdAt + 1 }).pipe(Effect43.catchTag("DuplicateToolResult", () => repository.getResult(input.executionId, result.call_id).pipe(Effect43.mapError(mapRepositoryError3), Effect43.flatMap((existing) => existing === undefined ? Effect43.fail(ToolRuntimeError.make({ message: "DuplicateToolResult" })) : Effect43.succeed(existing)))), Effect43.mapError(preserveRecordResultError));
+var recordReceived = (eventLog, input, record2) => ensureToolEvent(eventLog, resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result, input.eventSequence + 1)).pipe(Effect43.as(record2.result));
 var nonEmptyName = (name) => Schema40.decodeUnknownSync(exports_shared_schema.NonEmptyString)(name);
 var needsApprovalFromEffectTool = (tool) => tool.needsApproval === undefined ? undefined : typeof tool.needsApproval === "boolean" ? tool.needsApproval : true;
 var definitionFromEffectTool = (modelTool, options) => ({
@@ -10431,7 +10577,25 @@ var makeService = (initialTools) => Effect43.gen(function* () {
     register: Effect43.fn("ToolRuntime.register")((registeredTool) => registerTool(tools, registeredTool)),
     definitions: Ref11.get(tools).pipe(Effect43.map((registry) => Chunk.toReadonlyArray(Chunk.map(registry, (registeredTool) => registeredTool.definition)))),
     registeredTools: Ref11.get(tools).pipe(Effect43.map(Chunk.toReadonlyArray)),
+    prepare: Effect43.fn("ToolRuntime.prepare")(function* (input) {
+      const stored = yield* Ref11.get(tools);
+      const registry = (input.extraTools ?? []).reduce(upsertTool, stored);
+      const registeredTool = Chunk.findFirst(registry, sameToolName(input.call.name)).pipe(Option8.getOrUndefined);
+      if (registeredTool === undefined)
+        return yield* ToolNotRegistered.make({ tool_name: input.call.name });
+      yield* ensureAllowed(registeredTool, input);
+      yield* validateInput(registeredTool, input);
+      yield* recordRequested(repository, eventLog, input, registeredTool);
+      if (input.onRequested !== undefined)
+        yield* input.onRequested;
+    }),
     run: Effect43.fn("ToolRuntime.run")(function* (input) {
+      let settlementSequence;
+      const beginSettlement = Effect43.suspend(() => {
+        if (settlementSequence !== undefined)
+          return Effect43.succeed(settlementSequence);
+        return (input.beforeSettlement ?? Effect43.succeed(input.eventSequence)).pipe(Effect43.tap((sequence) => Effect43.sync(() => settlementSequence = sequence)));
+      });
       const stored = yield* Ref11.get(tools);
       const registry = (input.extraTools ?? []).reduce(upsertTool, stored);
       const registeredTool = Chunk.findFirst(registry, sameToolName(input.call.name)).pipe(Option8.getOrUndefined);
@@ -10442,8 +10606,11 @@ var makeService = (initialTools) => Effect43.gen(function* () {
         yield* ensureAllowed(registeredTool, input);
         yield* validateInput(registeredTool, input);
         const call = yield* recordRequested(repository, eventLog, input, registeredTool);
+        if (input.onRequested !== undefined)
+          yield* input.onRequested;
         const existingResult = yield* repository.getResult(input.executionId, input.call.id).pipe(Effect43.mapError(mapRepositoryError3));
         if (existingResult !== undefined) {
+          yield* beginSettlement;
           yield* repairResultEvent(eventLog, input, existingResult);
           return existingResult.result;
         }
@@ -10451,26 +10618,46 @@ var makeService = (initialTools) => Effect43.gen(function* () {
         if (registeredTool.definition.needs_approval === true) {
           const bypass = yield* hasPermissionApprovalBypass(waits, input);
           if (!bypass) {
-            const decision = yield* resolveApproval(waits, eventLog, input);
-            effectiveInput = { ...input, eventSequence: input.eventSequence + 2, createdAt: input.createdAt + 2 };
+            const sequence = yield* beginSettlement;
+            effectiveInput = {
+              ...input,
+              eventSequence: sequence,
+              createdAt: input.createdAt + sequence - input.eventSequence
+            };
+            const decision = yield* resolveApproval(waits, eventLog, effectiveInput);
+            effectiveInput = {
+              ...effectiveInput,
+              eventSequence: effectiveInput.eventSequence + 1,
+              createdAt: effectiveInput.createdAt + 1
+            };
             if (decision._tag === "denied") {
-              const denied = yield* recordReceived(repository, eventLog, effectiveInput, {
+              const deniedRecord = yield* persistReceived(repository, effectiveInput, {
                 call_id: input.call.id,
                 output: null,
                 error: decision.reason
               });
+              const denied = yield* recordReceived(eventLog, effectiveInput, deniedRecord);
               yield* recordToolCall(input.call.name, "denied");
               return denied;
             }
           }
         }
-        const rawResult = call.placement.kind === "client" || call.placement.kind === "remote" ? yield* runExternalTool(repository, waits, call, effectiveInput) : yield* repository.beginAttempt({
+        const executeHandler = call.placement.kind === "client" || call.placement.kind === "remote" ? runExternalTool(repository, waits, call, effectiveInput) : repository.beginAttempt({
           executionId: input.executionId,
           callId: input.call.id,
           startedAt: effectiveInput.createdAt
         }).pipe(Effect43.mapError(mapRepositoryError3), Effect43.flatMap(() => finalToolResult(registeredTool, effectiveInput, call.idempotencyKey)), Effect43.catchTag("ToolExecutionFailed", (error5) => Effect43.succeed(placementFailureResult(input, error5.message))));
-        const result = input.transformResult === undefined || rawResult.error !== undefined ? rawResult : yield* input.transformResult(rawResult);
-        const received = yield* recordReceived(repository, eventLog, effectiveInput, result);
+        const record2 = yield* Effect43.uninterruptibleMask((restore) => restore(executeHandler).pipe(Effect43.flatMap((rawResult) => input.transformResult === undefined || rawResult.error !== undefined ? Effect43.succeed(rawResult) : input.transformResult(rawResult)), Effect43.flatMap((result2) => persistReceived(repository, effectiveInput, result2))));
+        const result = record2.result;
+        if (effectiveInput === input) {
+          const sequence = yield* beginSettlement;
+          effectiveInput = {
+            ...input,
+            eventSequence: sequence,
+            createdAt: input.createdAt + sequence - input.eventSequence
+          };
+        }
+        const received = yield* recordReceived(eventLog, effectiveInput, record2);
         yield* recordToolCall(input.call.name, result.error === undefined ? "success" : "failure");
         return received;
       }).pipe(Effect43.tapError((error5) => recordToolCall(input.call.name, error5._tag === "ToolExecutionWaitRequested" ? "wait" : error5._tag === "ToolPermissionDenied" ? "denied" : "failure")));
@@ -11911,7 +12098,7 @@ var registeredTools2 = (state) => [
 ];
 
 // ../runtime/src/session/session-store-service.ts
-import { Clock as Clock9, Context as Context51, Effect as Effect57, Function as Function12, Layer as Layer52, Ref as Ref13, Semaphore as Semaphore4 } from "effect";
+import { Clock as Clock9, Context as Context51, Effect as Effect57, Function as Function12, Layer as Layer52, Ref as Ref13, Semaphore as Semaphore5 } from "effect";
 
 class Service51 extends Context51.Service()("@relayfx/runtime/session/session-store-service/Service") {
 }
@@ -12053,7 +12240,7 @@ var toAppendInput = (input) => {
 var make4 = Effect57.fn("RelaySessionStore.make")(function* (sessionId, entryScope = "default", makeOptions) {
   const repository = yield* exports_session_repository.Service;
   const state = yield* Ref13.make(undefined);
-  const lock = yield* Semaphore4.make(1);
+  const lock = yield* Semaphore5.make(1);
   const entryPrefix = `${sessionId}:entry:${entryScope}:`;
   const initialState = Effect57.fn("RelaySessionStore.initialState")(function* (input) {
     const current2 = yield* Ref13.get(state);
@@ -13029,13 +13216,13 @@ var layer47 = Layer58.effect(Service57, Effect63.gen(function* () {
 }));
 
 // ../runtime/src/tool/tool-transition-coordinator.ts
-import { Context as Context58, Effect as Effect64, Layer as Layer59, Semaphore as Semaphore5 } from "effect";
+import { Context as Context58, Effect as Effect64, Layer as Layer59, Semaphore as Semaphore6 } from "effect";
 import { SqlClient as SqlClient29 } from "effect/unstable/sql/SqlClient";
 
 class Service58 extends Context58.Service()("@relayfx/runtime/tool/tool-transition-coordinator/Service") {
 }
 var make6 = Effect64.gen(function* () {
-  const semaphore = yield* Semaphore5.make(1);
+  const semaphore = yield* Semaphore6.make(1);
   return Service58.of({
     coordinate: (effect) => semaphore.withPermit(effect)
   });
@@ -13043,7 +13230,7 @@ var make6 = Effect64.gen(function* () {
 var memoryLayer41 = Layer59.effect(Service58, make6);
 var sqlLayer = Layer59.effect(Service58, Effect64.gen(function* () {
   const sql = yield* SqlClient29;
-  const semaphore = yield* Semaphore5.make(1);
+  const semaphore = yield* Semaphore6.make(1);
   return Service58.of({
     coordinate: (effect) => semaphore.withPermit(sql.withTransaction(effect))
   });
@@ -15063,7 +15250,7 @@ var layer55 = (config) => Layer68.succeed(exports_steering.Steering, exports_ste
 }));
 
 // ../runtime/src/agent/relay-tool-executor.ts
-import { Effect as Effect78, Layer as Layer69, Option as Option17, Schema as Schema71 } from "effect";
+import { Deferred as Deferred3, Effect as Effect78, Layer as Layer69, Option as Option17, Schema as Schema71 } from "effect";
 var jsonValue5 = (value) => Schema71.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var errorDetail = (error5) => {
   switch (error5._tag) {
@@ -15091,47 +15278,103 @@ var boundResult = (config, result) => {
     return Effect78.succeed(result);
   return exports_tool_output.bound({ _tag: "Success", result: result.output, encodedResult: result.output }, { toolCallId: result.call_id, maxBytes: config.toolOutputMaxBytes }).pipe(Effect78.map((bounded) => ({ ...result, output: jsonValue5(bounded.encodedResult) })));
 };
-var make8 = (config) => ({
-  execute: (request) => Effect78.gen(function* () {
-    const first = yield* config.allocator.current;
-    const call = {
-      id: exports_ids_schema.ToolCallId.make(request.call.id),
-      name: request.call.name,
-      input: jsonValue5(request.call.params)
-    };
-    const resumed = config.resumedToolCallId === call.id;
-    const existingRequest = resumed ? yield* hasRequestedEvent(config, call.id) : false;
-    const eventSequence = existingRequest ? first - 1 : first;
-    return yield* config.toolRuntime.run({
-      executionId: config.executionId,
-      call,
-      permissions: config.permissions,
-      eventSequence,
-      createdAt: config.startedAt + eventSequence - config.eventSequence,
-      ...config.extraTools === undefined ? {} : { extraTools: config.extraTools },
-      transformResult: (result) => boundResult(config, result)
-    }).pipe(Effect78.flatMap((result) => nextLoggedSequence2(config.eventLog, config.executionId, existingRequest ? first + 1 : first + 2).pipe(Effect78.flatMap(config.allocator.resetTo), Effect78.as(result.error === undefined ? { _tag: "Success", result: result.output, encodedResult: result.output } : {
-      _tag: "DomainFailure",
-      failure: result.error,
-      encodedFailure: result.error
-    }))), Effect78.catch((error5) => nextLoggedSequence2(config.eventLog, config.executionId, first).pipe(Effect78.flatMap(config.allocator.resetTo), Effect78.flatMap(() => {
-      if (error5._tag === "ToolExecutionWaitRequested") {
-        return Effect78.succeed({ _tag: "Suspend", token: error5.wait_id });
-      }
-      if (error5._tag === "ToolExecutionFailed") {
-        const failure2 = `${error5._tag}: ${errorDetail(error5)}`;
-        return Effect78.succeed({ _tag: "DomainFailure", failure: failure2, encodedFailure: failure2 });
-      }
-      const stage = error5._tag === "ToolPermissionDenied" ? "authorization" : error5._tag === "ToolInputInvalid" ? "decode-input" : error5._tag === "ToolNotRegistered" ? "missing-handler" : "handler";
-      return Effect78.fail(exports_tool_executor.FrameworkFailure.make({
-        stage,
-        tool: call.name,
-        message: `${error5._tag}: ${errorDetail(error5)}`
-      }));
-    }))));
-  })
+var batchKey = (request) => `${request.turn}:${request.toolCallBatch.calls.map((call) => call.id).join(":")}`;
+var gateKey = (turn, toolCallIndex) => `${turn}:${toolCallIndex}`;
+var gateFor = (gates, key4) => {
+  const existing = gates.get(key4);
+  if (existing !== undefined)
+    return existing;
+  const created = Deferred3.makeUnsafe();
+  gates.set(key4, created);
+  return created;
+};
+var callFrom = (call) => ({
+  id: exports_ids_schema.ToolCallId.make(call.id),
+  name: call.name,
+  input: jsonValue5(call.params)
+});
+var frameworkFailure = (call, error5) => {
+  const stage = error5._tag === "ToolPermissionDenied" ? "authorization" : error5._tag === "ToolInputInvalid" ? "decode-input" : error5._tag === "ToolNotRegistered" ? "missing-handler" : "handler";
+  return exports_tool_executor.FrameworkFailure.make({
+    stage,
+    tool: call.name,
+    message: `${error5._tag}: ${errorDetail(error5)}`
+  });
+};
+var make8 = (config) => Effect78.sync(() => {
+  const prepared = new Map;
+  const settled = new Map;
+  const awaitPrevious = (gates, request) => {
+    if (request.toolCallIndex === 0 || config.resumedToolCallId === request.call.id)
+      return Effect78.void;
+    return Deferred3.await(gateFor(gates, gateKey(request.turn, request.toolCallIndex - 1)));
+  };
+  const completeSettlement = (request) => Deferred3.succeed(gateFor(settled, gateKey(request.turn, request.toolCallIndex)), undefined).pipe(Effect78.asVoid);
+  return exports_tool_executor.ToolExecutor.of({
+    execute: (request) => {
+      const key4 = batchKey(request);
+      const existingPreparation = prepared.get(key4);
+      const preparation = existingPreparation ?? Deferred3.makeUnsafe();
+      if (existingPreparation === undefined)
+        prepared.set(key4, preparation);
+      const prepareBatch = existingPreparation === undefined ? Effect78.gen(function* () {
+        const first = yield* config.allocator.current;
+        yield* Effect78.forEach(request.toolCallBatch.calls.entries(), ([toolCallIndex, batchCall]) => {
+          const call = callFrom(batchCall);
+          const eventSequence = first + toolCallIndex;
+          return config.toolRuntime.prepare({
+            executionId: config.executionId,
+            call,
+            permissions: config.permissions,
+            eventSequence,
+            createdAt: config.startedAt + eventSequence - config.eventSequence,
+            ...config.extraTools === undefined ? {} : { extraTools: config.extraTools }
+          }).pipe(Effect78.mapError((error5) => frameworkFailure(call, error5)));
+        });
+        const next = yield* nextLoggedSequence2(config.eventLog, config.executionId, first);
+        yield* config.allocator.advanceTo(next);
+        return next;
+      }).pipe(Effect78.exit, Effect78.flatMap((exit) => Deferred3.done(preparation, exit)), Effect78.andThen(Deferred3.await(preparation)), Effect78.uninterruptible) : Deferred3.await(preparation);
+      return Effect78.gen(function* () {
+        yield* prepareBatch;
+        let settlementSequence;
+        const beginSettlement = Effect78.suspend(() => {
+          if (settlementSequence !== undefined)
+            return Effect78.succeed(settlementSequence);
+          return awaitPrevious(settled, request).pipe(Effect78.andThen(config.allocator.current), Effect78.map((sequence) => sequence - 1), Effect78.tap((sequence) => Effect78.sync(() => settlementSequence = sequence)));
+        });
+        const first = yield* config.allocator.current;
+        const call = callFrom(request.call);
+        const existingRequest = yield* hasRequestedEvent(config, call.id);
+        const eventSequence = existingRequest ? first - 1 : first;
+        return yield* config.toolRuntime.run({
+          executionId: config.executionId,
+          call,
+          permissions: config.permissions,
+          eventSequence,
+          createdAt: config.startedAt + eventSequence - config.eventSequence,
+          ...config.extraTools === undefined ? {} : { extraTools: config.extraTools },
+          beforeSettlement: beginSettlement,
+          transformResult: (result) => boundResult(config, result)
+        }).pipe(Effect78.flatMap((result) => nextLoggedSequence2(config.eventLog, config.executionId, existingRequest ? first + 1 : first + 2).pipe(Effect78.flatMap(config.allocator.advanceTo), Effect78.as(result.error === undefined ? { _tag: "Success", result: result.output, encodedResult: result.output } : {
+          _tag: "DomainFailure",
+          failure: result.error,
+          encodedFailure: result.error
+        }))), Effect78.catch((error5) => beginSettlement.pipe(Effect78.asVoid, Effect78.andThen(nextLoggedSequence2(config.eventLog, config.executionId, first)), Effect78.flatMap(config.allocator.advanceTo), Effect78.flatMap(() => {
+          if (error5._tag === "ToolExecutionWaitRequested") {
+            return Effect78.succeed({ _tag: "Suspend", token: error5.wait_id });
+          }
+          if (error5._tag === "ToolExecutionFailed") {
+            const failure2 = `${error5._tag}: ${errorDetail(error5)}`;
+            return Effect78.succeed({ _tag: "DomainFailure", failure: failure2, encodedFailure: failure2 });
+          }
+          return Effect78.fail(frameworkFailure(call, error5));
+        }))), Effect78.tap((outcome) => outcome._tag === "Suspend" ? Effect78.void : completeSettlement(request)), Effect78.onInterrupt(() => completeSettlement(request)));
+      });
+    }
+  });
 });
-var layer56 = (config) => Layer69.succeed(exports_tool_executor.ToolExecutor, exports_tool_executor.ToolExecutor.of(make8(config)));
+var layer56 = (config) => Layer69.effect(exports_tool_executor.ToolExecutor, make8(config));
 
 // ../runtime/src/agent/relay-tool-output.ts
 import { Effect as Effect79, Function as Function14, Layer as Layer70, Option as Option18 } from "effect";
@@ -15182,6 +15425,7 @@ import { Effect as Effect80, Ref as Ref17 } from "effect";
 var make10 = (first) => Ref17.make(first).pipe(Effect80.map((ref) => ({
   allocate: (count) => Ref17.getAndUpdate(ref, (value) => value + count),
   current: Ref17.get(ref),
+  advanceTo: (sequence) => Ref17.update(ref, (current2) => Math.max(current2, sequence)),
   resetTo: (sequence) => Ref17.set(ref, sequence)
 })));
 
@@ -15418,7 +15662,7 @@ var loopError = (error5, nextEventSequence5) => AgentLoopError.make({
   message: error5 instanceof Error ? `${error5.name}: ${error5.message}` : String(error5),
   next_event_sequence: nextEventSequence5
 });
-var appendEvent = (eventLog, event, nextEventSequence5) => appendIdempotentTo(eventLog, event).pipe(Effect81.mapError((error5) => loopError(error5, nextEventSequence5)));
+var appendEvent = (eventLog, allocator, event, nextEventSequence5) => appendIdempotentTo(eventLog, event).pipe(Effect81.tap((appended) => allocator.advanceTo(appended.sequence + 1)), Effect81.mapError((error5) => loopError(error5, nextEventSequence5)));
 var compactionCommittedCursor = (executionId, checkpointId2) => `execution:${executionId}:agent-compaction:${checkpointId2}:committed`;
 var appendCompactionCommittedEvent = Effect81.fn("AgentLoop.appendCompactionCommittedEvent")(function* (eventLog, allocator, input, checkpoint) {
   if (input.sessionId === undefined)
@@ -15433,7 +15677,7 @@ var appendCompactionCommittedEvent = Effect81.fn("AgentLoop.appendCompactionComm
     session_id: input.sessionId,
     summary_present: checkpoint.summary !== undefined
   };
-  yield* appendEvent(eventLog, {
+  yield* appendEvent(eventLog, allocator, {
     id: exports_ids_schema.EventId.make(`event:${input.executionId}:agent-compaction:${checkpoint.id}:committed`),
     execution_id: input.executionId,
     type: "agent.compaction.committed",
@@ -15719,7 +15963,10 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
       const definitions2 = registered.map((tool3) => tool3.definition);
       yield* validateToolInputSchemaDigests(input, definitions2);
       const toolCallDecodeMaxRetries = yield* toolCallDecodeMaxRetriesConfig.pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)));
-      yield* appendEvent(eventLog, inputPreparedEvent(input, definitions2), input.eventSequence + 1);
+      const durableMaxSequence = yield* eventLog.maxSequence(input.executionId).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)));
+      const nextEventSequence5 = Math.max(input.eventSequence + 1, (durableMaxSequence ?? -1) + 1);
+      const allocator = yield* make10(nextEventSequence5);
+      yield* appendEvent(eventLog, allocator, inputPreparedEvent(input, definitions2), input.eventSequence + 1);
       const toolOutputMaxBytes = yield* effectiveToolOutputMaxBytes(input);
       const compactionPolicy = input.agent.compaction_policy;
       const configuredCompactionOptions = compactionOptions(input.agent);
@@ -15743,9 +15990,6 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
         input: jsonValue6(resumeSuspension.tool_params)
       };
       const storedHistory = resumeToolCall === undefined ? yield* loadStoredHistory(chats, input) : yield* restoreHistory(chats, input);
-      const durableMaxSequence = yield* eventLog.maxSequence(input.executionId).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)));
-      const nextEventSequence5 = Math.max(input.eventSequence + 1, (durableMaxSequence ?? -1) + 1);
-      const allocator = yield* make10(nextEventSequence5);
       const onCheckpointCommitted = (result) => appendCompactionCommittedEvent(eventLog, allocator, input, result.checkpoint).pipe(Effect81.andThen(layerOptions?.onCheckpointCommitted?.(result) ?? Effect81.void));
       const durableHistory = Option19.isNone(sessionRepository) ? storedHistory : yield* reconcileCompactionCheckpoint(sessionRepository.value, chats, input, storedHistory, onCheckpointCommitted, resumeSuspension === undefined);
       const continuingDurableHistory = durableHistory !== undefined;
@@ -15805,7 +16049,8 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
       const agent = exports_agent.make({
         name: input.agent.name,
         toolkit,
-        policy: turnPolicyFromDefinition(input.agent)
+        policy: turnPolicyFromDefinition(input.agent),
+        ...input.agent.tool_execution === undefined ? {} : { toolExecution: input.agent.tool_execution }
       });
       if (toolOutputMaxBytes !== undefined && Option19.isNone(blobStore)) {
         return yield* AgentLoopError.make({
@@ -15867,7 +16112,7 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
       const tokenBudget = input.agent.token_budget;
       const enforceBudget = (state) => tokenBudget === undefined || state.tokensUsed < tokenBudget ? Effect81.void : Effect81.gen(function* () {
         const budgetSequence = yield* allocator.allocate(1);
-        yield* appendEvent(eventLog, budgetExceededEvent(input, state.tokensUsed, tokenBudget, budgetSequence), budgetSequence + 1);
+        yield* appendEvent(eventLog, allocator, budgetExceededEvent(input, state.tokensUsed, tokenBudget, budgetSequence), budgetSequence + 1);
         return yield* AgentLoopBudgetExceeded.make({
           tokens_used: state.tokensUsed,
           token_budget: tokenBudget,
@@ -15881,13 +16126,13 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
             if (part.type === "text-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = sequence - input.eventSequence - 1;
-              yield* appendEvent(eventLog, outputDeltaEvent(input, part, deltaIndex), sequence + 1);
+              yield* appendEvent(eventLog, allocator, outputDeltaEvent(input, part, deltaIndex), sequence + 1);
               return { ...state, text: `${state.text}${part.delta}` };
             }
             if (part.type === "reasoning" || part.type === "reasoning-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = sequence - input.eventSequence - 1;
-              yield* appendEvent(eventLog, reasoningDeltaEvent(input, part, deltaIndex), sequence + 1);
+              yield* appendEvent(eventLog, allocator, reasoningDeltaEvent(input, part, deltaIndex), sequence + 1);
               return state;
             }
             if (part.type === "tool-params-start") {
@@ -15896,7 +16141,7 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
             if (part.type === "tool-params-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = state.toolCallDeltaIndexes[part.id] ?? 0;
-              yield* appendEvent(eventLog, toolCallDeltaEvent(input, part, state.toolCallNames[part.id], sequence, deltaIndex), sequence + 1);
+              yield* appendEvent(eventLog, allocator, toolCallDeltaEvent(input, part, state.toolCallNames[part.id], sequence, deltaIndex), sequence + 1);
               return {
                 ...state,
                 toolCallDeltaIndexes: { ...state.toolCallDeltaIndexes, [part.id]: deltaIndex + 1 }
@@ -15905,7 +16150,7 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
             if (part.type === "finish") {
               const finish = part;
               const sequence = yield* allocator.allocate(1);
-              yield* appendEvent(eventLog, usageReportedEvent(input, finish, sequence), sequence + 1);
+              yield* appendEvent(eventLog, allocator, usageReportedEvent(input, finish, sequence), sequence + 1);
               yield* recordModelUsage({
                 provider: input.agent.model.provider,
                 model: input.agent.model.model,
@@ -15973,7 +16218,7 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
       const schemaRef = input.agent.output_schema_ref;
       const structuredOutput = schemaRef === undefined || finalState.transcript === undefined ? undefined : yield* Chat.fromPrompt(finalState.transcript).pipe(Effect81.flatMap((chat) => runStructuredTurn(languageModels, schemas, chat, input, schemaRef, completedSequence + 1)));
       const structuredPart = structuredOutput === undefined || schemaRef === undefined ? [] : [{ type: "structured", value: structuredOutput, schema_ref: schemaRef }];
-      yield* appendEvent(eventLog, outputCompletedEvent(input, [...completedContent(finalState.text), ...structuredPart], finalState.text, completedSequence, structuredOutput), completedSequence + 1);
+      yield* appendEvent(eventLog, allocator, outputCompletedEvent(input, [...completedContent(finalState.text), ...structuredPart], finalState.text, completedSequence, structuredOutput), completedSequence + 1);
       return {
         metadata: {
           model_output: finalState.text,
@@ -17537,6 +17782,7 @@ var registerAgentPayload = Effect90.fn("Client.registerAgentPayload")(function*
     ...input.permission_rules === undefined ? {} : { permission_rules: input.permission_rules },
     ...input.compaction_policy === undefined ? {} : { compaction_policy: input.compaction_policy },
     ...turnPolicy,
+    ...input.agent.toolExecution === undefined ? {} : { tool_execution: input.agent.toolExecution },
     ...input.max_wait_turns === undefined ? {} : { max_wait_turns: input.max_wait_turns },
     ...input.token_budget === undefined ? {} : { token_budget: input.token_budget },
     ...input.child_run_presets === undefined ? {} : { child_run_presets: input.child_run_presets },
@@ -17911,6 +18157,16 @@ var layerFromRuntime3 = Layer80.effect(Service, Effect90.gen(function* () {
     const executionId = exports_ids_schema.ExecutionId.make(input.correlation_key ?? `execution:send:${identity2}`);
     const envelopeId = exports_ids_schema.EnvelopeId.make(`${executionId}:envelope:${identity2}`);
     const createdAt = yield* Clock19.currentTimeMillis;
+    const execution = yield* executionRepository.get(executionId).pipe(Effect90.mapError(toClientError));
+    if (execution === undefined) {
+      yield* executionRepository.create({
+        id: executionId,
+        rootAddressId: input.from,
+        status: "queued",
+        metadata: { operation: "envelope-send" },
+        createdAt
+      }).pipe(Effect90.catchIf(Schema83.is(exports_execution_repository.DuplicateExecution), () => Effect90.void), Effect90.mapError(toClientError));
+    }
     const maxSequence3 = yield* eventLog.maxSequence(executionId).pipe(Effect90.mapError(toClientError));
     return yield* envelopes.send({
       envelopeId,