@relayfx/sdk 0.3.5 → 0.3.6

package/dist/http-server.js

@@ -4,7 +4,7 @@ import {
   Service,
   Service1 as Service2,
   StateVersionConflict
-} from "./index-cyfx5y3r.js";
+} from "./index-mtvz1bjn.js";
 import"./index-nb39b5ae.js";
 
 // src/http-server.ts

package/dist/{index-5dqkw53p.js → index-2vsf6dks.js}

@@ -8,7 +8,7 @@ import {
   SqlFailure,
   make,
   normalizeAcquisitionCause
-} from "./index-cq8t8ka1.js";
+} from "./index-e02krw55.js";
 
 // src/migration-errors.ts
 import { Cause, Effect, Function } from "effect";

package/dist/{index-cq8t8ka1.js → index-e02krw55.js}

@@ -51,7 +51,7 @@ import {
   followExecutionFrom,
   inputSchemaRef,
   outputSchemaRef
-} from "./index-cyfx5y3r.js";
+} from "./index-mtvz1bjn.js";
 import {
   __export
 } from "./index-nb39b5ae.js";
@@ -10083,6 +10083,13 @@ var cancel3 = Effect42.fn("WaitService.cancel.call")(function* (input) {
   const service = yield* Service42;
   return yield* service.cancel(input);
 });
+// ../runtime/src/tool/tool-runtime-identifiers.ts
+var scopedPart = (value) => encodeURIComponent(value);
+var toolScope = (executionId, toolCallId) => `${scopedPart(executionId)}:${scopedPart(toolCallId)}`;
+var eventId = (executionId, toolCallId, kind) => exports_ids_schema.EventId.make(`event:${toolScope(executionId, toolCallId)}:${kind}`);
+var waitId = (kind, executionId, toolCallId) => exports_ids_schema.WaitId.make(`wait:${kind}:${toolScope(executionId, toolCallId)}`);
+var Identifiers = { eventId, waitId };
+
 // ../runtime/src/tool/tool-runtime-service.ts
 var permissionNames = (permissions) => HashSet3.fromIterable(permissions.map((permission) => permission.name));
 var requiredPermissionNames = (tool) => tool.requiredPermissions ?? tool.definition.permissions.map((permission) => permission.name);
@@ -10117,7 +10124,7 @@ var preserveToolError = (toolName, error5) => {
 };
 var preserveRecordResultError = (error5) => error5._tag === "ToolRuntimeError" ? error5 : mapRepositoryError3(error5);
 var requestedEvent = (input) => ({
-  id: exports_ids_schema.EventId.make(`event:${input.call.id}:tool-requested`),
+  id: Identifiers.eventId(input.executionId, input.call.id, "tool-requested"),
   execution_id: input.executionId,
   type: "tool.call.requested",
   sequence: input.eventSequence,
@@ -10135,7 +10142,7 @@ var ensureToolEvent = (eventLog, event) => eventLog.findByCursor({ executionId:
   onSome: (existing) => sameToolEventPayload(existing, event) ? Effect43.void : Effect43.fail(ToolRuntimeError.make({ message: "EventLogError" }))
 })));
 var resultEvent = (input, result, sequence) => ({
-  id: exports_ids_schema.EventId.make(`event:${input.call.id}:tool-result`),
+  id: Identifiers.eventId(input.executionId, input.call.id, "tool-result"),
   execution_id: input.executionId,
   type: "tool.result.received",
   sequence,
@@ -10204,11 +10211,11 @@ var finalToolResult = (tool, input, idempotencyKey) => Effect43.gen(function* ()
     output: jsonValue2(output)
   };
 });
-var approvalWaitId = (input) => exports_ids_schema.WaitId.make(`wait:approval:${input.call.id}`);
-var permissionWaitId = (input) => exports_ids_schema.WaitId.make(`wait:permission:${input.call.id}`);
+var approvalWaitId = (input) => Identifiers.waitId("approval", input.executionId, input.call.id);
+var permissionWaitId = (input) => Identifiers.waitId("permission", input.executionId, input.call.id);
 var mapWaitServiceError = (error5) => ToolRuntimeError.make({ message: error5.message });
-var approvalRequestedEvent = (input, waitId) => ({
-  id: exports_ids_schema.EventId.make(`event:${input.call.id}:approval-requested`),
+var approvalRequestedEvent = (input, waitId2) => ({
+  id: Identifiers.eventId(input.executionId, input.call.id, "approval-requested"),
   execution_id: input.executionId,
   type: "tool.approval.requested",
   sequence: input.eventSequence + 2,
@@ -10216,13 +10223,13 @@ var approvalRequestedEvent = (input, waitId) => ({
   data: {
     tool_call_id: input.call.id,
     tool_name: input.call.name,
-    wait_id: waitId,
+    wait_id: waitId2,
     input: input.call.input
   },
   created_at: input.createdAt + 2
 });
 var approvalResolvedEvent = (input, wait, approved) => ({
-  id: exports_ids_schema.EventId.make(`event:${input.call.id}:approval-resolved`),
+  id: Identifiers.eventId(input.executionId, input.call.id, "approval-resolved"),
   execution_id: input.executionId,
   type: "tool.approval.resolved",
   sequence: input.eventSequence + 1,
@@ -10237,14 +10244,14 @@ var approvalResolvedEvent = (input, wait, approved) => ({
   created_at: input.createdAt + 1
 });
 var deniedReason = (state) => state === "timed_out" ? "Tool approval timed out" : state === "cancelled" ? "Tool approval cancelled" : "Tool approval denied";
-var waitRequested = (input, waitId) => Effect43.fail(ToolExecutionWaitRequested.make({ tool_name: input.call.name, wait_id: waitId }));
+var waitRequested = (input, waitId2) => Effect43.fail(ToolExecutionWaitRequested.make({ tool_name: input.call.name, wait_id: waitId2 }));
 var hasPermissionApprovalBypass = (waits, input) => waits.get(permissionWaitId(input)).pipe(Effect43.mapError(mapWaitServiceError), Effect43.map((wait) => wait !== undefined && wait.state === "resolved" && wait.metadata.kind === "tool-permission" && wait.metadata.tool_call_id === input.call.id && wait.metadata.tool_name === input.call.name && (wait.metadata.answer === "Approved" || wait.metadata.answer === "Always")));
 var resolveApproval = (waits, eventLog, input) => Effect43.gen(function* () {
-  const waitId = approvalWaitId(input);
-  const existing = yield* waits.get(waitId).pipe(Effect43.mapError(mapWaitServiceError));
+  const waitId2 = approvalWaitId(input);
+  const existing = yield* waits.get(waitId2).pipe(Effect43.mapError(mapWaitServiceError));
   if (existing === undefined) {
     yield* waits.createDetached({
-      waitId,
+      waitId: waitId2,
       executionId: input.executionId,
       mode: "event",
       correlationKey: input.call.id,
@@ -10257,11 +10264,11 @@ var resolveApproval = (waits, eventLog, input) => Effect43.gen(function* () {
       eventSequence: input.eventSequence + 1,
       createdAt: input.createdAt
     }).pipe(Effect43.mapError(mapWaitServiceError));
-    yield* appendIdempotentTo(eventLog, approvalRequestedEvent(input, waitId)).pipe(Effect43.mapError(mapEventLogError2));
-    return yield* waitRequested(input, waitId);
+    yield* appendIdempotentTo(eventLog, approvalRequestedEvent(input, waitId2)).pipe(Effect43.mapError(mapEventLogError2));
+    return yield* waitRequested(input, waitId2);
   }
   if (existing.state === "open") {
-    return yield* waitRequested(input, waitId);
+    return yield* waitRequested(input, waitId2);
   }
   const approved = existing.state === "resolved" && existing.metadata.approved === true;
   yield* appendIdempotentTo(eventLog, approvalResolvedEvent(input, existing, approved)).pipe(Effect43.mapError(mapEventLogError2));
@@ -10356,7 +10363,7 @@ var placedTool = (modelTool, placement, options = {}) => ({
 });
 var clientTool = Function7.dual((args) => args.length > 1 || args.length === 1 && typeof args[0] === "object" && args[0] !== null && ("name" in args[0]), (modelTool, options = {}) => placedTool(modelTool, { kind: "client" }, options));
 var remoteTool = Function7.dual(2, (modelTool, options) => placedTool(modelTool, { kind: "remote", queue: options.queue }, options));
-var placementWaitId = (input) => exports_ids_schema.WaitId.make(`wait:tool:${input.call.id}`);
+var placementWaitId = (input) => Identifiers.waitId("tool", input.executionId, input.call.id);
 var placementFailureResult = (input, message) => ({
   call_id: input.call.id,
   output: null,
@@ -10376,11 +10383,11 @@ var externalOutcomeResult = (call, input) => {
   return Schema40.decodeUnknownEffect(exports_tool_schema.resultSchema(call.definition.output_schema))(call.externalOutcome.output).pipe(Effect43.map((output) => ({ call_id: input.call.id, output: jsonValue2(output) })), Effect43.catch((error5) => Effect43.succeed(placementFailureResult(input, `invalid ${placement} result: ${error5.message}`))));
 };
 var runExternalTool = (repository, waits, call, input) => Effect43.gen(function* () {
-  const waitId = placementWaitId(input);
-  let wait = yield* waits.get(waitId).pipe(Effect43.mapError(mapWaitServiceError));
+  const waitId2 = placementWaitId(input);
+  let wait = yield* waits.get(waitId2).pipe(Effect43.mapError(mapWaitServiceError));
   if (wait === undefined) {
     wait = yield* waits.createDetached({
-      waitId,
+      waitId: waitId2,
       executionId: input.executionId,
       mode: "event",
       correlationKey: input.call.id,
@@ -10397,12 +10404,12 @@ var runExternalTool = (repository, waits, call, input) => Effect43.gen(function*
   const waitingCall = call.state === "requested" ? yield* repository.prepareExternalWait({
     executionId: input.executionId,
     callId: input.call.id,
-    waitId,
+    waitId: waitId2,
     availableAt: input.createdAt,
     updatedAt: input.createdAt
   }).pipe(Effect43.mapError(mapRepositoryError3)) : call;
   if (wait.state === "open")
-    return yield* waitRequested(input, waitId);
+    return yield* waitRequested(input, waitId2);
   if (wait.state === "timed_out")
     return placementFailureResult(input, "Tool execution timed out");
   if (wait.state === "cancelled")
@@ -11462,10 +11469,10 @@ var presetMap = (agent) => new Map(Object.entries(agent.child_run_presets ?? {})
     ...preset.metadata === undefined ? {} : { metadata: preset.metadata }
   }
 ]));
-var createJoinWait = Effect52.fn("SpawnChildRunTool.createJoinWait")(function* (config, input, id, waitId, createdAt) {
+var createJoinWait = Effect52.fn("SpawnChildRunTool.createJoinWait")(function* (config, input, id, waitId2, createdAt) {
   const eventSequence = yield* nextEventSequence(config.eventLog, input.execution_id);
   yield* config.waits.createDetached({
-    waitId,
+    waitId: waitId2,
     executionId: input.execution_id,
     mode: "child",
     correlationKey: id,
@@ -11477,7 +11484,7 @@ var createJoinWait = Effect52.fn("SpawnChildRunTool.createJoinWait")(function* (
     createdAt
   }).pipe(Effect52.mapError(mapWaitError));
 });
-var dispatchChild = Effect52.fn("SpawnChildRunTool.dispatchChild")(function* (config, input, id, definition, waitId) {
+var dispatchChild = Effect52.fn("SpawnChildRunTool.dispatchChild")(function* (config, input, id, definition, waitId2) {
   yield* config.dispatch({
     executionId: exports_ids_schema.ExecutionId.make(id),
     rootAddressId: input.address_id,
@@ -11493,7 +11500,7 @@ var dispatchChild = Effect52.fn("SpawnChildRunTool.dispatchChild")(function* (co
     metadata: {
       parent_execution_id: input.execution_id,
       child_execution_id: id,
-      parent_wait_id: waitId
+      parent_wait_id: waitId2
     }
   }).pipe(Effect52.mapError((error5) => ToolRuntimeError.make({ message: String(error5) })));
 });
@@ -11517,10 +11524,10 @@ var run3 = Effect52.fn("SpawnChildRunTool.run")(function* (config, activeToolNam
   if (enforceStaticOrDynamic)
     yield* ensureStaticOrDynamic(input);
   const id = childExecutionId(context);
-  const waitId = childWaitId(id);
-  const existingWait = yield* config.waits.get(waitId).pipe(Effect52.mapError(mapWaitError));
+  const waitId2 = childWaitId(id);
+  const existingWait = yield* config.waits.get(waitId2).pipe(Effect52.mapError(mapWaitError));
   if (existingWait?.state === "open") {
-    return yield* ToolExecutionWaitRequested.make({ tool_name: activeToolName, wait_id: waitId });
+    return yield* ToolExecutionWaitRequested.make({ tool_name: activeToolName, wait_id: waitId2 });
   }
   if (existingWait !== undefined)
     return yield* resultFromTerminal(config, id, existingWait);
@@ -11550,9 +11557,9 @@ var run3 = Effect52.fn("SpawnChildRunTool.run")(function* (config, activeToolNam
       createdAt: context.createdAt + 1
     }).pipe(Effect52.mapError((error5) => mapChildRunError(activeToolName, error5)));
   }
-  yield* createJoinWait(config, spawn, id, waitId, context.createdAt + 2);
-  yield* dispatchChild(config, spawn, id, definition, waitId);
-  return yield* ToolExecutionWaitRequested.make({ tool_name: activeToolName, wait_id: waitId });
+  yield* createJoinWait(config, spawn, id, waitId2, context.createdAt + 2);
+  yield* dispatchChild(config, spawn, id, definition, waitId2);
+  return yield* ToolExecutionWaitRequested.make({ tool_name: activeToolName, wait_id: waitId2 });
 });
 var registeredTool = (config) => tool(toolName, {
   description: "Spawn a durable child run and wait for its terminal output.",
@@ -13353,9 +13360,9 @@ var ActivityNames = {
   accept: `${StartExecutionWorkflowName}/Accept`,
   cancel: (turn) => `${StartExecutionWorkflowName}/Cancel/${turn}`,
   checkCancel: (turn) => `${StartExecutionWorkflowName}/CheckCancel/${turn}`,
-  loadWaitBeforeSleep: (waitId) => `${StartExecutionWorkflowName}/LoadWaitBeforeSleep/${waitId}`,
-  loadWaitAfterWake: (waitId) => `${StartExecutionWorkflowName}/LoadWaitAfterWake/${waitId}`,
-  markWaiting: (waitId) => `${StartExecutionWorkflowName}/MarkWaiting/${waitId}`,
+  loadWaitBeforeSleep: (waitId2) => `${StartExecutionWorkflowName}/LoadWaitBeforeSleep/${waitId2}`,
+  loadWaitAfterWake: (waitId2) => `${StartExecutionWorkflowName}/LoadWaitAfterWake/${waitId2}`,
+  markWaiting: (waitId2) => `${StartExecutionWorkflowName}/MarkWaiting/${waitId2}`,
   ensureWorkspace: `${StartExecutionWorkflowName}/EnsureWorkspace`,
   suspendWorkspace: (key4) => `${StartExecutionWorkflowName}/SuspendWorkspace/${key4}`,
   resumeWorkspace: (key4) => `${StartExecutionWorkflowName}/ResumeWorkspace/${key4}`,
@@ -13410,7 +13417,7 @@ var mapChildExecutionRepositoryError = (error5) => ExecutionWorkflowFailed.make(
 var mapSkillRegistryError = (error5) => ExecutionWorkflowFailed.make({ message: error5.message });
 var mapEventLogError6 = (error5) => ExecutionWorkflowFailed.make({ message: error5._tag });
 var mapWorkspaceError = (error5) => ExecutionWorkflowFailed.make({ message: error5._tag });
-var waitSignal = (waitId) => DurableDeferred.make(`Relay/Execution/Wait/${waitId}`, {
+var waitSignal = (waitId2) => DurableDeferred.make(`Relay/Execution/Wait/${waitId2}`, {
   success: WaitSignal,
   error: ExecutionWorkflowFailed
 });
@@ -13484,8 +13491,8 @@ var acceptExecution = (input) => Activity.make({
 });
 var terminalExecutionStatuses = new Set(["completed", "failed", "cancelled"]);
 var waitIdFromRecord = (record2) => {
-  const waitId = record2.metadata.wait_id;
-  return typeof waitId === "string" ? exports_ids_schema.WaitId.make(waitId) : undefined;
+  const waitId2 = record2.metadata.wait_id;
+  return typeof waitId2 === "string" ? exports_ids_schema.WaitId.make(waitId2) : undefined;
 };
 var prepareCancellation = Effect67.fn("ExecutionWorkflow.prepareCancellation")(function* (input) {
   const repository = yield* exports_execution_repository.Service;
@@ -13633,11 +13640,11 @@ var loadCancellationRequested = (input, turn) => Activity.make({
     return record2?.metadata?.cancellation_requested === true;
   })
 });
-var loadWait = (name, waitId) => Activity.make({
+var loadWait = (name, waitId2) => Activity.make({
   name,
   success: Schema61.UndefinedOr(WaitSnapshot),
   error: ExecutionWorkflowFailed,
-  execute: get11(waitId).pipe(Effect67.map((record2) => record2 === undefined ? undefined : toWaitSnapshot(record2)), Effect67.mapError(mapWaitError2))
+  execute: get11(waitId2).pipe(Effect67.map((record2) => record2 === undefined ? undefined : toWaitSnapshot(record2)), Effect67.mapError(mapWaitError2))
 });
 var markWaiting = (input, repository, wait) => Activity.make({
   name: ActivityNames.markWaiting(wait.id),
@@ -13757,7 +13764,7 @@ var failWorkspace = (input, error5) => fail({
 }).pipe(Effect67.catch(() => Effect67.void));
 var attachWorkspace = (input) => attach({ executionId: input.execution_id, now: input.started_at }).pipe(Effect67.mapError(mapWorkspaceError));
 var sessionEntryScope = Function13.dual(2, (input, turn) => `${input.execution_id}:${workflowGenerationForStart(input)}:complete:${turn}`);
-var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn, pendingSuspension) => Activity.make({
+var completeExecution = (input, waitId2, waitState, workspaceRuntimeLayer, turn, pendingSuspension) => Activity.make({
   name: ActivityNames.complete(turn),
   success: exports_execution_schema.Execution,
   error: ExecutionWorkflowFailed,
@@ -13811,8 +13818,8 @@ var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn,
     const program = activeProgram.pipe(Effect67.map((result) => ({
       metadata: {
         ...result.metadata,
-        ...waitId === undefined ? {} : { wait_id: waitId },
-        ...waitId === undefined || waitState === undefined ? {} : { wait_state: waitState }
+        ...waitId2 === undefined ? {} : { wait_id: waitId2 },
+        ...waitId2 === undefined || waitState === undefined ? {} : { wait_state: waitState }
       },
       nextEventSequence: result.nextEventSequence
     })), Effect67.catchTag("AgentLoopWaitRequested", (wait) => Effect67.succeed({
@@ -13906,8 +13913,8 @@ var terminalOutput = (execution) => {
   const output = execution.metadata?.model_output;
   return typeof output === "string" ? [exports_content_schema.text(output)] : [];
 };
-var missingWait = (waitId) => ExecutionWorkflowFailed.make({ message: `Wait not found: ${waitId}` });
-var stillOpen = (waitId) => ExecutionWorkflowFailed.make({ message: `Wait remained open after wake: ${waitId}` });
+var missingWait = (waitId2) => ExecutionWorkflowFailed.make({ message: `Wait not found: ${waitId2}` });
+var stillOpen = (waitId2) => ExecutionWorkflowFailed.make({ message: `Wait remained open after wake: ${waitId2}` });
 var resolveWaitState = Effect67.fn("ExecutionWorkflow.resolveWaitState")(function* (input, repository) {
   if (input.wait_id === undefined)
     return;
@@ -13930,32 +13937,32 @@ var resolveWaitState = Effect67.fn("ExecutionWorkflow.resolveWaitState")(functio
   return afterTerminal;
 });
 var waitIdFromExecution = (execution) => {
-  const waitId = execution.metadata?.wait_id;
-  return typeof waitId === "string" ? exports_ids_schema.WaitId.make(waitId) : undefined;
+  const waitId2 = execution.metadata?.wait_id;
+  return typeof waitId2 === "string" ? exports_ids_schema.WaitId.make(waitId2) : undefined;
 };
 var pendingSuspensionFromExecution = (execution) => {
   const pending = execution.metadata?.pending_agent_suspension;
   return Schema61.decodeUnknownOption(exports_agent_event.AgentSuspended)(pending).pipe(Option15.getOrUndefined);
 };
-var finishCancelledWait = Effect67.fn("ExecutionWorkflow.finishCancelledWait")(function* (startInput, turn, waitId) {
+var finishCancelledWait = Effect67.fn("ExecutionWorkflow.finishCancelledWait")(function* (startInput, turn, waitId2) {
   const cancelled = yield* cancelExecution(startInput, turn, "wait cancelled");
   yield* releaseWorkspace(startInput);
   yield* notifyParent(startInput, "cancelled", []);
   return {
     execution_id: cancelled.id,
     status: cancelled.status,
-    wait_id: waitId,
+    wait_id: waitId2,
     wait_state: "cancelled",
     ...cancelled.metadata === undefined ? {} : { metadata: cancelled.metadata }
   };
 });
-var continueAsNew = (startInput, turn, waitId, pendingSuspension) => Activity.make({
+var continueAsNew = (startInput, turn, waitId2, pendingSuspension) => Activity.make({
   name: ActivityNames.continueAsNew(turn),
   success: StartResult,
   error: ExecutionWorkflowError,
   execute: StartExecutionWorkflow.execute({
     ...startInput,
-    wait_id: waitId,
+    wait_id: waitId2,
     resume_suspension: pendingSuspension,
     workflow_generation: workflowGenerationForStart(startInput) + 1
   })
@@ -14016,8 +14023,8 @@ var runWorkflow = Effect67.fn("ExecutionWorkflow.run")(function* (input) {
         break;
       if (turn >= maxWaitTurns)
         return yield* ExecutionWorkflowFailed.make({ message: "Agent wait turn limit exceeded" });
-      const waitId = waitIdFromExecution(execution);
-      if (waitId === undefined)
+      const waitId2 = waitIdFromExecution(execution);
+      if (waitId2 === undefined)
         return yield* ExecutionWorkflowFailed.make({ message: "Waiting execution missing wait id" });
       pendingSuspension = pendingSuspensionFromExecution(execution);
       if (pendingSuspension === undefined) {
@@ -14027,14 +14034,14 @@ var runWorkflow = Effect67.fn("ExecutionWorkflow.run")(function* (input) {
         yield* failIncompatibleCheckpoint(startInput, error5);
         return yield* error5;
       }
-      activeWaitId = waitId;
-      waitState = yield* resolveWaitState({ ...startInput, wait_id: waitId }, repository);
+      activeWaitId = waitId2;
+      waitState = yield* resolveWaitState({ ...startInput, wait_id: waitId2 }, repository);
       if (waitState === "cancelled") {
-        return yield* finishCancelledWait(startInput, turn + 1, waitId);
+        return yield* finishCancelledWait(startInput, turn + 1, waitId2);
       }
       turn += 1;
       if (continueAsNewAfterTurns !== undefined && turn >= continueAsNewAfterTurns) {
-        return yield* continueAsNew(startInput, turn, waitId, pendingSuspension);
+        return yield* continueAsNew(startInput, turn, waitId2, pendingSuspension);
       }
     }
     yield* releaseWorkspace(startInput);
@@ -14053,11 +14060,11 @@ var awaitCanonicalSettledResult = Effect67.fn("ExecutionWorkflow.awaitCanonicalS
     until: (record2) => record2?.status === "waiting" || record2 !== undefined && terminalExecutionStatuses.has(record2.status)
   }));
   const canonicalWaitId = execution?.metadata?.wait_id;
-  const waitId = typeof canonicalWaitId === "string" ? exports_ids_schema.WaitId.make(canonicalWaitId) : input.wait_id;
+  const waitId2 = typeof canonicalWaitId === "string" ? exports_ids_schema.WaitId.make(canonicalWaitId) : input.wait_id;
   const result = {
     execution_id: input.execution_id,
     status: execution?.status ?? "waiting",
-    ...waitId === undefined ? {} : { wait_id: waitId },
+    ...waitId2 === undefined ? {} : { wait_id: waitId2 },
     ...execution?.metadata === undefined ? {} : { metadata: execution.metadata }
   };
   return result;
@@ -14095,14 +14102,14 @@ var startRequest = Effect67.fn("ExecutionWorkflow.startRequest")(function* (inpu
     }
     const workflowExecutionId2 = yield* activeWorkflowExecutionIdForExecution(input.execution_id);
     const existingWaitId = existing.metadata?.wait_id;
-    const waitId = typeof existingWaitId === "string" ? exports_ids_schema.WaitId.make(existingWaitId) : undefined;
-    if (existing.status === "waiting" && waitId !== undefined) {
-      const wait = yield* get11(waitId).pipe(Effect67.mapError(mapWaitError2));
+    const waitId2 = typeof existingWaitId === "string" ? exports_ids_schema.WaitId.make(existingWaitId) : undefined;
+    if (existing.status === "waiting" && waitId2 !== undefined) {
+      const wait = yield* get11(waitId2).pipe(Effect67.mapError(mapWaitError2));
       const state = wait === undefined ? undefined : terminalWaitState(toWaitSnapshot(wait));
       if (state !== undefined) {
         yield* signalWait({
           workflow_execution_id: workflowExecutionId2,
-          wait_id: waitId,
+          wait_id: waitId2,
           state,
           signaled_at: wait?.resolvedAt ?? input.started_at
         });
@@ -14241,9 +14248,9 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service62, Effect69.gen(f
       const findOpenByCorrelation = envelopes.findOpenByCorrelation;
       const wait = findOpenByCorrelation === undefined ? undefined : yield* findOpenByCorrelation(input.executionId, `inbox:${input.executionId}`).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: input.executionId, message: error5.message })));
       if (wait?.state === "open") {
-        const waitId = wait.id;
+        const waitId2 = wait.id;
         const sequence = yield* nextSequence(eventLog, input.executionId).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: input.executionId, message: error5._tag })));
-        const transition3 = yield* waits.wake({ waitId, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({
+        const transition3 = yield* waits.wake({ waitId: waitId2, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({
           execution_id: input.executionId,
           message: error5._tag === "WaitNotFound" ? error5.wait_id : error5.message
         })));
@@ -14269,14 +14276,14 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service62, Effect69.gen(f
     }),
     undrainedCount: (id) => repository.countUndrained(id).pipe(Effect69.mapError((error5) => InboxServiceError.make({ message: error5.message }))),
     reply: Effect69.fn("InboxService.reply")(function* (input) {
-      const waitId = exports_ids_schema.WaitId.make(input.replyToken);
-      const wait = yield* waits.get(waitId).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
+      const waitId2 = exports_ids_schema.WaitId.make(input.replyToken);
+      const wait = yield* waits.get(waitId2).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
       if (wait === undefined || wait.state !== "open" || wait.envelopeId === undefined)
         return yield* InboxReplyTokenInvalid.make({ reply_token: input.replyToken });
       const original = yield* envelopes.getEnvelope(wait.envelopeId).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
       if (original === undefined)
         return yield* InboxReplyTokenInvalid.make({ reply_token: input.replyToken });
-      const envelopeId = exports_ids_schema.EnvelopeId.make(`envelope:reply:${waitId}`);
+      const envelopeId = exports_ids_schema.EnvelopeId.make(`envelope:reply:${waitId2}`);
       yield* envelopes.acceptEnvelope({
         envelope: {
           id: envelopeId,
@@ -14289,7 +14296,7 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service62, Effect69.gen(f
         }
       }).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: wait.executionId, message: error5.message })));
       const sequence = yield* nextSequence(eventLog, wait.executionId).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: wait.executionId, message: error5._tag })));
-      const transition3 = yield* waits.wake({ waitId, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
+      const transition3 = yield* waits.wake({ waitId: waitId2, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
       if (!transition3.transitioned)
         return yield* InboxReplyTokenInvalid.make({ reply_token: input.replyToken });
       if (signalDependencies !== undefined) {
@@ -14301,7 +14308,7 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service62, Effect69.gen(f
           signaledAt: input.createdAt
         }).pipe(Effect69.provideService(exports_execution_repository.Service, signalDependencies.executionRepository), Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: wait.executionId, message: String(error5) })));
       }
-      return { envelope_id: envelopeId, execution_id: wait.executionId, wait_id: waitId };
+      return { envelope_id: envelopeId, execution_id: wait.executionId, wait_id: waitId2 };
     })
   });
 }));
@@ -14454,8 +14461,8 @@ var registeredTool4 = (config) => tool(toolName4, {
   requiredPermissions: [permissionName4],
   metadata: { relay_core_tool: true },
   run: (input, context) => Effect72.gen(function* () {
-    const waitId = exports_ids_schema.WaitId.make(`wait:inbox:${context.call.id}`);
-    const existing = yield* config.waits.get(waitId).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
+    const waitId2 = exports_ids_schema.WaitId.make(`wait:inbox:${context.call.id}`);
+    const existing = yield* config.waits.get(waitId2).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
     const drain2 = () => config.inbox.drain({ executionId: context.executionId, drainId: context.call.id }).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
     if (existing?.state === "timed_out")
       return { status: "timed_out", messages: [] };
@@ -14464,7 +14471,7 @@ var registeredTool4 = (config) => tool(toolName4, {
       return { status: "messages", messages: drained.map(project) };
     }
     if (existing?.state === "open")
-      return yield* ToolExecutionWaitRequested.make({ tool_name: toolName4, wait_id: waitId });
+      return yield* ToolExecutionWaitRequested.make({ tool_name: toolName4, wait_id: waitId2 });
     const count = yield* config.inbox.undrainedCount(context.executionId).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
     if (count > 0) {
       const drained = yield* drain2();
@@ -14472,7 +14479,7 @@ var registeredTool4 = (config) => tool(toolName4, {
     }
     if (existing === undefined)
       yield* config.waits.createDetached({
-        waitId,
+        waitId: waitId2,
         executionId: context.executionId,
         mode: "event",
         correlationKey: `inbox:${context.executionId}`,
@@ -14482,13 +14489,13 @@ var registeredTool4 = (config) => tool(toolName4, {
       }).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
     if ((yield* config.inbox.undrainedCount(context.executionId).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })))) > 0) {
       const sequence = yield* config.eventLog.maxSequence(context.executionId).pipe(Effect72.map((value) => (value ?? -1) + 1), Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5._tag })));
-      const transition3 = yield* config.waits.wake({ waitId, resolvedAt: context.createdAt, eventSequence: sequence }).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5._tag })));
+      const transition3 = yield* config.waits.wake({ waitId: waitId2, resolvedAt: context.createdAt, eventSequence: sequence }).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5._tag })));
       if (transition3.transitioned) {
         const drained = yield* drain2();
         return { status: "messages", messages: drained.map(project) };
       }
     }
-    return yield* ToolExecutionWaitRequested.make({ tool_name: toolName4, wait_id: waitId });
+    return yield* ToolExecutionWaitRequested.make({ tool_name: toolName4, wait_id: waitId2 });
   })
 });
 
@@ -14669,18 +14676,18 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
       });
       const envelope = envelopeFrom(input);
       const ready = readyFor(input, route);
-      const waitId = waitIdFor(input);
+      const waitId2 = waitIdFor(input);
       const replayed = yield* repository.getEnvelope(envelope.id).pipe(Effect74.mapError(mapRepositoryError11));
       if (replayed !== undefined) {
         if (route.kind === "local-execution" && inbox._tag === "Some" && input.input.idempotency_key !== undefined) {
-          if (waitId !== undefined) {
-            yield* inbox.value.ensureReplyWait({ envelope, waitId }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
+          if (waitId2 !== undefined) {
+            yield* inbox.value.ensureReplyWait({ envelope, waitId: waitId2 }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
           }
           yield* inbox.value.deliver({
             executionId: exports_ids_schema.ExecutionId.make(route.route_key),
             envelope,
             idempotencyKey: input.input.idempotency_key,
-            ...waitId === undefined ? {} : { replyWaitId: waitId },
+            ...waitId2 === undefined ? {} : { replyWaitId: waitId2 },
             eventSequence: input.eventSequence,
             createdAt: input.createdAt
           }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
@@ -14688,7 +14695,7 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
         const recorded = {
           envelope_id: envelope.id,
           execution_id: envelope.execution_id,
-          ...waitId === undefined ? {} : { wait_id: waitId }
+          ...waitId2 === undefined ? {} : { wait_id: waitId2 }
         };
         return Object.defineProperty(recorded, "route_kind", { value: route.kind });
       }
@@ -14701,17 +14708,17 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
           envelope,
           acceptance: {
             envelope,
-            ...waitId === undefined ? {} : { waitId }
+            ...waitId2 === undefined ? {} : { waitId: waitId2 }
           },
           ...input.input.idempotency_key === undefined ? {} : { idempotencyKey: input.input.idempotency_key },
-          ...waitId === undefined ? {} : { replyWaitId: waitId },
+          ...waitId2 === undefined ? {} : { replyWaitId: waitId2 },
           eventSequence: input.eventSequence,
           createdAt: input.createdAt
         }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
         accepted2 = {
           envelope_id: envelope.id,
           execution_id: envelope.execution_id,
-          ...waitId === undefined ? {} : { wait_id: waitId }
+          ...waitId2 === undefined ? {} : { wait_id: waitId2 }
         };
         if (delivery.deduplicated) {
           return Object.defineProperty(accepted2, "route_kind", { value: route.kind });
@@ -14719,7 +14726,7 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
       } else {
         accepted2 = yield* repository.acceptEnvelope({
           envelope,
-          ...waitId === undefined ? {} : { waitId },
+          ...waitId2 === undefined ? {} : { waitId: waitId2 },
           ...ready === undefined ? {} : { ready }
         }).pipe(Effect74.mapError(mapRepositoryError11));
       }
@@ -14728,8 +14735,8 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
       if (ready !== undefined) {
         yield* appendIdempotentTo(eventLog, readyEvent(input, ready)).pipe(Effect74.mapError(mapEventLogError7));
       }
-      if (route.kind === "local-execution" && inbox._tag === "Some" && waitId !== undefined) {
-        yield* inbox.value.ensureReplyWait({ envelope, waitId }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
+      if (route.kind === "local-execution" && inbox._tag === "Some" && waitId2 !== undefined) {
+        yield* inbox.value.ensureReplyWait({ envelope, waitId: waitId2 }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
       }
       yield* recordEnvelopeSent(route.kind);
       return Object.defineProperty(accepted2, "route_kind", { value: route.kind });
@@ -14795,9 +14802,9 @@ var layerFromEpoch = (epoch) => exports_instructions.layer(epoch.baseline.length
 // ../runtime/src/agent/relay-permissions.ts
 import { Clock as Clock15, Effect as Effect76, Layer as Layer67, Option as Option16, Schema as Schema69 } from "effect";
 var jsonValue3 = (value) => Schema69.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
-var waitIdForToolCall = (toolCallId) => exports_ids_schema.WaitId.make(`wait:permission:${toolCallId}`);
+var waitIdForToolCall = (executionId, toolCallId) => Identifiers.waitId("permission", executionId, toolCallId);
 var fallbackToolCallId = (request) => `${request.agentName}:${request.turn}:${request.tool}`;
-var tokenFor = (request) => waitIdForToolCall(request.toolCallId ?? fallbackToolCallId(request));
+var tokenFor = (executionId, request) => waitIdForToolCall(executionId, request.toolCallId ?? fallbackToolCallId(request));
 var matchingRule = (rules, tool3, params) => {
   let matched;
   for (const rule of rules) {
@@ -14806,7 +14813,7 @@ var matchingRule = (rules, tool3, params) => {
   }
   return matched;
 };
-var staticDecision = (ruleset, request) => {
+var staticDecision = (executionId, ruleset, request) => {
   const rule = matchingRule(ruleset.rules, request.tool, request.params);
   const level = rule?.level ?? ruleset.fallback ?? "ask";
   switch (level) {
@@ -14818,7 +14825,7 @@ var staticDecision = (ruleset, request) => {
         ...rule?.reason === undefined ? {} : { reason: rule.reason }
       };
     case "ask":
-      return { _tag: "Ask", token: tokenFor(request) };
+      return { _tag: "Ask", token: tokenFor(executionId, request) };
   }
 };
 var evaluateDecision = Effect76.fn("RelayPermissions.evaluateDecision")(function* (config, request) {
@@ -14834,10 +14841,10 @@ var evaluateDecision = Effect76.fn("RelayPermissions.evaluateDecision")(function
           ...rule.reason === undefined ? {} : { reason: rule.reason }
         };
       case "ask":
-        return { _tag: "Ask", token: tokenFor(request) };
+        return { _tag: "Ask", token: tokenFor(config.executionId, request) };
     }
   }
-  return staticDecision(config.ruleset, request);
+  return staticDecision(config.executionId, config.ruleset, request);
 });
 var permissionError = (message) => exports_permissions.PermissionError.make({ message });
 var createdAtForSequence = (config, sequence) => config.startedAt + sequence - config.eventSequence;
@@ -14849,18 +14856,18 @@ var allocateEventSequence = Effect76.fn("RelayPermissions.allocateEventSequence"
   return sequence;
 });
 var resetAllocatorToLog = (config) => config.allocator.current.pipe(Effect76.flatMap((current2) => nextLoggedSequence(config.eventLog, config.executionId, current2)), Effect76.flatMap(config.allocator.resetTo));
-var permissionRequestedCursor = (config, pending, waitId) => `${config.executionId}:permission:${pending.toolCallId ?? waitId}:requested`;
+var permissionRequestedCursor = (config, pending, waitId2) => `${config.executionId}:permission:${pending.toolCallId ?? waitId2}:requested`;
 var permissionResolvedCursor = (config, pending, wait) => `${config.executionId}:permission:${pending.toolCallId ?? wait.id}:resolved`;
-var permissionRequestedEvent = (config, pending, waitId, sequence) => ({
-  id: exports_ids_schema.EventId.make(`event:${pending.toolCallId ?? waitId}:permission-requested`),
+var permissionRequestedEvent = (config, pending, waitId2, sequence) => ({
+  id: Identifiers.eventId(config.executionId, pending.toolCallId ?? waitId2, "permission-requested"),
   execution_id: config.executionId,
   type: "permission.ask.requested",
   sequence,
-  cursor: permissionRequestedCursor(config, pending, waitId),
+  cursor: permissionRequestedCursor(config, pending, waitId2),
   data: {
     tool_call_id: pending.toolCallId ?? pending.token,
     tool_name: pending.tool,
-    wait_id: waitId,
+    wait_id: waitId2,
     input: jsonValue3(pending.params),
     agent_name: pending.agentName,
     scope: config.scope
@@ -14887,7 +14894,7 @@ var answerForWait = (wait) => {
   return { _tag: "Denied", reason: "Permission denied" };
 };
 var permissionResolvedEvent = (config, pending, wait, answer, sequence) => ({
-  id: exports_ids_schema.EventId.make(`event:${pending.toolCallId ?? wait.id}:permission-resolved`),
+  id: Identifiers.eventId(config.executionId, pending.toolCallId ?? wait.id, "permission-resolved"),
   execution_id: config.executionId,
   type: "permission.ask.resolved",
   sequence,
@@ -14907,19 +14914,19 @@ var appendPermissionEvent = (config, event) => appendIdempotentTo(config.eventLo
   onNone: () => Effect76.fail(permissionError(error5.message)),
   onSome: (prior) => samePermissionEvent(prior, event) ? Effect76.succeed(prior) : Effect76.fail(permissionError(error5.message))
 })))), Effect76.mapError((error5) => permissionError(error5.message)), Effect76.tap(() => resetAllocatorToLog(config)));
-var ensurePermissionRequestedEvent = Effect76.fn("RelayPermissions.ensurePermissionRequestedEvent")(function* (config, pending, waitId) {
-  const cursor = permissionRequestedCursor(config, pending, waitId);
+var ensurePermissionRequestedEvent = Effect76.fn("RelayPermissions.ensurePermissionRequestedEvent")(function* (config, pending, waitId2) {
+  const cursor = permissionRequestedCursor(config, pending, waitId2);
   const existing = yield* findEventByCursor(config, cursor);
   if (Option16.isSome(existing))
     return;
   const requestedSequence = yield* allocateEventSequence(config);
-  yield* appendPermissionEvent(config, permissionRequestedEvent(config, pending, waitId, requestedSequence));
+  yield* appendPermissionEvent(config, permissionRequestedEvent(config, pending, waitId2, requestedSequence));
 });
 var createAsk = Effect76.fn("RelayPermissions.createAsk")(function* (config, pending) {
-  const waitId = exports_ids_schema.WaitId.make(pending.token);
+  const waitId2 = exports_ids_schema.WaitId.make(pending.token);
   const waitSequence = yield* allocateEventSequence(config);
   yield* config.waits.createDetached({
-    waitId,
+    waitId: waitId2,
     executionId: config.executionId,
     mode: "event",
     correlationKey: pending.toolCallId ?? pending.token,
@@ -14934,17 +14941,17 @@ var createAsk = Effect76.fn("RelayPermissions.createAsk")(function* (config, pen
     eventSequence: waitSequence,
     createdAt: createdAtForSequence(config, waitSequence)
   }).pipe(Effect76.mapError((error5) => permissionError(error5.message)));
-  yield* ensurePermissionRequestedEvent(config, pending, waitId);
+  yield* ensurePermissionRequestedEvent(config, pending, waitId2);
 });
 var awaitAnswer = Effect76.fn("RelayPermissions.awaitAnswer")(function* (config, pending) {
-  const waitId = exports_ids_schema.WaitId.make(pending.token);
-  const existing = yield* config.waits.get(waitId).pipe(Effect76.mapError((error5) => permissionError(error5.message)));
+  const waitId2 = exports_ids_schema.WaitId.make(pending.token);
+  const existing = yield* config.waits.get(waitId2).pipe(Effect76.mapError((error5) => permissionError(error5.message)));
   if (existing === undefined) {
     yield* createAsk(config, pending);
     return Option16.none();
   }
   if (existing.state === "open") {
-    yield* ensurePermissionRequestedEvent(config, pending, waitId);
+    yield* ensurePermissionRequestedEvent(config, pending, waitId2);
     return Option16.none();
   }
   const answer = answerForWait(existing);
@@ -16344,16 +16351,16 @@ var make12 = Effect86.gen(function* () {
     }).pipe(Effect86.mapError(toSchedulerError));
   }).pipe(Effect86.withSpan("SchedulerService.dispatchStartExecution"));
   const dispatchWaitTransition = (schedule, now) => Effect86.gen(function* () {
-    const waitId = schedule.wait_id;
-    if (waitId === undefined) {
+    const waitId2 = schedule.wait_id;
+    if (waitId2 === undefined) {
       return yield* SchedulerError.make({ message: `Schedule ${schedule.id} is missing wait_id` });
     }
-    const wait = yield* waits.get(waitId).pipe(Effect86.mapError(toSchedulerError));
+    const wait = yield* waits.get(waitId2).pipe(Effect86.mapError(toSchedulerError));
     if (wait === undefined || wait.state !== "open")
       return;
     const eventSequence = yield* nextEventSequence5(eventLog, wait.executionId);
     const metadata11 = dispatchMetadata(schedule);
-    const result = schedule.target_kind === "wake-wait" ? yield* waits.wake({ waitId, resolvedAt: now, eventSequence, metadata: metadata11 }).pipe(Effect86.mapError(toSchedulerError)) : yield* waits.timeout({ waitId, timedOutAt: now, eventSequence, metadata: metadata11 }).pipe(Effect86.mapError(toSchedulerError));
+    const result = schedule.target_kind === "wake-wait" ? yield* waits.wake({ waitId: waitId2, resolvedAt: now, eventSequence, metadata: metadata11 }).pipe(Effect86.mapError(toSchedulerError)) : yield* waits.timeout({ waitId: waitId2, timedOutAt: now, eventSequence, metadata: metadata11 }).pipe(Effect86.mapError(toSchedulerError));
     if (!result.transitioned)
       return;
     yield* signalWorkflowWait({
@@ -17590,13 +17597,13 @@ var toToolWorkLease = (lease) => ({
   claim_expires_at: lease.claimExpiresAt,
   idempotency_key: lease.idempotencyKey
 });
-var toolWaitId = (callId) => exports_ids_schema.WaitId.make(`wait:tool:${callId}`);
+var toolWaitId = (executionId, callId) => Identifiers.waitId("tool", executionId, callId);
 var acceptedWaitOutcome = (wait) => Schema83.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect90.mapError(toClientError));
 var resolveToolOutcomeWait = Effect90.fn("Client.resolveToolOutcomeWait")(function* (waits, eventLog, call, outcome, completedAt) {
-  const waitId = call.waitId ?? toolWaitId(call.call.id);
-  const wait = yield* waits.get(waitId).pipe(Effect90.mapError(toClientError));
+  const waitId2 = call.waitId ?? toolWaitId(call.executionId, call.call.id);
+  const wait = yield* waits.get(waitId2).pipe(Effect90.mapError(toClientError));
   if (wait === undefined)
-    return yield* ClientError.make({ message: `Tool wait not found: ${waitId}` });
+    return yield* ClientError.make({ message: `Tool wait not found: ${waitId2}` });
   if (wait.executionId !== call.executionId) {
     return yield* ClientError.make({ message: `Tool wait does not match call: ${call.call.id}` });
   }
@@ -17612,7 +17619,7 @@ var resolveToolOutcomeWait = Effect90.fn("Client.resolveToolOutcomeWait")(functi
   }
   const eventSequence = yield* nextEventSequence6(eventLog, call.executionId);
   const resolved = yield* waits.wake({
-    waitId,
+    waitId: waitId2,
     resolvedAt: completedAt,
     eventSequence,
     metadata: { kind: "tool-placement", external_outcome: outcome }
@@ -17757,10 +17764,10 @@ var childSpawnFingerprint = (record2) => {
   return typeof fingerprint === "string" ? fingerprint : undefined;
 };
 var createChildJoinWait = Effect90.fn("Client.createChildJoinWait")(function* (waits, eventLog, input, accepted2, createdAt) {
-  const waitId = childJoinWaitId(accepted2.child_execution_id);
+  const waitId2 = childJoinWaitId(accepted2.child_execution_id);
   const eventSequence = yield* nextEventSequence6(eventLog, input.execution_id);
   yield* waits.createDetached({
-    waitId,
+    waitId: waitId2,
     executionId: input.execution_id,
     mode: "child",
     correlationKey: accepted2.child_execution_id,
@@ -17771,7 +17778,7 @@ var createChildJoinWait = Effect90.fn("Client.createChildJoinWait")(function* (w
     eventSequence,
     createdAt
   }).pipe(Effect90.mapError(toClientError));
-  return waitId;
+  return waitId2;
 });
 var reconcileExistingChildSpawn = Effect90.fn("Client.reconcileExistingChildSpawn")(function* (childExecutions, waits, eventLog, input) {
   const childExecutionId3 = childExecutionIdForSpawn(input);

package/dist/{index-cyfx5y3r.js → index-mtvz1bjn.js}

@@ -1114,42 +1114,46 @@ var Classification = Schema17.Union([
   TimerWait,
   ExternalWait
 ]).annotate({ identifier: "Relay.WaitClassification" });
-var suffixAfter = (waitId, namespace) => waitId.slice(namespace.length);
+var scopedToolCallId = (waitId, namespace) => {
+  const scope = waitId.slice(namespace.length);
+  const separator = scope.indexOf(":");
+  return ToolCallId.make(decodeURIComponent(scope.slice(separator + 1)));
+};
 var classify = (input) => {
   const waitId = input.wait_id;
   if (waitId.startsWith("wait:permission:")) {
     return {
       kind: "permission",
       wait_id: waitId,
-      tool_call_id: ToolCallId.make(suffixAfter(waitId, "wait:permission:"))
+      tool_call_id: scopedToolCallId(waitId, "wait:permission:")
     };
   }
   if (waitId.startsWith("wait:approval:")) {
     return {
       kind: "tool_approval",
       wait_id: waitId,
-      tool_call_id: ToolCallId.make(suffixAfter(waitId, "wait:approval:"))
+      tool_call_id: scopedToolCallId(waitId, "wait:approval:")
     };
   }
   if (waitId.startsWith("wait:child:")) {
     return {
       kind: "child_join",
       wait_id: waitId,
-      child_execution_id: ChildExecutionId.make(suffixAfter(waitId, "wait:child:"))
+      child_execution_id: ChildExecutionId.make(waitId.slice("wait:child:".length))
     };
   }
   if (waitId.startsWith("wait:inbox:")) {
     return {
       kind: "inbox",
       wait_id: waitId,
-      tool_call_id: ToolCallId.make(suffixAfter(waitId, "wait:inbox:"))
+      tool_call_id: ToolCallId.make(waitId.slice("wait:inbox:".length))
     };
   }
   if (waitId.startsWith("wait:tool:")) {
     return {
       kind: "tool_placement",
       wait_id: waitId,
-      tool_call_id: ToolCallId.make(suffixAfter(waitId, "wait:tool:"))
+      tool_call_id: scopedToolCallId(waitId, "wait:tool:")
     };
   }
   if (waitId.startsWith("wait:reply:") || input.envelope_id !== undefined && input.mode === "reply") {

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   exports_tool_runtime,
   exports_workflow_definition_host,
   makeDatabaseIdentity
-} from "./index-cq8t8ka1.js";
+} from "./index-e02krw55.js";
 import {
   exports_model_registry
 } from "./index-8fpd6kvj.js";
@@ -40,7 +40,7 @@ import {
   exports_tool_schema,
   exports_wait_schema,
   exports_workflow_schema
-} from "./index-cyfx5y3r.js";
+} from "./index-mtvz1bjn.js";
 import {
   __export
 } from "./index-nb39b5ae.js";

package/dist/mysql.js

@@ -2,14 +2,14 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-5dqkw53p.js";
+} from "./index-2vsf6dks.js";
 import {
   MigratorError,
   RuntimeMigrationError,
   SqlFailure
-} from "./index-cq8t8ka1.js";
+} from "./index-e02krw55.js";
 import"./index-8fpd6kvj.js";
-import"./index-cyfx5y3r.js";
+import"./index-mtvz1bjn.js";
 import"./index-nb39b5ae.js";
 
 // src/mysql.ts

package/dist/postgres.js

@@ -2,7 +2,7 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-5dqkw53p.js";
+} from "./index-2vsf6dks.js";
 import {
   Dialect,
   RuntimeMigrationError,
@@ -14,11 +14,11 @@ import {
   fromDbTimestamp,
   fromNullableDbTimestamp,
   timestampParam
-} from "./index-cq8t8ka1.js";
+} from "./index-e02krw55.js";
 import"./index-8fpd6kvj.js";
 import {
   exports_ids_schema
-} from "./index-cyfx5y3r.js";
+} from "./index-mtvz1bjn.js";
 import {
   __export
 } from "./index-nb39b5ae.js";

package/dist/sqlite.js

@@ -2,7 +2,7 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-5dqkw53p.js";
+} from "./index-2vsf6dks.js";
 import {
   DatabaseAlreadyOwned,
   RuntimeConfigurationError,
@@ -12,9 +12,9 @@ import {
   make,
   makeDatabaseIdentity,
   runtimeLayer
-} from "./index-cq8t8ka1.js";
+} from "./index-e02krw55.js";
 import"./index-8fpd6kvj.js";
-import"./index-cyfx5y3r.js";
+import"./index-mtvz1bjn.js";
 import"./index-nb39b5ae.js";
 
 // src/sqlite-runtime.ts

package/dist/types/runtime/agent/relay-permissions.d.ts

@@ -21,5 +21,4 @@ export interface Config {
     readonly startedAt: number;
     readonly eventSequence: Execution.ExecutionEventSequence;
 }
-export declare const waitIdForToolCall: (toolCallId: string) => string & import("effect/Brand").Brand<"Relay.WaitId">;
 export declare const layer: (config: Config) => Layer.Layer<Permissions.Permissions | Permissions.RuleStore, never, never>;

package/dist/types/runtime/tool/tool-runtime-identifiers.d.ts

@@ -0,0 +1,9 @@
+import { Ids } from "../../schema/index";
+export type ToolWaitKind = "approval" | "permission" | "tool";
+declare const eventId: (executionId: Ids.ExecutionId, toolCallId: Ids.ToolCallId | string, kind: "tool-requested" | "tool-result" | "approval-requested" | "approval-resolved" | "permission-requested" | "permission-resolved") => string & import("effect/Brand").Brand<"Relay.EventId">;
+declare const waitId: (kind: ToolWaitKind, executionId: Ids.ExecutionId, toolCallId: Ids.ToolCallId | string) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+export declare const Identifiers: {
+    eventId: typeof eventId;
+    waitId: typeof waitId;
+};
+export {};

package/dist/types/runtime/tool/tool-runtime-service.d.ts

@@ -6,6 +6,7 @@ import { Service as EventLogService } from "../execution/event-log-service";
 import { Service as WaitServiceService } from "../wait/wait-service";
 export * from "./tool-runtime-contract";
 import { Service } from "./tool-runtime-contract";
+export { Identifiers } from "./tool-runtime-identifiers";
 import type { DynamicToolOptions, PlacedToolOptions, RegisteredTool, RunInput, ToolkitRegistrationOptions, ToolOptions } from "./tool-runtime-contract";
 export declare const toolFromRegistered: (tool: RegisteredTool) => AiTool.Any;
 export declare const toolsFromToolkit: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@relayfx/sdk",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Effect-native durable execution SDK for addressable agents and tools",
   "type": "module",
   "exports": {