@relayfx/sdk 0.0.41 → 0.0.43

package/dist/ai.js

@@ -8318,7 +8318,7 @@ __export(exports_agent_loop_service, {
   AgentLoopBudgetExceeded: () => AgentLoopBudgetExceeded
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/agent.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/agent.ts
 var exports_agent = {};
 __export(exports_agent, {
   streamObject: () => streamObject,
@@ -8328,10 +8328,10 @@ __export(exports_agent, {
   generate: () => generate,
   defaultObjectPrompt: () => defaultObjectPrompt
 });
-import { Cause as Cause3, Effect as Effect45, Fiber, Option as Option15, Queue as Queue2, Ref as Ref10, Schema as Schema45, Stream as Stream7 } from "effect";
+import { Cause as Cause3, Effect as Effect45, Fiber, Option as Option15, Queue as Queue2, Ref as Ref10, Schema as Schema47, Stream as Stream7 } from "effect";
 import { Chat, LanguageModel as LanguageModel3, Prompt as Prompt4, Response as Response3, Telemetry, Tokenizer as Tokenizer2, Tool as Tool4, Toolkit as Toolkit3 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/agent-event.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/agent-event.ts
 var exports_agent_event = {};
 __export(exports_agent_event, {
   addUsage: () => addUsage,
@@ -8388,7 +8388,7 @@ class AgentSuspended extends Schema38.TaggedErrorClass()("@batonfx/core/AgentSus
 }) {
 }
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/approvals.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/approvals.ts
 var exports_approvals = {};
 __export(exports_approvals, {
   testLayer: () => testLayer26,
@@ -8404,7 +8404,7 @@ var autoApprove = Layer29.succeed(Approvals, Approvals.of({ check: () => Effect3
 var denyAll = Layer29.succeed(Approvals, Approvals.of({ check: () => Effect31.succeed({ _tag: "Denied" }) }));
 var testLayer26 = (implementation) => Layer29.succeed(Approvals, Approvals.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/compaction.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/compaction.ts
 var exports_compaction = {};
 __export(exports_compaction, {
   truncate: () => truncate,
@@ -8422,7 +8422,7 @@ __export(exports_compaction, {
 import { Context as Context32, Effect as Effect34, Layer as Layer32, Option as Option10, Schema as Schema41 } from "effect";
 import { LanguageModel, Prompt as Prompt3, Tokenizer, Toolkit as Toolkit2 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/session.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/session.ts
 var exports_session = {};
 __export(exports_session, {
   testLayer: () => testLayer27,
@@ -8554,7 +8554,7 @@ var memoryLayer24 = Layer30.effect(SessionStore, Ref7.make(initialState).pipe(Ef
 }))));
 var testLayer27 = (implementation) => Layer30.succeed(SessionStore, SessionStore.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/tool-output.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/tool-output.ts
 var exports_tool_output = {};
 __export(exports_tool_output, {
   testLayer: () => testLayer28,
@@ -8614,7 +8614,7 @@ var bound = (result, options) => Effect33.gen(function* () {
   return { _tag: "Success", result: output, encodedResult: output };
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/compaction.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/compaction.ts
 var DEFAULT_RESERVE_TOKENS = 16384;
 var DEFAULT_KEEP_RECENT_TOKENS = 20000;
 var SUMMARY_TEMPLATE = `Summarize the conversation so another agent can continue seamlessly.
@@ -8797,7 +8797,7 @@ var truncate = (maxTokens) => ({
 var testLayer29 = (implementation) => Layer32.succeed(Compaction, Compaction.of(implementation));
 var isContextOverflow = (error) => /context|token|prompt/i.test(error instanceof Error ? `${error.name}: ${error.message}` : String(error)) && /overflow|exceed|exceeded|maximum|too large|too long|length/i.test(error instanceof Error ? `${error.name}: ${error.message}` : String(error));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/instructions.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/instructions.ts
 var exports_instructions = {};
 __export(exports_instructions, {
   testLayer: () => testLayer30,
@@ -8846,7 +8846,7 @@ var renderUpdate = (epoch, context) => Effect35.gen(function* () {
 var layer27 = (sources) => Layer33.succeed(Instructions, Instructions.of({ sources: [...sources] }));
 var testLayer30 = (implementation) => Layer33.succeed(Instructions, Instructions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/memory.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/memory.ts
 var exports_memory = {};
 __export(exports_memory, {
   testLayer: () => testLayer31,
@@ -8875,7 +8875,7 @@ var merge = (first, second) => ({
 var noopLayer = Layer34.succeed(Memory, Memory.of(noop));
 var testLayer31 = (implementation) => Layer34.succeed(Memory, Memory.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/model-middleware.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/model-middleware.ts
 var exports_model_middleware = {};
 __export(exports_model_middleware, {
   layer: () => layer28,
@@ -8889,7 +8889,7 @@ class ModelMiddleware extends Context35.Service()("@batonfx/core/ModelMiddleware
 var identityLayer = Layer35.succeed(ModelMiddleware, []);
 var layer28 = (middleware) => Layer35.succeed(ModelMiddleware, middleware);
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/model-resilience.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/model-resilience.ts
 var exports_model_resilience = {};
 __export(exports_model_resilience, {
   testLayer: () => testLayer32,
@@ -8935,7 +8935,7 @@ var apply = (model, resilience) => ({
   }).pipe(Stream5.retry(retryStreamSchedule(resilience)))
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/permissions.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/permissions.ts
 var exports_permissions = {};
 __export(exports_permissions, {
   testLayer: () => testLayer33,
@@ -9065,7 +9065,7 @@ var ruleStoreMemory = (initialRules = []) => Layer37.effect(RuleStore, Ref9.make
 var ruleStoreTestLayer = (implementation) => Layer37.succeed(RuleStore, RuleStore.of(implementation));
 var testLayer33 = (implementation) => Layer37.succeed(Permissions, Permissions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/skill-source.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/skill-source.ts
 var exports_skill_source = {};
 __export(exports_skill_source, {
   testLayer: () => testLayer34,
@@ -9123,37 +9123,64 @@ var selectListings = (skills, budgetTokens, recentlyUsed) => {
   return selected;
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/steering.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/steering.ts
 var exports_steering = {};
 __export(exports_steering, {
   testLayer: () => testLayer35,
   layer: () => layer30,
+  SteeringQueueFull: () => SteeringQueueFull,
   Steering: () => Steering
 });
-import { Context as Context39, Effect as Effect41, Exit, Layer as Layer39, Queue } from "effect";
+import { Context as Context39, Effect as Effect41, Exit, Layer as Layer39, Queue, Schema as Schema45 } from "effect";
 
 class Steering extends Context39.Service()("@batonfx/core/Steering") {
 }
+
+class SteeringQueueFull extends Schema45.TaggedErrorClass()("@batonfx/core/SteeringQueueFull", {
+  queue: Schema45.Literals(["steering", "followUp"]),
+  capacity: Schema45.Number
+}) {
+}
+var resolvePolicy = (policy, mode) => ({
+  mode: policy?.mode ?? mode,
+  ...policy?.capacity === undefined ? {} : { capacity: policy.capacity },
+  onFull: policy?.onFull ?? "fail"
+});
+var queueStrategy = (strategy) => {
+  switch (strategy) {
+    case "drop-oldest":
+      return "sliding";
+    case "drop-newest":
+    case "fail":
+      return "dropping";
+    case "suspend":
+      return "suspend";
+  }
+};
+var makeQueue = (name, policy) => (policy.capacity === undefined ? Queue.unbounded() : Queue.make({ capacity: policy.capacity, strategy: queueStrategy(policy.onFull) })).pipe(Effect41.map((queue) => ({ name, queue, policy })));
+var offer = (runtime, message) => Queue.offer(runtime.queue, message).pipe(Effect41.flatMap((offered) => {
+  if (offered || runtime.policy.capacity === undefined || runtime.policy.onFull !== "fail")
+    return Effect41.void;
+  return Effect41.fail(new SteeringQueueFull({ queue: runtime.name, capacity: runtime.policy.capacity }));
+}));
 var drainOne = (queue) => Effect41.sync(() => {
   const taken = Queue.takeUnsafe(queue);
   return taken === undefined || !Exit.isSuccess(taken) ? [] : [taken.value];
 });
 var drain = (queue, mode) => mode === "all" ? Queue.clear(queue) : drainOne(queue);
 var layer30 = (options = {}) => Layer39.effect(Steering, Effect41.gen(function* () {
-  const steeringQueue = yield* Queue.unbounded();
-  const followUpQueue = yield* Queue.unbounded();
-  const steeringMode = options.steeringMode ?? "all";
-  const followUpMode = options.followUpMode ?? "one-at-a-time";
+  const steeringQueue = yield* makeQueue("steering", resolvePolicy(options.steering, "all"));
+  const followUpQueue = yield* makeQueue("followUp", resolvePolicy(options.followUp, "one-at-a-time"));
   return Steering.of({
-    steer: (message) => Queue.offer(steeringQueue, message).pipe(Effect41.asVoid),
-    followUp: (message) => Queue.offer(followUpQueue, message).pipe(Effect41.asVoid),
-    takeSteering: () => drain(steeringQueue, steeringMode),
-    takeFollowUp: () => drain(followUpQueue, followUpMode)
+    steer: (message) => offer(steeringQueue, message),
+    followUp: (message) => offer(followUpQueue, message),
+    takeSteering: () => drain(steeringQueue.queue, steeringQueue.policy.mode),
+    takeFollowUp: () => drain(followUpQueue.queue, followUpQueue.policy.mode)
   });
 }));
 var testLayer35 = (implementation) => Layer39.succeed(Steering, Steering.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/tool-context.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/tool-context.ts
 var exports_tool_context = {};
 __export(exports_tool_context, {
   testLayer: () => testLayer36,
@@ -9171,18 +9198,22 @@ var layerDefault = Layer40.sync(ToolContext, () => ToolContext.of({
 }));
 var testLayer36 = (implementation) => Layer40.succeed(ToolContext, ToolContext.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/tool-executor.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/tool-executor.ts
 var exports_tool_executor = {};
 __export(exports_tool_executor, {
   testLayer: () => testLayer37,
+  sandbox: () => sandbox,
   router: () => router,
   routeToolkit: () => routeToolkit,
   route: () => route,
+  remote: () => remote,
+  mcp: () => mcp,
   fromToolkit: () => fromToolkit,
   executeToolkit: () => executeToolkit,
+  client: () => client,
   ToolExecutor: () => ToolExecutor
 });
-import { Cause as Cause2, Context as Context41, Effect as Effect43, Layer as Layer41, Option as Option14, Sink as Sink2, Stream as Stream6 } from "effect";
+import { Cause as Cause2, Context as Context41, Effect as Effect43, Layer as Layer41, Option as Option14, Schema as Schema46, Sink as Sink2, Stream as Stream6 } from "effect";
 class ToolExecutor extends Context41.Service()("@batonfx/core/ToolExecutor") {
 }
 var failureMessage = (cause) => {
@@ -9202,6 +9233,24 @@ var resultMessage = (result) => {
     return String(result);
   }
 };
+var schemaMessage = (error) => error instanceof Error ? error.message : typeof error === "string" ? error : resultMessage(error);
+var decodeSuccess = (tool2, result) => {
+  const successSchema = tool2.successSchema;
+  if (!Schema46.isSchema(successSchema)) {
+    return Effect43.succeed({ _tag: "Success", result, encodedResult: result });
+  }
+  return Schema46.decodeUnknownEffect(successSchema)(result).pipe(Effect43.flatMap((decoded) => Schema46.encodeUnknownEffect(successSchema)(decoded).pipe(Effect43.map((encoded) => ({ _tag: "Success", result: decoded, encodedResult: encoded })))), Effect43.catchCause((cause) => Effect43.succeed(failureOutcome(`invalid client result: ${schemaMessage(Cause2.squash(cause))}`))));
+};
+var placementOutcome = (placement, tool2, response) => {
+  switch (response._tag) {
+    case "Failure":
+      return Effect43.succeed(failureOutcome(response.message));
+    case "Suspend":
+      return Effect43.succeed({ _tag: "Suspend", token: response.token });
+    case "Success":
+      return decodeSuccess(tool2, response.result).pipe(Effect43.map((outcome) => outcome._tag === "Failure" ? failureOutcome(outcome.message.replace("invalid client result", `invalid ${placement} result`)) : outcome));
+  }
+};
 var executeWithToolkit = (toolkit, request) => {
   if (toolkit.tools[request.call.name] === undefined) {
     return Effect43.succeed(failureOutcome(`Tool ${request.call.name} is not registered`));
@@ -9239,6 +9288,24 @@ var route = (options) => {
     execute: options.execute
   };
 };
+var placementRoute = (placement, options) => {
+  const routedTools = options.tools ?? Object.keys(options.toolkit.tools);
+  return route({
+    tools: routedTools,
+    execute: (request) => {
+      const tool2 = options.toolkit.tools[request.call.name];
+      if (tool2 === undefined)
+        return Effect43.succeed(failureOutcome(`Tool ${request.call.name} is not registered`));
+      const effect = options.execute({ ...request, placement, tool: tool2 });
+      const scheduled = "schedule" in options && options.schedule !== undefined ? Effect43.retry(effect, options.schedule) : effect;
+      return scheduled.pipe(Effect43.flatMap((response) => placementOutcome(placement, tool2, response)), Effect43.catchCause((cause) => Cause2.hasInterrupts(cause) ? Effect43.interrupt : Effect43.succeed(failureOutcome(`${placement} tool infrastructure failed: ${failureMessage(cause)}`))));
+    }
+  });
+};
+var client = (options) => placementRoute("client", options);
+var remote = (options) => placementRoute("remote", options);
+var mcp = (options) => placementRoute("mcp", options);
+var sandbox = (options) => placementRoute("sandbox", options);
 function routeToolkit(toolkit) {
   const makeRoute = (handled) => route({
     tools: Object.keys(handled.tools),
@@ -9247,15 +9314,17 @@ function routeToolkit(toolkit) {
   return "handle" in toolkit ? makeRoute(toolkit) : toolkit.pipe(Effect43.map(makeRoute));
 }
 var routeInputEffect = (input) => Effect43.isEffect(input) ? input : Effect43.succeed(input);
-var router = (routes) => Layer41.effect(ToolExecutor, Effect43.all(Array.from(routes, routeInputEffect)).pipe(Effect43.map((resolved) => ToolExecutor.of({
-  execute: (request) => {
-    const matched = resolved.find((candidate) => candidate.matches(request));
-    return matched === undefined ? Effect43.succeed(failureOutcome(`Tool ${request.call.name} is not registered`)) : matched.execute(request);
-  }
-}))));
+function router(routes) {
+  return Layer41.effect(ToolExecutor, Effect43.all(Array.from(routes, routeInputEffect)).pipe(Effect43.map((resolved) => ToolExecutor.of({
+    execute: (request) => {
+      const matched = resolved.find((candidate) => candidate.matches(request));
+      return matched === undefined ? Effect43.succeed(failureOutcome(`Tool ${request.call.name} is not registered`)) : matched.execute(request);
+    }
+  }))));
+}
 var testLayer37 = (implementation) => Layer41.succeed(ToolExecutor, ToolExecutor.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/turn-policy.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/turn-policy.ts
 var exports_turn_policy = {};
 __export(exports_turn_policy, {
   untilToolCall: () => untilToolCall,
@@ -9294,7 +9363,7 @@ var both = (first, second) => make4((info) => Effect44.gen(function* () {
 }));
 var defaultPolicy = recurs(8);
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/agent.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/agent.ts
 function make5(nameOrOptions, options = {}) {
   const resolved = typeof nameOrOptions === "string" ? { ...options, name: nameOrOptions } : nameOrOptions;
   return {
@@ -9305,16 +9374,22 @@ function make5(nameOrOptions, options = {}) {
   };
 }
 var defaultObjectPrompt = "Return the final structured output for the task above.";
+var steeringDrainedEvent = (turn, queue, messages) => ({
+  _tag: "SteeringDrained",
+  turn,
+  queue,
+  count: messages.length
+});
 var skillListingBudgetTokens = 2048;
 var activateSkillToolName = "activate_skill";
-var activateSkillParameters = Schema45.Struct({ name: Schema45.String });
+var activateSkillParameters = Schema47.Struct({ name: Schema47.String });
 var activateSkillTool = Tool4.make(activateSkillToolName, {
   description: "Load the full body for one listed Baton skill by name before applying that skill.",
   parameters: activateSkillParameters,
-  success: Schema45.Struct({
-    name: Schema45.String,
-    body: Schema45.String,
-    allowedTools: Schema45.Array(Schema45.String)
+  success: Schema47.Struct({
+    name: Schema47.String,
+    body: Schema47.String,
+    allowedTools: Schema47.Array(Schema47.String)
   })
 });
 var errorMessage = (error) => error instanceof Error ? `${error.name}: ${error.message}` : String(error);
@@ -9617,7 +9692,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect45.gen
   const activateSkillOutcome = (turn, call) => Effect45.gen(function* () {
     if (skillRuntime === undefined)
       return { _tag: "Failure", message: "SkillSource is not available" };
-    const params = Schema45.decodeUnknownOption(activateSkillParameters)(call.params);
+    const params = Schema47.decodeUnknownOption(activateSkillParameters)(call.params);
     if (Option15.isNone(params))
       return { _tag: "Failure", message: "Skill activation requires a name" };
     const skill = yield* skillRuntime.source.get(params.value.name).pipe(Effect45.mapError((error) => skillError(turn, error)));
@@ -9856,7 +9931,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect45.gen
       const followUp = yield* takeFollowUp();
       if (followUp.length > 0) {
         return {
-          events: Stream7.fromIterable([completed]),
+          events: Stream7.fromIterable([completed, steeringDrainedEvent(turn, "followUp", followUp)]),
           next: { prompt: promptFromSteeringMessages(followUp) }
         };
       }
@@ -9892,7 +9967,7 @@ var streamInternal = (agent, options, structured) => Stream7.unwrap(Effect45.gen
     const basePrompt = steering.length === 0 ? toolPrompt : Prompt4.concat(promptFromSteeringMessages(steering), toolPrompt);
     const prompt = decision2.overrides?.instructions === undefined ? basePrompt : withSystem(decision2.overrides.instructions, basePrompt);
     return {
-      events: Stream7.fromIterable([completed]),
+      events: Stream7.fromIterable(steering.length === 0 ? [completed] : [completed, steeringDrainedEvent(turn, "steering", steering)]),
       next: { prompt, ...decision2.overrides === undefined ? {} : { overrides: decision2.overrides } }
     };
   });
@@ -9971,14 +10046,14 @@ var generateObject = (agent, options) => Stream7.runFold(streamObject(agent, opt
     })
   })
 })));
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/agent-tool.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/agent-tool.ts
 var exports_agent_tool = {};
 __export(exports_agent_tool, {
   asTool: () => asTool
 });
-import { Cause as Cause4, Effect as Effect46, Schema as Schema46 } from "effect";
+import { Cause as Cause4, Effect as Effect46, Schema as Schema48 } from "effect";
 import { Tool as Tool5, Toolkit as Toolkit4 } from "effect/unstable/ai";
-var defaultParameters = Schema46.Struct({ prompt: Schema46.String });
+var defaultParameters = Schema48.Struct({ prompt: Schema48.String });
 var errorMessage2 = (error) => {
   if (error instanceof AgentSuspended) {
     return `suspended on ${error.tool_name}: ${error.reason}`;
@@ -10004,14 +10079,14 @@ var lazyHandled = (toolkit, name, handler) => ({
 var asTool = (agent, options = {}) => {
   const name = options.name ?? agent.name;
   const parameters = options.parameters ?? defaultParameters;
-  const success2 = options.success ?? Schema46.String;
+  const success2 = options.success ?? Schema48.String;
   const toPrompt = options.toPrompt ?? ((params) => params.prompt);
   const fromResult = options.fromResult ?? ((result) => result.text);
   const tool2 = Tool5.make(name, {
     ...options.description === undefined ? {} : { description: options.description },
     parameters,
     success: success2,
-    failure: Schema46.String,
+    failure: Schema48.String,
     failureMode: "return"
   });
   const toolkit = Toolkit4.make(tool2);
@@ -10029,7 +10104,7 @@ var asTool = (agent, options = {}) => {
   });
   return lazyHandled(toolkit, name, handler);
 };
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/guardrail.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/guardrail.ts
 var exports_guardrail = {};
 __export(exports_guardrail, {
   validateInput: () => validateInput2,
@@ -10109,16 +10184,16 @@ var redactOutput = (options) => ({
 var filterOutput = (keep) => ({
   transformPart: (part, context) => Effect47.succeed(part.type === "tool-call" || keep(part, context) ? Option16.some(part) : Option16.none())
 });
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/handoff.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/handoff.ts
 var exports_handoff = {};
 __export(exports_handoff, {
   transferTool: () => transferTool,
   supervisor: () => supervisor,
   fanOut: () => fanOut
 });
-import { Effect as Effect48, Schema as Schema47 } from "effect";
+import { Effect as Effect48, Schema as Schema49 } from "effect";
 import { AiError as AiError2, Toolkit as Toolkit5 } from "effect/unstable/ai";
-var defaultTransferParameters = Schema47.Struct({ prompt: Schema47.String });
+var defaultTransferParameters = Schema49.Struct({ prompt: Schema49.String });
 var transferName = (agentName) => `transfer_to_${agentName}`;
 var positiveConcurrency = (value) => {
   const concurrency = value ?? 4;
@@ -10172,7 +10247,7 @@ var supervisor = (options) => {
     toolkit
   };
 };
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/model-registry.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/model-registry.ts
 var exports_model_registry = {};
 __export(exports_model_registry, {
   testLayer: () => testLayer38,
@@ -10187,13 +10262,13 @@ __export(exports_model_registry, {
   Service: () => Service29,
   LanguageModelNotRegistered: () => LanguageModelNotRegistered
 });
-import { Chunk as Chunk2, Context as Context42, Effect as Effect49, Layer as Layer43, Option as Option17, Ref as Ref11, Schema as Schema48, Semaphore as Semaphore3 } from "effect";
+import { Chunk as Chunk2, Context as Context42, Effect as Effect49, Layer as Layer43, Option as Option17, Ref as Ref11, Schema as Schema50, Semaphore as Semaphore3 } from "effect";
 import { Model } from "effect/unstable/ai";
 
-class LanguageModelNotRegistered extends Schema48.TaggedErrorClass()("LanguageModelNotRegistered", {
-  provider: Schema48.String,
-  model: Schema48.String,
-  registration_key: Schema48.optionalKey(Schema48.String)
+class LanguageModelNotRegistered extends Schema50.TaggedErrorClass()("LanguageModelNotRegistered", {
+  provider: Schema50.String,
+  model: Schema50.String,
+  registration_key: Schema50.optionalKey(Schema50.String)
 }) {
 }
 
@@ -10261,7 +10336,7 @@ var provide = (selection, effect) => Effect49.gen(function* () {
   return yield* service.provide(selection, effect);
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.3.0/node_modules/@batonfx/core/src/index.ts
+// ../../node_modules/.bun/@batonfx+core@0.3.2/node_modules/@batonfx/core/src/index.ts
 import {
   AiError as AiError3,
   Chat as Chat2,
@@ -10279,7 +10354,7 @@ import {
 } from "effect/unstable/ai";
 
 // ../runtime/src/agent/agent-loop-service.ts
-import { Config as Config3, Context as Context54, Crypto as Crypto3, Effect as Effect67, HashSet as HashSet6, Layer as Layer60, Option as Option22, Ref as Ref18, Schema as Schema61, Stream as Stream8 } from "effect";
+import { Config as Config3, Context as Context54, Crypto as Crypto3, Effect as Effect67, HashSet as HashSet6, Layer as Layer60, Option as Option22, Ref as Ref18, Schema as Schema63, Stream as Stream8 } from "effect";
 import { Chat as Chat3, LanguageModel as LanguageModel6, Prompt as Prompt12, Tokenizer as Tokenizer4, Toolkit as Toolkit7 } from "effect/unstable/ai";
 
 // ../runtime/src/child/child-run-service.ts
@@ -10299,31 +10374,31 @@ __export(exports_child_run_service, {
   ChildRunScopeBroadened: () => ChildRunScopeBroadened,
   ChildRunModelMissing: () => ChildRunModelMissing
 });
-import { Context as Context44, Effect as Effect51, HashSet as HashSet5, Layer as Layer45, Option as Option18, Result as Result2, Schema as Schema50 } from "effect";
+import { Context as Context44, Effect as Effect51, HashSet as HashSet5, Layer as Layer45, Option as Option18, Result as Result2, Schema as Schema52 } from "effect";
 
 // ../runtime/src/workspace/workspace-provider-service.ts
-import { Context as Context43, Effect as Effect50, Layer as Layer44, Ref as Ref12, Schema as Schema49 } from "effect";
+import { Context as Context43, Effect as Effect50, Layer as Layer44, Ref as Ref12, Schema as Schema51 } from "effect";
 
-class WorkspaceNotFound extends Schema49.TaggedErrorClass()("WorkspaceNotFound", {
+class WorkspaceNotFound extends Schema51.TaggedErrorClass()("WorkspaceNotFound", {
   sandbox_ref: exports_ids_schema.WorkspaceRef
 }) {
 }
 
-class WorkspaceUnavailable extends Schema49.TaggedErrorClass()("WorkspaceUnavailable", {
+class WorkspaceUnavailable extends Schema51.TaggedErrorClass()("WorkspaceUnavailable", {
   sandbox_ref: exports_ids_schema.WorkspaceRef,
-  message: Schema49.String
+  message: Schema51.String
 }) {
 }
 
-class WorkspaceCapabilityUnsupported extends Schema49.TaggedErrorClass()("WorkspaceCapabilityUnsupported", {
-  capability: Schema49.Literals(["suspend", "snapshot", "fork"]),
+class WorkspaceCapabilityUnsupported extends Schema51.TaggedErrorClass()("WorkspaceCapabilityUnsupported", {
+  capability: Schema51.Literals(["suspend", "snapshot", "fork"]),
   provider_key: exports_workspace_schema.WorkspaceProviderKey
 }) {
 }
 
-class WorkspaceProviderError extends Schema49.TaggedErrorClass()("WorkspaceProviderError", {
+class WorkspaceProviderError extends Schema51.TaggedErrorClass()("WorkspaceProviderError", {
   provider_key: exports_workspace_schema.WorkspaceProviderKey,
-  message: Schema49.String
+  message: Schema51.String
 }) {
 }
 
@@ -10355,28 +10430,28 @@ var destroy = Effect50.fn("WorkspaceProvider.destroy.call")(function* (ref) {
 });
 
 // ../runtime/src/child/child-run-service.ts
-class StaticChildRunPresetNotFound extends Schema50.TaggedErrorClass()("StaticChildRunPresetNotFound", {
+class StaticChildRunPresetNotFound extends Schema52.TaggedErrorClass()("StaticChildRunPresetNotFound", {
   preset_name: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ChildRunScopeBroadened extends Schema50.TaggedErrorClass()("ChildRunScopeBroadened", {
-  field: Schema50.Literals(["tool_names", "permissions"]),
+class ChildRunScopeBroadened extends Schema52.TaggedErrorClass()("ChildRunScopeBroadened", {
+  field: Schema52.Literals(["tool_names", "permissions"]),
   value: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ChildRunServiceError extends Schema50.TaggedErrorClass()("ChildRunServiceError", {
-  message: Schema50.String
+class ChildRunServiceError extends Schema52.TaggedErrorClass()("ChildRunServiceError", {
+  message: Schema52.String
 }) {
 }
 
-class ChildRunWorkspaceUnavailable extends Schema50.TaggedErrorClass()("ChildRunWorkspaceUnavailable", {
-  reason: Schema50.String
+class ChildRunWorkspaceUnavailable extends Schema52.TaggedErrorClass()("ChildRunWorkspaceUnavailable", {
+  reason: Schema52.String
 }) {
 }
 
-class ChildRunModelMissing extends Schema50.TaggedErrorClass()("ChildRunModelMissing", {}) {
+class ChildRunModelMissing extends Schema52.TaggedErrorClass()("ChildRunModelMissing", {}) {
 }
 
 class Service31 extends Context44.Service()("@relayfx/runtime/ChildRunService") {
@@ -10604,26 +10679,26 @@ var spawnDynamic = Effect51.fn("ChildRunService.spawnDynamic.call")(function* (i
 });
 
 // ../runtime/src/child/spawn-child-run-tool.ts
-import { Effect as Effect52, Schema as Schema51 } from "effect";
+import { Effect as Effect52, Schema as Schema53 } from "effect";
 var toolName = "spawn_child_run";
 var permissionName = "relay.child_run.spawn";
-var Input = Schema51.Struct({
-  preset_name: Schema51.optionalKey(exports_shared_schema.NonEmptyString),
-  instructions: Schema51.optionalKey(Schema51.String),
-  model: Schema51.optionalKey(exports_agent_schema.ModelSelection),
-  tool_names: Schema51.optionalKey(Schema51.Array(Schema51.String)),
-  permissions: Schema51.optionalKey(Schema51.Array(Schema51.String)),
-  output_schema_ref: Schema51.optionalKey(Schema51.String),
-  metadata: Schema51.optionalKey(exports_shared_schema.Metadata),
-  input: Schema51.optionalKey(Schema51.Array(exports_content_schema.Part))
+var Input = Schema53.Struct({
+  preset_name: Schema53.optionalKey(exports_shared_schema.NonEmptyString),
+  instructions: Schema53.optionalKey(Schema53.String),
+  model: Schema53.optionalKey(exports_agent_schema.ModelSelection),
+  tool_names: Schema53.optionalKey(Schema53.Array(Schema53.String)),
+  permissions: Schema53.optionalKey(Schema53.Array(Schema53.String)),
+  output_schema_ref: Schema53.optionalKey(Schema53.String),
+  metadata: Schema53.optionalKey(exports_shared_schema.Metadata),
+  input: Schema53.optionalKey(Schema53.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Input" });
-var Output = Schema51.Struct({
+var Output = Schema53.Struct({
   child_execution_id: exports_ids_schema.ChildExecutionId,
-  status: Schema51.Literals(["completed", "failed", "cancelled"]),
-  output: Schema51.Array(exports_content_schema.Part)
+  status: Schema53.Literals(["completed", "failed", "cancelled"]),
+  output: Schema53.Array(exports_content_schema.Part)
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Output" });
-var TransferInput = Schema51.Struct({
-  input: Schema51.optionalKey(Schema51.Array(exports_content_schema.Part))
+var TransferInput = Schema53.Struct({
+  input: Schema53.optionalKey(Schema53.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.TransferInput" });
 var enabled = (agent) => agent.metadata?.multi_agent_enabled === true;
 var parentContext = (agent) => ({
@@ -10810,17 +10885,17 @@ var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target
 });
 
 // ../runtime/src/memory/memory-service.ts
-import { Clock as Clock3, Context as Context46, Effect as Effect54, Layer as Layer47, Schema as Schema53 } from "effect";
+import { Clock as Clock3, Context as Context46, Effect as Effect54, Layer as Layer47, Schema as Schema55 } from "effect";
 import { EmbeddingModel as EmbeddingModel3, Prompt as Prompt9 } from "effect/unstable/ai";
 
 // ../runtime/src/model/embedding-model-service.ts
-import { Context as Context45, Effect as Effect53, Layer as Layer46, Ref as Ref13, Schema as Schema52 } from "effect";
+import { Context as Context45, Effect as Effect53, Layer as Layer46, Ref as Ref13, Schema as Schema54 } from "effect";
 import { EmbeddingModel as EmbeddingModel2, Model as Model3 } from "effect/unstable/ai";
 
-class EmbeddingModelNotRegistered extends Schema52.TaggedErrorClass()("EmbeddingModelNotRegistered", {
-  provider: Schema52.String,
-  model: Schema52.String,
-  registration_key: Schema52.optionalKey(Schema52.String)
+class EmbeddingModelNotRegistered extends Schema54.TaggedErrorClass()("EmbeddingModelNotRegistered", {
+  provider: Schema54.String,
+  model: Schema54.String,
+  registration_key: Schema54.optionalKey(Schema54.String)
 }) {
 }
 
@@ -10946,7 +11021,7 @@ var defaultTopK = 5;
 var memoryError = (error) => new exports_memory.MemoryError({
   message: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
 });
-var decodeSubject = (subject) => Schema53.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect54.mapError(memoryError));
+var decodeSubject = (subject) => Schema55.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect54.mapError(memoryError));
 var textPart = (text3) => Prompt9.makePart("text", { text: text3 });
 var textFromParts = (parts) => parts.filter((part) => part.type === "text").map((part) => part.text).join(`
 `).trim();
@@ -11140,20 +11215,20 @@ __export(exports_model_call_policy, {
   defaultClassify: () => defaultClassify2,
   Service: () => Service35
 });
-import { Context as Context48, Duration as Duration3, Layer as Layer49, Schedule as Schedule3 } from "effect";
+import { Context as Context48, Duration as Duration3, Layer as Layer49, Schedule as Schedule4 } from "effect";
 import { AiError as AiError4 } from "effect/unstable/ai";
 
 class Service35 extends Context48.Service()("@relayfx/runtime/ModelCallPolicy") {
 }
 var isOutputValidationError = (error) => AiError4.isAiError(error) ? error.reason._tag === "InvalidOutputError" : AiError4.isAiErrorReason(error) && error._tag === "InvalidOutputError";
 var defaultClassify2 = (error) => isOutputValidationError(error) ? "terminal" : exports_model_resilience.defaultClassify(error);
-var defaultSchedule = Schedule3.exponential(Duration3.seconds(1)).pipe(Schedule3.jittered, Schedule3.both(Schedule3.recurs(4)));
+var defaultSchedule = Schedule4.exponential(Duration3.seconds(1)).pipe(Schedule4.jittered, Schedule4.both(Schedule4.recurs(4)));
 var make7 = (input) => ({
   classify: input?.classify ?? defaultClassify2,
   retrySchedule: input?.retrySchedule ?? defaultSchedule
 });
 var layer36 = (input) => Layer49.succeed(Service35, Service35.of(make7(input)));
-var noRetryLayer = layer36({ retrySchedule: Schedule3.recurs(0) });
+var noRetryLayer = layer36({ retrySchedule: Schedule4.recurs(0) });
 var testLayer41 = (implementation) => Layer49.succeed(Service35, Service35.of(implementation));
 
 // ../runtime/src/schema-registry/schema-registry-service.ts
@@ -11168,9 +11243,9 @@ __export(exports_schema_registry_service, {
   Service: () => Service36,
   SchemaRefNotRegistered: () => SchemaRefNotRegistered
 });
-import { Context as Context49, Effect as Effect56, Layer as Layer50, Ref as Ref14, Schema as Schema54 } from "effect";
+import { Context as Context49, Effect as Effect56, Layer as Layer50, Ref as Ref14, Schema as Schema56 } from "effect";
 
-class SchemaRefNotRegistered extends Schema54.TaggedErrorClass()("SchemaRefNotRegistered", { schema_ref: exports_shared_schema.NonEmptyString }) {
+class SchemaRefNotRegistered extends Schema56.TaggedErrorClass()("SchemaRefNotRegistered", { schema_ref: exports_shared_schema.NonEmptyString }) {
 }
 
 class Service36 extends Context49.Service()("@relayfx/runtime/SchemaRegistry") {
@@ -11303,16 +11378,16 @@ __export(exports_blob_store_service, {
   BlobStoreError: () => BlobStoreError,
   BlobNotResolvable: () => BlobNotResolvable
 });
-import { Context as Context51, Effect as Effect58, Layer as Layer52, Ref as Ref16, Schema as Schema55 } from "effect";
+import { Context as Context51, Effect as Effect58, Layer as Layer52, Ref as Ref16, Schema as Schema57 } from "effect";
 
-class BlobNotResolvable extends Schema55.TaggedErrorClass()("BlobNotResolvable", {
-  uri: Schema55.String,
-  reason: Schema55.String
+class BlobNotResolvable extends Schema57.TaggedErrorClass()("BlobNotResolvable", {
+  uri: Schema57.String,
+  reason: Schema57.String
 }) {
 }
 
-class BlobStoreError extends Schema55.TaggedErrorClass()("BlobStoreError", {
-  message: Schema55.String
+class BlobStoreError extends Schema57.TaggedErrorClass()("BlobStoreError", {
+  message: Schema57.String
 }) {
 }
 
@@ -11385,7 +11460,7 @@ __export(exports_prompt_assembler_service, {
   Service: () => Service40,
   PromptAssemblerError: () => PromptAssemblerError
 });
-import { Context as Context53, Effect as Effect60, Layer as Layer54, Schema as Schema57 } from "effect";
+import { Context as Context53, Effect as Effect60, Layer as Layer54, Schema as Schema59 } from "effect";
 import { Prompt as Prompt10 } from "effect/unstable/ai";
 
 // ../runtime/src/content/artifact-store-service.ts
@@ -11400,11 +11475,11 @@ __export(exports_artifact_store_service, {
   Memory: () => Memory2,
   ArtifactNotResolvable: () => ArtifactNotResolvable
 });
-import { Context as Context52, Effect as Effect59, Layer as Layer53, Schema as Schema56 } from "effect";
+import { Context as Context52, Effect as Effect59, Layer as Layer53, Schema as Schema58 } from "effect";
 
-class ArtifactNotResolvable extends Schema56.TaggedErrorClass()("ArtifactNotResolvable", {
-  artifact_id: Schema56.String,
-  reason: Schema56.String
+class ArtifactNotResolvable extends Schema58.TaggedErrorClass()("ArtifactNotResolvable", {
+  artifact_id: Schema58.String,
+  reason: Schema58.String
 }) {
 }
 
@@ -11446,14 +11521,14 @@ var register8 = Effect59.fn("ArtifactStore.register.call")(function* (artifact_i
 });
 
 // ../runtime/src/agent/prompt-assembler-service.ts
-class PromptAssemblerError extends Schema57.TaggedErrorClass()("PromptAssemblerError", {
-  message: Schema57.String
+class PromptAssemblerError extends Schema59.TaggedErrorClass()("PromptAssemblerError", {
+  message: Schema59.String
 }) {
 }
 
 class Service40 extends Context53.Service()("@relayfx/runtime/PromptAssembler") {
 }
-var jsonValue2 = (value) => Schema57.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue2 = (value) => Schema59.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var stringifyJson = (value) => JSON.stringify(jsonValue2(value));
 var contentToPromptPart = (part) => {
   const options = part.provider_options;
@@ -11597,8 +11672,8 @@ var make9 = (config) => exports_compaction.make(strategy(config), defaultOptions
 var layerFromEpoch = (epoch) => exports_instructions.layer(epoch.baseline.length === 0 ? [] : [exports_instructions.staticSource("relay:context-epoch", epoch.baseline)]);
 
 // ../runtime/src/agent/relay-permissions.ts
-import { Clock as Clock6, Effect as Effect62, Equal as Equal2, Layer as Layer56, Option as Option19, Schema as Schema58 } from "effect";
-var jsonValue3 = (value) => Schema58.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
+import { Clock as Clock6, Effect as Effect62, Equal as Equal2, Layer as Layer56, Option as Option19, Schema as Schema60 } from "effect";
+var jsonValue3 = (value) => Schema60.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
 var waitIdForToolCall = (toolCallId) => exports_ids_schema.WaitId.make(`wait:permission:${toolCallId}`);
 var fallbackToolCallId = (request) => `${request.agentName}:${request.turn}:${request.tool}`;
 var tokenFor2 = (request) => waitIdForToolCall(request.toolCallId ?? fallbackToolCallId(request));
@@ -11764,7 +11839,7 @@ var awaitAnswer = Effect62.fn("RelayPermissions.awaitAnswer")(function* (config,
 });
 var rememberRule = Effect62.fn("RelayPermissions.rememberRule")(function* (config, rule) {
   const createdAt = yield* Clock6.currentTimeMillis;
-  const decodedRule = yield* Schema58.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect62.mapError((error) => permissionError(error.message)));
+  const decodedRule = yield* Schema60.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect62.mapError((error) => permissionError(error.message)));
   yield* config.repository.remember({
     agent: config.agentName,
     scope: config.scope,
@@ -11780,9 +11855,9 @@ var layer40 = (config) => Layer56.mergeAll(Layer56.succeed(exports_permissions.P
 })));
 
 // ../runtime/src/agent/relay-steering.ts
-import { Clock as Clock7, Effect as Effect63, Layer as Layer57, Schema as Schema59 } from "effect";
+import { Clock as Clock7, Effect as Effect63, Layer as Layer57, Schema as Schema61 } from "effect";
 import { Prompt as Prompt11 } from "effect/unstable/ai";
-var jsonValue4 = (value) => Schema59.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue4 = (value) => Schema61.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var stringifyJson2 = (value) => JSON.stringify(jsonValue4(value));
 var createdAtForSequence2 = (config, sequence) => config.startedAt + sequence - config.eventSequence;
 var drainId = (config, kind, sequence) => `drain:${config.executionId}:steering:${kind}:sequence:${sequence}`;
@@ -11815,7 +11890,7 @@ var contentFromMessage = (message) => {
   const textParts = promptTextParts(prompt);
   if (textParts.length > 0)
     return textParts;
-  return [exports_content_schema.text(stringifyJson2(Schema59.encodeSync(Prompt11.Prompt)(prompt)))];
+  return [exports_content_schema.text(stringifyJson2(Schema61.encodeSync(Prompt11.Prompt)(prompt)))];
 };
 var steeringReceivedEvent = (config, kind, drain2, messages, sequence) => ({
   id: exports_ids_schema.EventId.make(`event:${drain2.drainId}:received`),
@@ -11860,8 +11935,8 @@ var layer41 = (config) => Layer57.succeed(exports_steering.Steering, exports_ste
 }));
 
 // ../runtime/src/agent/relay-tool-executor.ts
-import { Effect as Effect64, Layer as Layer58, Option as Option20, Schema as Schema60 } from "effect";
-var jsonValue5 = (value) => Schema60.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+import { Effect as Effect64, Layer as Layer58, Option as Option20, Schema as Schema62 } from "effect";
+var jsonValue5 = (value) => Schema62.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var errorDetail = (error) => {
   switch (error._tag) {
     case "ToolNotRegistered":
@@ -11968,29 +12043,29 @@ var make12 = (first) => Ref17.make(first).pipe(Effect66.map((ref) => ({
 })));
 
 // ../runtime/src/agent/agent-loop-service.ts
-class AgentLoopError extends Schema61.TaggedErrorClass()("AgentLoopError", {
-  message: Schema61.String,
-  next_event_sequence: Schema61.optionalKey(exports_execution_schema.ExecutionEventSequence)
+class AgentLoopError extends Schema63.TaggedErrorClass()("AgentLoopError", {
+  message: Schema63.String,
+  next_event_sequence: Schema63.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
-class AgentLoopWaitRequested extends Schema61.TaggedErrorClass()("AgentLoopWaitRequested", {
+class AgentLoopWaitRequested extends Schema63.TaggedErrorClass()("AgentLoopWaitRequested", {
   wait_id: exports_ids_schema.WaitId,
   tool_call: exports_tool_schema.Call,
   next_event_sequence: exports_execution_schema.ExecutionEventSequence
 }) {
 }
 
-class AgentLoopBudgetExceeded extends Schema61.TaggedErrorClass()("AgentLoopBudgetExceeded", {
-  tokens_used: Schema61.Int,
-  token_budget: Schema61.Int,
+class AgentLoopBudgetExceeded extends Schema63.TaggedErrorClass()("AgentLoopBudgetExceeded", {
+  tokens_used: Schema63.Int,
+  token_budget: Schema63.Int,
   next_event_sequence: exports_execution_schema.ExecutionEventSequence
 }) {
 }
 
 class Service41 extends Context54.Service()("@relayfx/runtime/AgentLoop") {
 }
-var jsonValue6 = (value) => Schema61.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue6 = (value) => Schema63.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var toolNames = (agent) => HashSet6.fromIterable(agent.tool_names);
 var availableRegisteredTools = (agent, registered) => {
   const names = toolNames(agent);
@@ -12559,14 +12634,14 @@ var exports_execution_entity = {};
 __export(exports_execution_entity, {
   layer: () => layer49,
   entity: () => entity,
-  client: () => client,
+  client: () => client2,
   Start: () => Start,
   SignalWait: () => SignalWait,
   Cancel: () => Cancel
 });
 import { ClusterSchema, Entity } from "effect/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
-import { Schema as Schema68 } from "effect";
+import { Schema as Schema70 } from "effect";
 
 // ../runtime/src/workflow/execution-workflow.ts
 var exports_execution_workflow = {};
@@ -12597,15 +12672,15 @@ __export(exports_execution_workflow, {
   ActivityNameTemplates: () => ActivityNameTemplates
 });
 import { Activity, DurableDeferred, Workflow } from "effect/unstable/workflow";
-import { Effect as Effect73, Exit as Exit2, Option as Option26, Schema as Schema67 } from "effect";
+import { Effect as Effect73, Exit as Exit2, Option as Option26, Schema as Schema69 } from "effect";
 
 // ../runtime/src/child/parent-notifier-service.ts
-import { Context as Context55, Effect as Effect68, Layer as Layer61, Option as Option23, Ref as Ref19, Schema as Schema62 } from "effect";
-class ParentNotifyError extends Schema62.TaggedErrorClass()("ParentNotifyError", {
-  message: Schema62.String
+import { Context as Context55, Effect as Effect68, Layer as Layer61, Option as Option23, Ref as Ref19, Schema as Schema64 } from "effect";
+class ParentNotifyError extends Schema64.TaggedErrorClass()("ParentNotifyError", {
+  message: Schema64.String
 }) {
 }
-var ChildTerminalStatus = Schema62.Literals(["completed", "failed", "cancelled"]).annotate({
+var ChildTerminalStatus = Schema64.Literals(["completed", "failed", "cancelled"]).annotate({
   identifier: "Relay.ParentNotifier.ChildTerminalStatus"
 });
 
@@ -12704,15 +12779,15 @@ __export(exports_skill_registry_service, {
   SkillDefinitionInvalid: () => SkillDefinitionInvalid,
   Service: () => Service43
 });
-import { Clock as Clock8, Context as Context56, Effect as Effect69, Layer as Layer62, Schema as Schema63 } from "effect";
+import { Clock as Clock8, Context as Context56, Effect as Effect69, Layer as Layer62, Schema as Schema65 } from "effect";
 
-class SkillDefinitionInvalid extends Schema63.TaggedErrorClass()("SkillDefinitionInvalid", {
-  message: Schema63.String
+class SkillDefinitionInvalid extends Schema65.TaggedErrorClass()("SkillDefinitionInvalid", {
+  message: Schema65.String
 }) {
 }
 
-class SkillRegistryError extends Schema63.TaggedErrorClass()("SkillRegistryError", {
-  message: Schema63.String
+class SkillRegistryError extends Schema65.TaggedErrorClass()("SkillRegistryError", {
+  message: Schema65.String
 }) {
 }
 
@@ -12881,11 +12956,11 @@ __export(exports_execution_service, {
   Service: () => Service44,
   ExecutionServiceError: () => ExecutionServiceError
 });
-import { Clock as Clock9, Context as Context57, Effect as Effect70, Layer as Layer63, Option as Option24, Schema as Schema64, Stream as Stream9 } from "effect";
+import { Clock as Clock9, Context as Context57, Effect as Effect70, Layer as Layer63, Option as Option24, Schema as Schema66, Stream as Stream9 } from "effect";
 import { ShardingConfig } from "effect/unstable/cluster";
-class ExecutionServiceError extends Schema64.TaggedErrorClass()("ExecutionServiceError", {
-  message: Schema64.String,
-  next_event_sequence: Schema64.optionalKey(exports_execution_schema.ExecutionEventSequence)
+class ExecutionServiceError extends Schema66.TaggedErrorClass()("ExecutionServiceError", {
+  message: Schema66.String,
+  next_event_sequence: Schema66.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
@@ -13201,13 +13276,13 @@ var spawnChildRun = Effect70.fn("ExecutionService.spawnChildRun.call")(function*
 var stream3 = (input) => Stream9.unwrap(Service44.pipe(Effect70.map((service) => service.stream(input))));
 
 // ../runtime/src/workspace/workspace-planner-service.ts
-import { Context as Context59, Effect as Effect72, HashSet as HashSet7, Layer as Layer65, Option as Option25, Schema as Schema66 } from "effect";
+import { Context as Context59, Effect as Effect72, HashSet as HashSet7, Layer as Layer65, Option as Option25, Schema as Schema68 } from "effect";
 
 // ../runtime/src/workspace/workspace-runtime-service.ts
-import { Context as Context58, Effect as Effect71, Layer as Layer64, Schema as Schema65 } from "effect";
+import { Context as Context58, Effect as Effect71, Layer as Layer64, Schema as Schema67 } from "effect";
 
-class WorkspaceRuntimeError extends Schema65.TaggedErrorClass()("WorkspaceRuntimeError", {
-  message: Schema65.String
+class WorkspaceRuntimeError extends Schema67.TaggedErrorClass()("WorkspaceRuntimeError", {
+  message: Schema67.String
 }) {
 }
 
@@ -13235,18 +13310,18 @@ var exec = Effect71.fn("WorkspaceRuntime.exec.call")(function* (input) {
 });
 
 // ../runtime/src/workspace/workspace-planner-service.ts
-class WorkspaceRuntimeMissing extends Schema66.TaggedErrorClass()("WorkspaceRuntimeMissing", {
+class WorkspaceRuntimeMissing extends Schema68.TaggedErrorClass()("WorkspaceRuntimeMissing", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspaceLeaseMissingRef extends Schema66.TaggedErrorClass()("WorkspaceLeaseMissingRef", {
+class WorkspaceLeaseMissingRef extends Schema68.TaggedErrorClass()("WorkspaceLeaseMissingRef", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspacePlannerError extends Schema66.TaggedErrorClass()("WorkspacePlannerError", {
-  message: Schema66.String
+class WorkspacePlannerError extends Schema68.TaggedErrorClass()("WorkspacePlannerError", {
+  message: Schema68.String
 }) {
 }
 
@@ -13432,67 +13507,67 @@ var fail = Effect72.fn("WorkspacePlanner.fail.call")(function* (input) {
 });
 
 // ../runtime/src/workflow/execution-workflow.ts
-class ExecutionWorkflowFailed extends Schema67.TaggedErrorClass()("ExecutionWorkflowFailed", {
-  message: Schema67.String
+class ExecutionWorkflowFailed extends Schema69.TaggedErrorClass()("ExecutionWorkflowFailed", {
+  message: Schema69.String
 }) {
 }
-var StartInput = Schema67.Struct({
+var StartInput = Schema69.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   root_address_id: exports_ids_schema.AddressId,
-  session_id: Schema67.optionalKey(exports_ids_schema.SessionId),
-  input: Schema67.optionalKey(Schema67.Array(exports_content_schema.Part)),
+  session_id: Schema69.optionalKey(exports_ids_schema.SessionId),
+  input: Schema69.optionalKey(Schema69.Array(exports_content_schema.Part)),
   event_sequence: exports_execution_schema.ExecutionEventSequence,
   started_at: exports_shared_schema.TimestampMillis,
   completed_at: exports_shared_schema.TimestampMillis,
-  agent_id: Schema67.optionalKey(exports_ids_schema.AgentId),
-  agent_revision: Schema67.optionalKey(exports_agent_schema.DefinitionRevision),
-  agent_snapshot: Schema67.optionalKey(exports_agent_schema.Definition),
-  agent_tool_input_schema_digests: Schema67.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
-  wait_id: Schema67.optionalKey(exports_ids_schema.WaitId),
-  resume_tool_call: Schema67.optionalKey(exports_tool_schema.Call),
-  workflow_generation: Schema67.optionalKey(Schema67.Int.check(Schema67.isGreaterThanOrEqualTo(0))),
-  metadata: Schema67.optionalKey(exports_shared_schema.Metadata)
+  agent_id: Schema69.optionalKey(exports_ids_schema.AgentId),
+  agent_revision: Schema69.optionalKey(exports_agent_schema.DefinitionRevision),
+  agent_snapshot: Schema69.optionalKey(exports_agent_schema.Definition),
+  agent_tool_input_schema_digests: Schema69.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
+  wait_id: Schema69.optionalKey(exports_ids_schema.WaitId),
+  resume_tool_call: Schema69.optionalKey(exports_tool_schema.Call),
+  workflow_generation: Schema69.optionalKey(Schema69.Int.check(Schema69.isGreaterThanOrEqualTo(0))),
+  metadata: Schema69.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartInput" });
-var WaitSignalState = Schema67.Literals(["resolved", "timed_out", "cancelled"]).annotate({
+var WaitSignalState = Schema69.Literals(["resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.ExecutionWorkflow.WaitSignalState"
 });
-var WaitSignal = Schema67.Struct({
+var WaitSignal = Schema69.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitSignalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionWorkflow.WaitSignal" });
-var SignalWaitInput = Schema67.Struct({
-  workflow_execution_id: Schema67.String,
+var SignalWaitInput = Schema69.Struct({
+  workflow_execution_id: Schema69.String,
   wait_id: exports_ids_schema.WaitId,
   state: WaitSignalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionWorkflow.SignalWaitInput" });
-var CancelExecutionInput = Schema67.Struct({
+var CancelExecutionInput = Schema69.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   cancelled_at: exports_shared_schema.TimestampMillis,
-  reason: Schema67.optionalKey(Schema67.String)
+  reason: Schema69.optionalKey(Schema69.String)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.CancelExecutionInput" });
-var CancelExecutionResult = Schema67.Struct({
+var CancelExecutionResult = Schema69.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus
 }).annotate({ identifier: "Relay.ExecutionWorkflow.CancelExecutionResult" });
-var WaitSnapshot = Schema67.Struct({
+var WaitSnapshot = Schema69.Struct({
   id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
-  envelope_id: Schema67.optionalKey(exports_ids_schema.EnvelopeId),
+  envelope_id: Schema69.optionalKey(exports_ids_schema.EnvelopeId),
   mode: exports_envelope_schema.WaitMode,
-  correlation_key: Schema67.optionalKey(Schema67.String),
-  state: Schema67.Literals(["open", "resolved", "timed_out", "cancelled"]),
+  correlation_key: Schema69.optionalKey(Schema69.String),
+  state: Schema69.Literals(["open", "resolved", "timed_out", "cancelled"]),
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
-  resolved_at: Schema67.optionalKey(exports_shared_schema.TimestampMillis)
+  resolved_at: Schema69.optionalKey(exports_shared_schema.TimestampMillis)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.WaitSnapshot" });
-var StartResult = Schema67.Struct({
+var StartResult = Schema69.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus,
-  wait_id: Schema67.optionalKey(exports_ids_schema.WaitId),
-  wait_state: Schema67.optionalKey(Schema67.Literals(["resolved", "timed_out", "cancelled"])),
-  metadata: Schema67.optionalKey(exports_shared_schema.Metadata)
+  wait_id: Schema69.optionalKey(exports_ids_schema.WaitId),
+  wait_state: Schema69.optionalKey(Schema69.Literals(["resolved", "timed_out", "cancelled"])),
+  metadata: Schema69.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartResult" });
 var StartExecutionWorkflowName = "Relay/Execution/Start";
 var ActivityNames = {
@@ -13702,7 +13777,7 @@ var cancelExecution = (input, turn, reason) => Activity.make({
 });
 var loadCancellationRequested = (input, turn) => Activity.make({
   name: ActivityNames.checkCancel(turn),
-  success: Schema67.Boolean,
+  success: Schema69.Boolean,
   error: ExecutionWorkflowFailed,
   execute: Effect73.gen(function* () {
     const repository = yield* exports_execution_repository.Service;
@@ -13712,7 +13787,7 @@ var loadCancellationRequested = (input, turn) => Activity.make({
 });
 var loadWait = (name, waitId) => Activity.make({
   name,
-  success: Schema67.UndefinedOr(WaitSnapshot),
+  success: Schema69.UndefinedOr(WaitSnapshot),
   error: ExecutionWorkflowFailed,
   execute: get11(waitId).pipe(Effect73.map((record2) => record2 === undefined ? undefined : toWaitSnapshot(record2)), Effect73.mapError(mapWaitError2))
 });
@@ -13803,7 +13878,7 @@ var compactionForStart = Effect73.fn("ExecutionWorkflow.compactionForStart")(fun
     ...keepRecentTokens === undefined ? {} : { keepRecentTokens }
   };
 });
-var decodeMemorySubject = (value) => typeof value === "string" ? Schema67.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(value).pipe(Effect73.mapError(() => new ExecutionWorkflowFailed({ message: `Invalid memory_subject_id metadata value: ${value}` }))) : Effect73.fail(new ExecutionWorkflowFailed({ message: "memory_subject_id metadata value must be a string" }));
+var decodeMemorySubject = (value) => typeof value === "string" ? Schema69.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(value).pipe(Effect73.mapError(() => new ExecutionWorkflowFailed({ message: `Invalid memory_subject_id metadata value: ${value}` }))) : Effect73.fail(new ExecutionWorkflowFailed({ message: "memory_subject_id metadata value must be a string" }));
 var memorySubjectForStart = Effect73.fn("ExecutionWorkflow.memorySubjectForStart")(function* (input) {
   const executionSubject = memorySubjectFromMetadata(input.metadata);
   if (executionSubject !== undefined)
@@ -13821,7 +13896,7 @@ var steeringEnabledForStart = (input) => {
 var nextEventSequence4 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect73.map((max) => max === undefined ? 0 : max + 1), Effect73.mapError(mapEventLogError6));
 var ensureWorkspace = (input) => Activity.make({
   name: ActivityNames.ensureWorkspace,
-  success: Schema67.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema69.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: Effect73.gen(function* () {
     if (input.agent_snapshot === undefined)
@@ -13838,19 +13913,19 @@ var ensureWorkspace = (input) => Activity.make({
 });
 var suspendWorkspace = (input, key2) => Activity.make({
   name: ActivityNames.suspendWorkspace(key2),
-  success: Schema67.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema69.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: suspend2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect73.mapError(mapWorkspaceError))
 });
 var resumeWorkspace = (input, key2) => Activity.make({
   name: ActivityNames.resumeWorkspace(key2),
-  success: Schema67.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema69.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: resume2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect73.map((plan2) => plan2?.lease), Effect73.mapError(mapWorkspaceError))
 });
 var releaseWorkspace = (input) => Activity.make({
   name: ActivityNames.releaseWorkspace,
-  success: Schema67.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema69.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: release2({ executionId: input.execution_id, now: input.completed_at }).pipe(Effect73.mapError(mapWorkspaceError))
 });
@@ -13951,7 +14026,7 @@ var childDispatchContext = (input) => {
 };
 var loadChildCancellationRequested = (input) => Activity.make({
   name: ActivityNames.checkQueuedChildCancellation,
-  success: Schema67.Boolean,
+  success: Schema69.Boolean,
   error: ExecutionWorkflowFailed,
   execute: Effect73.gen(function* () {
     const context = childDispatchContext(input);
@@ -13963,7 +14038,7 @@ var loadChildCancellationRequested = (input) => Activity.make({
 });
 var notifyParentActivity = (input, context, status, output) => Activity.make({
   name: ActivityNames.notifyParent(status),
-  success: Schema67.Void,
+  success: Schema69.Void,
   error: ExecutionWorkflowFailed,
   execute: Effect73.gen(function* () {
     const notifier = yield* Effect73.serviceOption(Service42);
@@ -14016,7 +14091,7 @@ var waitIdFromExecution = (execution) => {
 };
 var pendingToolCallFromExecution = (execution) => {
   const pending = execution.metadata?.pending_tool_call;
-  return Schema67.decodeUnknownOption(exports_tool_schema.Call)(pending).pipe(Option26.getOrUndefined);
+  return Schema69.decodeUnknownOption(exports_tool_schema.Call)(pending).pipe(Option26.getOrUndefined);
 };
 var finishCancelledWait = Effect73.fn("ExecutionWorkflow.finishCancelledWait")(function* (startInput, turn, waitId) {
   const cancelled = yield* cancelExecution(startInput, turn, "wait cancelled");
@@ -14230,7 +14305,7 @@ var Start = Rpc.make("start", {
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var SignalWait = Rpc.make("signalWait", {
   payload: SignalWaitInput,
-  success: Schema68.Void,
+  success: Schema70.Void,
   error: ExecutionWorkflowFailed
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var Cancel = Rpc.make("cancel", {
@@ -14244,7 +14319,7 @@ var layer49 = entity.toLayer(entity.of({
   signalWait: (request) => signalWait(request.payload),
   cancel: (request) => cancelRequest(request.payload)
 }), { concurrency: "unbounded" });
-var client = entity.client;
+var client2 = entity.client;
 // ../runtime/src/envelope/envelope-service.ts
 var exports_envelope_service = {};
 __export(exports_envelope_service, {
@@ -14258,26 +14333,26 @@ __export(exports_envelope_service, {
   EnvelopeRouteDeferred: () => EnvelopeRouteDeferred,
   EnvelopeAddressNotFound: () => EnvelopeAddressNotFound
 });
-import { Context as Context60, Effect as Effect74, Layer as Layer67, Schema as Schema69 } from "effect";
-class EnvelopeAddressNotFound extends Schema69.TaggedErrorClass()("EnvelopeAddressNotFound", {
+import { Context as Context60, Effect as Effect74, Layer as Layer67, Schema as Schema71 } from "effect";
+class EnvelopeAddressNotFound extends Schema71.TaggedErrorClass()("EnvelopeAddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class EnvelopeRouteUnavailable extends Schema69.TaggedErrorClass()("EnvelopeRouteUnavailable", {
+class EnvelopeRouteUnavailable extends Schema71.TaggedErrorClass()("EnvelopeRouteUnavailable", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema69.String
+  route_key: Schema71.String
 }) {
 }
 
-class EnvelopeRouteDeferred extends Schema69.TaggedErrorClass()("EnvelopeRouteDeferred", {
+class EnvelopeRouteDeferred extends Schema71.TaggedErrorClass()("EnvelopeRouteDeferred", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema69.String
+  route_key: Schema71.String
 }) {
 }
 
-class EnvelopeServiceError extends Schema69.TaggedErrorClass()("EnvelopeServiceError", {
-  message: Schema69.String
+class EnvelopeServiceError extends Schema71.TaggedErrorClass()("EnvelopeServiceError", {
+  message: Schema71.String
 }) {
 }
 
@@ -14435,7 +14510,7 @@ __export(exports_runner_runtime_service, {
   DatabaseMode: () => DatabaseMode,
   ClusterConfigMismatch: () => ClusterConfigMismatch
 });
-import { Config as Config5, Context as Context62, Crypto as Crypto4, Duration as Duration5, Effect as Effect77, Layer as Layer69, Option as Option27, Schema as Schema71, Stream as Stream10 } from "effect";
+import { Config as Config5, Context as Context62, Crypto as Crypto4, Duration as Duration5, Effect as Effect77, Layer as Layer69, Option as Option27, Schema as Schema73, Stream as Stream10 } from "effect";
 import {
   ClusterWorkflowEngine,
   HttpRunner,
@@ -14473,7 +14548,7 @@ __export(exports_scheduler_service, {
   SchedulerError: () => SchedulerError,
   ScheduleCronInvalid: () => ScheduleCronInvalid
 });
-import { Clock as Clock10, Config as Config4, Context as Context61, Cron, Duration as Duration4, Effect as Effect76, Layer as Layer68, Random, Result as Result3, Schema as Schema70 } from "effect";
+import { Clock as Clock10, Config as Config4, Context as Context61, Cron, Duration as Duration4, Effect as Effect76, Layer as Layer68, Random, Result as Result3, Schema as Schema72 } from "effect";
 
 // ../runtime/src/wait/wait-signal.ts
 var exports_wait_signal = {};
@@ -14483,8 +14558,8 @@ __export(exports_wait_signal, {
 import { Effect as Effect75 } from "effect";
 var signalWorkflowWait = Effect75.fn("WaitSignal.signalWorkflowWait")(function* (input) {
   const workflowExecutionId2 = yield* activeWorkflowExecutionIdForExecution(input.executionId);
-  const client2 = input.makeExecutionClient(input.executionId);
-  yield* client2.signalWait({
+  const client3 = input.makeExecutionClient(input.executionId);
+  yield* client3.signalWait({
     workflow_execution_id: workflowExecutionId2,
     wait_id: input.waitId,
     state: input.state,
@@ -14493,14 +14568,14 @@ var signalWorkflowWait = Effect75.fn("WaitSignal.signalWorkflowWait")(function*
 });
 
 // ../runtime/src/schedule/scheduler-service.ts
-class SchedulerError extends Schema70.TaggedErrorClass()("SchedulerError", {
-  message: Schema70.String
+class SchedulerError extends Schema72.TaggedErrorClass()("SchedulerError", {
+  message: Schema72.String
 }) {
 }
 
-class ScheduleCronInvalid extends Schema70.TaggedErrorClass()("ScheduleCronInvalid", {
-  cron_expr: Schema70.String,
-  message: Schema70.String
+class ScheduleCronInvalid extends Schema72.TaggedErrorClass()("ScheduleCronInvalid", {
+  cron_expr: Schema72.String,
+  message: Schema72.String
 }) {
 }
 
@@ -14538,7 +14613,7 @@ var make14 = Effect76.gen(function* () {
   const waits = yield* Service25;
   const eventLog = yield* Service24;
   const executionRepository = yield* exports_execution_repository.Service;
-  const makeExecutionClient = yield* client;
+  const makeExecutionClient = yield* client2;
   const workerId = yield* workerIdConfig;
   const claimTtlMillis = yield* claimTtlMillisConfig;
   const pollIntervalMillis = yield* pollIntervalMillisConfig;
@@ -14651,25 +14726,25 @@ var runOnce2 = Effect76.fn("SchedulerService.runOnce.call")(function* () {
 });
 
 // ../runtime/src/runner/runner-runtime-service.ts
-var DatabaseMode = Schema71.Literals(["sql", "pg", "mysql", "sqlite", "memory"]).annotate({
+var DatabaseMode = Schema73.Literals(["sql", "pg", "mysql", "sqlite", "memory"]).annotate({
   identifier: "Relay.RunnerRuntime.DatabaseMode"
 });
-var ReadinessStatus = Schema71.Struct({
+var ReadinessStatus = Schema73.Struct({
   database: DatabaseMode,
-  cluster: Schema71.Literal("ready"),
-  workflow: Schema71.Literals(["ready", "client"]),
-  executionEntity: Schema71.Literals(["registered", "client"])
+  cluster: Schema73.Literal("ready"),
+  workflow: Schema73.Literals(["ready", "client"]),
+  executionEntity: Schema73.Literals(["registered", "client"])
 }).annotate({ identifier: "Relay.RunnerRuntime.ReadinessStatus" });
 
-class RunnerRuntimeError extends Schema71.TaggedErrorClass()("RunnerRuntimeError", {
-  message: Schema71.String
+class RunnerRuntimeError extends Schema73.TaggedErrorClass()("RunnerRuntimeError", {
+  message: Schema73.String
 }) {
 }
 
-class ClusterConfigMismatch extends Schema71.TaggedErrorClass()("ClusterConfigMismatch", {
-  field: Schema71.String,
-  expected: Schema71.String,
-  actual: Schema71.String
+class ClusterConfigMismatch extends Schema73.TaggedErrorClass()("ClusterConfigMismatch", {
+  field: Schema73.String,
+  expected: Schema73.String,
+  actual: Schema73.String
 }) {
 }
 
@@ -14683,7 +14758,7 @@ var memoryClusterLayer = Sharding.layer.pipe(Layer69.provideMerge(Runners.layerN
 var clusterHost = Config5.string("RELAY_CLUSTER_HOST").pipe(Config5.withDefault("localhost"));
 var clusterPort = Config5.int("RELAY_CLUSTER_PORT").pipe(Config5.withDefault(34431));
 var clusterShardsPerGroup = Config5.int("RELAY_CLUSTER_SHARDS_PER_GROUP").pipe(Config5.withDefault(300));
-var clusterShardGroups = Config5.schema(Config5.Array(Schema71.String), "RELAY_CLUSTER_SHARD_GROUPS").pipe(Config5.withDefault(["default", "execution"]));
+var clusterShardGroups = Config5.schema(Config5.Array(Schema73.String), "RELAY_CLUSTER_SHARD_GROUPS").pipe(Config5.withDefault(["default", "execution"]));
 var runnerAddressKey = (address) => `${address.host}:${address.port}`;
 var runnerAddressEquals = (left, right) => left.host === right.host && left.port === right.port;
 var shardingConfigFromEnv = () => Layer69.effect(ShardingConfig2.ShardingConfig, Effect77.gen(function* () {
@@ -14784,7 +14859,7 @@ var testCryptoLayer = Layer69.succeed(Crypto4.Crypto, Crypto4.make({
 var executionServiceLayer = layer46.pipe(Layer69.provideMerge(layer32));
 var addressResolutionLayerWith = (toolRuntimeLayer) => layer25.pipe(Layer69.provideMerge(layerFromRepository), Layer69.provideMerge(layer24.pipe(Layer69.provideMerge(toolRuntimeLayer))));
 var parentNotifierLayer = Layer69.effect(Service42, Effect77.gen(function* () {
-  const makeExecutionClient = yield* client;
+  const makeExecutionClient = yield* client2;
   const executionRepository = yield* exports_execution_repository.Service;
   return yield* make13({
     signalWait: (input) => signalWorkflowWait({
@@ -14803,7 +14878,7 @@ var workflowAndEntityLayerWith = (toolRuntimeLayer, schedulerLayer, promptAssemb
 var makeService2 = (database, checkDatabase) => Effect77.gen(function* () {
   const sharding = yield* Sharding.Sharding;
   const workflow = yield* WorkflowEngine.WorkflowEngine;
-  const makeClient = yield* client;
+  const makeClient = yield* client2;
   return Service49.of({
     check: Effect77.fn("RunnerRuntime.check")(function* () {
       yield* Effect77.annotateCurrentSpan("relay.database.mode", database);
@@ -14850,7 +14925,7 @@ var sqlCheckLayer = Layer69.effect(Service49, Effect77.gen(function* () {
 }));
 var makeClientService = (database, checkDatabase) => Effect77.gen(function* () {
   const sharding = yield* Sharding.Sharding;
-  const makeClient = yield* client;
+  const makeClient = yield* client2;
   return Service49.of({
     check: Effect77.fn("RunnerRuntime.check")(function* () {
       yield* Effect77.annotateCurrentSpan("relay.database.mode", database);
@@ -15013,51 +15088,51 @@ __export(exports_activity_version_registry, {
   ActivityManifestChange: () => ActivityManifestChange,
   ActivityManifest: () => ActivityManifest
 });
-import { Crypto as Crypto5, Effect as Effect78, Schema as Schema72 } from "effect";
+import { Crypto as Crypto5, Effect as Effect78, Schema as Schema74 } from "effect";
 var generatedFrom = "@relayfx/runtime/ExecutionWorkflow";
-var ActivityManifestEntry = Schema72.Struct({
-  name: Schema72.String,
-  signature_hash: Schema72.String
+var ActivityManifestEntry = Schema74.Struct({
+  name: Schema74.String,
+  signature_hash: Schema74.String
 }).annotate({ identifier: "Relay.ActivityManifestEntry" });
-var ActivityManifest = Schema72.Struct({
-  version: Schema72.Literal(1),
-  generated_from: Schema72.String,
-  hash_algorithm: Schema72.Literal("sha256-json-schema-v1"),
-  activities: Schema72.Array(ActivityManifestEntry)
+var ActivityManifest = Schema74.Struct({
+  version: Schema74.Literal(1),
+  generated_from: Schema74.String,
+  hash_algorithm: Schema74.Literal("sha256-json-schema-v1"),
+  activities: Schema74.Array(ActivityManifestEntry)
 }).annotate({ identifier: "Relay.ActivityManifest" });
-var ActivityManifestChange = Schema72.Struct({
-  type: Schema72.Literals(["removed", "changed", "added"]),
-  name: Schema72.String,
-  baseline_hash: Schema72.optionalKey(Schema72.String),
-  current_hash: Schema72.optionalKey(Schema72.String)
+var ActivityManifestChange = Schema74.Struct({
+  type: Schema74.Literals(["removed", "changed", "added"]),
+  name: Schema74.String,
+  baseline_hash: Schema74.optionalKey(Schema74.String),
+  current_hash: Schema74.optionalKey(Schema74.String)
 }).annotate({ identifier: "Relay.ActivityManifestChange" });
-var ActivityManifestGuardResult = Schema72.Struct({
-  status: Schema72.Literals(["pass", "fail"]),
-  waiting_executions: Schema72.Int.check(Schema72.isGreaterThanOrEqualTo(0)),
-  breaking_changes: Schema72.Array(ActivityManifestChange),
-  additive_changes: Schema72.Array(ActivityManifestChange)
+var ActivityManifestGuardResult = Schema74.Struct({
+  status: Schema74.Literals(["pass", "fail"]),
+  waiting_executions: Schema74.Int.check(Schema74.isGreaterThanOrEqualTo(0)),
+  breaking_changes: Schema74.Array(ActivityManifestChange),
+  additive_changes: Schema74.Array(ActivityManifestChange)
 }).annotate({ identifier: "Relay.ActivityManifestGuardResult" });
 
-class ActivityManifestGuardFailed extends Schema72.TaggedErrorClass()("ActivityManifestGuardFailed", {
-  message: Schema72.String,
+class ActivityManifestGuardFailed extends Schema74.TaggedErrorClass()("ActivityManifestGuardFailed", {
+  message: Schema74.String,
   result: ActivityManifestGuardResult
 }) {
 }
-var TurnInput = Schema72.Struct({
+var TurnInput = Schema74.Struct({
   start: StartInput,
-  turn: Schema72.Int.check(Schema72.isGreaterThanOrEqualTo(0))
+  turn: Schema74.Int.check(Schema74.isGreaterThanOrEqualTo(0))
 });
-var WaitIdInput = Schema72.Struct({
+var WaitIdInput = Schema74.Struct({
   wait_id: exports_ids_schema.WaitId
 });
-var WorkspaceKeyInput = Schema72.Struct({
+var WorkspaceKeyInput = Schema74.Struct({
   start: StartInput,
-  key: Schema72.String
+  key: Schema74.String
 });
 var contracts = [
   {
     name: ActivityNameTemplates.resolveLocalAgent,
-    input: Schema72.Struct({ address_id: exports_ids_schema.AddressId }),
+    input: Schema74.Struct({ address_id: exports_ids_schema.AddressId }),
     success: LocalAgentTarget,
     error: ExecutionWorkflowFailed
   },
@@ -15069,66 +15144,66 @@ var contracts = [
   },
   {
     name: ActivityNameTemplates.cancel,
-    input: Schema72.Struct({ start: StartInput, turn: Schema72.Int, reason: Schema72.String }),
+    input: Schema74.Struct({ start: StartInput, turn: Schema74.Int, reason: Schema74.String }),
     success: exports_execution_schema.Execution,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.checkCancel,
     input: TurnInput,
-    success: Schema72.Boolean,
+    success: Schema74.Boolean,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.loadWaitBeforeSleep,
     input: WaitIdInput,
-    success: Schema72.UndefinedOr(WaitSnapshot),
+    success: Schema74.UndefinedOr(WaitSnapshot),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.loadWaitAfterWake,
     input: WaitIdInput,
-    success: Schema72.UndefinedOr(WaitSnapshot),
+    success: Schema74.UndefinedOr(WaitSnapshot),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.markWaiting,
-    input: Schema72.Struct({ start: StartInput, wait: WaitSnapshot }),
+    input: Schema74.Struct({ start: StartInput, wait: WaitSnapshot }),
     success: exports_execution_schema.Execution,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.ensureWorkspace,
     input: StartInput,
-    success: Schema72.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+    success: Schema74.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.suspendWorkspace,
     input: WorkspaceKeyInput,
-    success: Schema72.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+    success: Schema74.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.resumeWorkspace,
     input: WorkspaceKeyInput,
-    success: Schema72.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+    success: Schema74.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.releaseWorkspace,
     input: StartInput,
-    success: Schema72.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+    success: Schema74.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.complete,
-    input: Schema72.Struct({
+    input: Schema74.Struct({
       start: StartInput,
-      turn: Schema72.Int.check(Schema72.isGreaterThanOrEqualTo(0)),
-      wait_id: Schema72.optionalKey(exports_ids_schema.WaitId),
-      wait_state: Schema72.optionalKey(WaitSignalState),
-      pending_tool_call: Schema72.optionalKey(exports_tool_schema.Call)
+      turn: Schema74.Int.check(Schema74.isGreaterThanOrEqualTo(0)),
+      wait_id: Schema74.optionalKey(exports_ids_schema.WaitId),
+      wait_state: Schema74.optionalKey(WaitSignalState),
+      pending_tool_call: Schema74.optionalKey(exports_tool_schema.Call)
     }),
     success: exports_execution_schema.Execution,
     error: ExecutionWorkflowFailed
@@ -15136,24 +15211,24 @@ var contracts = [
   {
     name: ActivityNameTemplates.checkQueuedChildCancellation,
     input: StartInput,
-    success: Schema72.Boolean,
+    success: Schema74.Boolean,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.notifyParent,
-    input: Schema72.Struct({
+    input: Schema74.Struct({
       start: StartInput,
       status: ChildTerminalStatus,
-      output: Schema72.Array(exports_content_schema.Part)
+      output: Schema74.Array(exports_content_schema.Part)
     }),
-    success: Schema72.Void,
+    success: Schema74.Void,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.continueAsNew,
-    input: Schema72.Struct({
+    input: Schema74.Struct({
       start: StartInput,
-      turn: Schema72.Int.check(Schema72.isGreaterThanOrEqualTo(0)),
+      turn: Schema74.Int.check(Schema74.isGreaterThanOrEqualTo(0)),
       wait_id: exports_ids_schema.WaitId,
       pending_tool_call: exports_tool_schema.Call
     }),
@@ -15161,7 +15236,7 @@ var contracts = [
     error: ExecutionWorkflowFailed
   }
 ];
-var schemaJson = (schema) => Schema72.decodeUnknownSync(exports_shared_schema.JsonValue)(Schema72.toJsonSchemaDocument(schema));
+var schemaJson = (schema) => Schema74.decodeUnknownSync(exports_shared_schema.JsonValue)(Schema74.toJsonSchemaDocument(schema));
 var canonical = (value) => {
   if (value === null || typeof value !== "object")
     return value;
@@ -15276,7 +15351,7 @@ __export(exports_language_model_registration, {
   anthropic: () => anthropic
 });
 
-// ../../node_modules/.bun/@batonfx+providers@0.3.0/node_modules/@batonfx/providers/src/anthropic.ts
+// ../../node_modules/.bun/@batonfx+providers@0.3.2/node_modules/@batonfx/providers/src/anthropic.ts
 import { AnthropicClient, AnthropicLanguageModel } from "@effect/ai-anthropic";
 import { Layer as Layer70 } from "effect";
 import { FetchHttpClient as FetchHttpClient2 } from "effect/unstable/http";
@@ -15292,13 +15367,13 @@ var anthropic = (input) => exports_model_registry.registrationFromLayer({
 });
 var anthropicClientLayerConfig = AnthropicClient.layerConfig;
 var withAnthropic = (options) => exports_model_registry.layerFromRegistrationEffects([anthropic(options)]).pipe(Layer70.provide(AnthropicClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer70.provide(FetchHttpClient2.layer));
-// ../../node_modules/.bun/@batonfx+providers@0.3.0/node_modules/@batonfx/providers/src/deterministic.ts
+// ../../node_modules/.bun/@batonfx+providers@0.3.2/node_modules/@batonfx/providers/src/deterministic.ts
 import { OpenAiClient as OpenAiClient3 } from "@effect/ai-openai";
 import { Effect as Effect79, Layer as Layer72, Option as Option28, Stream as Stream11 } from "effect";
 import { LanguageModel as LanguageModel8, Response as Response7 } from "effect/unstable/ai";
 import { FetchHttpClient as FetchHttpClient4 } from "effect/unstable/http";
 
-// ../../node_modules/.bun/@batonfx+providers@0.3.0/node_modules/@batonfx/providers/src/openai.ts
+// ../../node_modules/.bun/@batonfx+providers@0.3.2/node_modules/@batonfx/providers/src/openai.ts
 import { OpenAiClient as OpenAiClient2, OpenAiLanguageModel } from "@effect/ai-openai";
 import { Layer as Layer71 } from "effect";
 import { FetchHttpClient as FetchHttpClient3 } from "effect/unstable/http";
@@ -15315,7 +15390,7 @@ var openAi = (input) => exports_model_registry.registrationFromLayer({
 var openAiClientLayerConfig2 = OpenAiClient2.layerConfig;
 var withOpenAi = (options) => exports_model_registry.layerFromRegistrationEffects([openAi(options)]).pipe(Layer71.provide(OpenAiClient2.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer71.provide(FetchHttpClient3.layer));
 
-// ../../node_modules/.bun/@batonfx+providers@0.3.0/node_modules/@batonfx/providers/src/deterministic.ts
+// ../../node_modules/.bun/@batonfx+providers@0.3.2/node_modules/@batonfx/providers/src/deterministic.ts
 var deterministicModelLayer = Layer72.effect(LanguageModel8.LanguageModel, LanguageModel8.make({
   generateText: () => Effect79.succeed([{ type: "text", text: "deterministic response" }]),
   streamText: () => Stream11.make(Response7.makePart("text-delta", { id: "text", delta: "deterministic response" }))
@@ -15339,7 +15414,7 @@ var withOpenAiOrDeterministic = (options) => Layer72.unwrap(Effect79.gen(functio
     ...Option28.isSome(openAiRegistration) ? [openAiRegistration.value] : []
   ]);
 }));
-// ../../node_modules/.bun/@batonfx+providers@0.3.0/node_modules/@batonfx/providers/src/openai-compat.ts
+// ../../node_modules/.bun/@batonfx+providers@0.3.2/node_modules/@batonfx/providers/src/openai-compat.ts
 import { OpenAiClient as OpenAiClient4, OpenAiLanguageModel as OpenAiLanguageModel2 } from "@effect/ai-openai-compat";
 import { Config as Config8, Layer as Layer73 } from "effect";
 import { FetchHttpClient as FetchHttpClient5 } from "effect/unstable/http";
@@ -15360,7 +15435,7 @@ var clientLayerConfig = (options) => OpenAiClient4.layerConfig({
   ...options.baseUrl === undefined ? {} : { apiUrl: Config8.succeed(options.baseUrl) }
 });
 var withOpenAiCompatible = (options) => exports_model_registry.layerFromRegistrationEffects([openAiCompatible(options)]).pipe(Layer73.provide(clientLayerConfig(options)), Layer73.provide(FetchHttpClient5.layer));
-// ../../node_modules/.bun/@batonfx+providers@0.3.0/node_modules/@batonfx/providers/src/openrouter.ts
+// ../../node_modules/.bun/@batonfx+providers@0.3.2/node_modules/@batonfx/providers/src/openrouter.ts
 import { OpenRouterClient, OpenRouterLanguageModel } from "@effect/ai-openrouter";
 import { Layer as Layer74 } from "effect";
 import { FetchHttpClient as FetchHttpClient6 } from "effect/unstable/http";