@relayfx/sdk 0.0.23 → 0.0.24

package/dist/index.js

@@ -865,26 +865,39 @@ __export(exports_address_book_repository, {
   AddressBookRepositoryError: () => AddressBookRepositoryError
 });
 import { asc, eq as eq2, sql as sql3 } from "drizzle-orm";
-import { Context as Context3, Effect as Effect3, Layer as Layer3, Schema as Schema12 } from "effect";
+import { Context as Context3, Effect as Effect3, Layer as Layer3, Schema as Schema13 } from "effect";
 
 // ../store-sql/src/database/database-service.ts
 var exports_database_service = {};
 __export(exports_database_service, {
   toPgDate: () => toPgDate,
+  timestampParam: () => timestampParam,
   testLayer: () => testLayer,
   pgTypeParsers: () => pgTypeParsers,
   layerFromPgClient: () => layerFromPgClient,
   layer: () => layer,
   fromPgDate: () => fromPgDate,
   fromNullablePgDate: () => fromNullablePgDate,
+  fromNullableDbTimestamp: () => fromNullableDbTimestamp,
+  fromDbTimestamp: () => fromDbTimestamp,
+  encodeJson: () => encodeJson,
+  dialect: () => dialect,
+  decodeJson: () => decodeJson,
+  decodeBool: () => decodeBool,
   check: () => check,
+  SqliteClientLive: () => SqliteClientLive,
   Service: () => Service,
-  PgClientLive: () => PgClientLive
+  PgClientLive: () => PgClientLive,
+  MysqlClientLive: () => MysqlClientLive,
+  Dialect: () => Dialect
 });
+import * as MysqlClient from "@effect/sql-mysql2/MysqlClient";
 import * as PgClient from "@effect/sql-pg/PgClient";
+import * as SqliteClient from "@effect/sql-sqlite-bun/SqliteClient";
 import * as PgDrizzle from "drizzle-orm/effect-postgres";
 import { sql } from "drizzle-orm";
-import { Config, Context, DateTime, Effect, Layer, Redacted } from "effect";
+import { Config, Context, DateTime, Effect, Layer, Redacted, Schema as Schema12 } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 import { types } from "pg";
 
 class Service extends Context.Service()("@relayfx/store-sql/Database") {
@@ -913,6 +926,33 @@ var check = Effect.fn("Database.check")(function* () {
   const db = yield* Service;
   yield* db.execute(sql`select 1 as ok`).pipe(Effect.asVoid);
 });
+var Dialect = Schema12.Literals(["pg", "mysql", "sqlite"]);
+var dialect = Effect.gen(function* () {
+  const client = yield* SqlClient.SqlClient;
+  const detected = client.onDialectOrElse({
+    pg: () => "pg",
+    mysql: () => "mysql",
+    sqlite: () => "sqlite",
+    orElse: () => null
+  });
+  return detected ?? (yield* Effect.die(new Error("unsupported SQL dialect")));
+});
+var MysqlClientLive = MysqlClient.layerConfig({
+  url: Config.redacted("DATABASE_URL").pipe(Config.withDefault(Redacted.make("mysql://relay:relay@localhost:5546/relay"))),
+  maxConnections: Config.int("RELAY_SQL_MAX_CONNECTIONS").pipe(Config.withDefault(8))
+});
+var SqliteClientLive = SqliteClient.layerConfig({
+  filename: Config.string("RELAY_SQLITE_FILE").pipe(Config.withDefault("relay.sqlite"))
+});
+var timestampParam = (client, millis) => client.onDialectOrElse({
+  sqlite: () => millis,
+  orElse: () => toPgDate(millis)
+});
+var fromDbTimestamp = fromPgDate;
+var fromNullableDbTimestamp = fromNullablePgDate;
+var encodeJson = (value) => JSON.stringify(value);
+var decodeJson = (value) => typeof value === "string" ? JSON.parse(value) : value;
+var decodeBool = (value) => value === true || value === 1 || value === "1";
 
 // ../store-sql/src/schema/relay-schema.ts
 var exports_relay_schema = {};
@@ -1385,13 +1425,13 @@ var predicate = (tenantId2, tenantColumn, ...conditions) => and(eq(tenantColumn,
 // ../store-sql/src/address/address-book-repository.ts
 var RouteKind2 = exports_address_schema.RouteKind;
 
-class AddressNotFound extends Schema12.TaggedErrorClass()("AddressNotFound", {
+class AddressNotFound extends Schema13.TaggedErrorClass()("AddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class AddressBookRepositoryError extends Schema12.TaggedErrorClass()("AddressBookRepositoryError", {
-  message: Schema12.String
+class AddressBookRepositoryError extends Schema13.TaggedErrorClass()("AddressBookRepositoryError", {
+  message: Schema13.String
 }) {
 }
 
@@ -1502,9 +1542,9 @@ __export(exports_agent_chat_repository, {
   AgentChatRepositoryError: () => AgentChatRepositoryError
 });
 import { eq as eq3 } from "drizzle-orm";
-import { Context as Context4, Effect as Effect4, Layer as Layer4, Schema as Schema13 } from "effect";
-class AgentChatRepositoryError extends Schema13.TaggedErrorClass()("AgentChatRepositoryError", {
-  message: Schema13.String
+import { Context as Context4, Effect as Effect4, Layer as Layer4, Schema as Schema14 } from "effect";
+class AgentChatRepositoryError extends Schema14.TaggedErrorClass()("AgentChatRepositoryError", {
+  message: Schema14.String
 }) {
 }
 
@@ -1583,9 +1623,9 @@ __export(exports_agent_definition_repository, {
   AgentDefinitionRepositoryError: () => AgentDefinitionRepositoryError
 });
 import { asc as asc2, desc, eq as eq4, sql as sql4 } from "drizzle-orm";
-import { Context as Context5, Effect as Effect5, Layer as Layer5, Schema as Schema14 } from "effect";
-class AgentDefinitionRepositoryError extends Schema14.TaggedErrorClass()("AgentDefinitionRepositoryError", {
-  message: Schema14.String
+import { Context as Context5, Effect as Effect5, Layer as Layer5, Schema as Schema15 } from "effect";
+class AgentDefinitionRepositoryError extends Schema15.TaggedErrorClass()("AgentDefinitionRepositoryError", {
+  message: Schema15.String
 }) {
 }
 
@@ -1613,7 +1653,7 @@ var toRevisionRecord = (row) => {
     createdAt: fromPgDate(row.createdAt)
   };
 };
-var cloneDefinition = (definition) => Schema14.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
+var cloneDefinition = (definition) => Schema15.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
 var cloneRecord = (record) => ({
   ...record,
   definition: cloneDefinition(record.definition),
@@ -1785,18 +1825,18 @@ __export(exports_child_execution_repository, {
   ChildExecutionNotFound: () => ChildExecutionNotFound
 });
 import { asc as asc3, eq as eq5 } from "drizzle-orm";
-import { Context as Context6, Effect as Effect6, Layer as Layer6, Schema as Schema15 } from "effect";
-class ChildExecutionRepositoryError extends Schema15.TaggedErrorClass()("ChildExecutionRepositoryError", {
-  message: Schema15.String
+import { Context as Context6, Effect as Effect6, Layer as Layer6, Schema as Schema16 } from "effect";
+class ChildExecutionRepositoryError extends Schema16.TaggedErrorClass()("ChildExecutionRepositoryError", {
+  message: Schema16.String
 }) {
 }
 
-class DuplicateChildExecution extends Schema15.TaggedErrorClass()("DuplicateChildExecution", {
+class DuplicateChildExecution extends Schema16.TaggedErrorClass()("DuplicateChildExecution", {
   id: exports_ids_schema.ChildExecutionId
 }) {
 }
 
-class ChildExecutionNotFound extends Schema15.TaggedErrorClass()("ChildExecutionNotFound", {
+class ChildExecutionNotFound extends Schema16.TaggedErrorClass()("ChildExecutionNotFound", {
   id: exports_ids_schema.ChildExecutionId
 }) {
 }
@@ -1931,24 +1971,24 @@ __export(exports_cluster_registry_repository, {
   LockRow: () => LockRow,
   ClusterRegistryError: () => ClusterRegistryError
 });
-import { Context as Context7, Effect as Effect7, Layer as Layer7, Schema as Schema16 } from "effect";
-import { SqlClient, SqlSchema } from "effect/unstable/sql";
+import { Context as Context7, Effect as Effect7, Layer as Layer7, Schema as Schema17 } from "effect";
+import { SqlClient as SqlClient3, SqlSchema } from "effect/unstable/sql";
 
-class ClusterRegistryError extends Schema16.TaggedErrorClass()("ClusterRegistryError", {
-  message: Schema16.String
+class ClusterRegistryError extends Schema17.TaggedErrorClass()("ClusterRegistryError", {
+  message: Schema17.String
 }) {
 }
 
 class Service7 extends Context7.Service()("@relayfx/store-sql/ClusterRegistryRepository") {
 }
-var RunnerRow = Schema16.Struct({
-  address: Schema16.String,
-  healthy: Schema16.Boolean,
-  last_heartbeat: Schema16.Union([Schema16.Date, Schema16.DateFromString]),
-  owned_shards: Schema16.Union([Schema16.Number, Schema16.NumberFromString])
+var RunnerRow = Schema17.Struct({
+  address: Schema17.String,
+  healthy: Schema17.Boolean,
+  last_heartbeat: Schema17.Union([Schema17.Date, Schema17.DateFromString]),
+  owned_shards: Schema17.Union([Schema17.Number, Schema17.NumberFromString])
 }).annotate({ identifier: "Relay.ClusterRegistry.RunnerRow" });
-var LockRow = Schema16.Struct({
-  address: Schema16.String
+var LockRow = Schema17.Struct({
+  address: Schema17.String
 }).annotate({ identifier: "Relay.ClusterRegistry.LockRow" });
 var toRunnerRecord = (row) => ({
   address: row.address,
@@ -1958,9 +1998,9 @@ var toRunnerRecord = (row) => ({
 });
 var toRegistryError = (error) => new ClusterRegistryError({ message: String(error) });
 var layer7 = Layer7.effect(Service7, Effect7.gen(function* () {
-  const sql5 = yield* SqlClient.SqlClient;
+  const sql5 = yield* SqlClient3.SqlClient;
   const runnersQuery = SqlSchema.findAll({
-    Request: Schema16.Void,
+    Request: Schema17.Void,
     Result: RunnerRow,
     execute: () => sql5`
         SELECT r.address, r.healthy, r.last_heartbeat, COUNT(l.shard_id) AS owned_shards
@@ -1971,7 +2011,7 @@ var layer7 = Layer7.effect(Service7, Effect7.gen(function* () {
       `
   });
   const ownerQuery = SqlSchema.findAll({
-    Request: Schema16.Struct({ shard_id: Schema16.String }),
+    Request: Schema17.Struct({ shard_id: Schema17.String }),
     Result: LockRow,
     execute: ({ shard_id }) => sql5`SELECT address FROM cluster_locks WHERE shard_id = ${shard_id}`
   });
@@ -2012,9 +2052,9 @@ __export(exports_compaction_repository, {
   CompactionRepositoryError: () => CompactionRepositoryError
 });
 import { asc as asc4, eq as eq6 } from "drizzle-orm";
-import { Context as Context8, Effect as Effect8, Layer as Layer8, Schema as Schema17 } from "effect";
-class CompactionRepositoryError extends Schema17.TaggedErrorClass()("CompactionRepositoryError", {
-  message: Schema17.String
+import { Context as Context8, Effect as Effect8, Layer as Layer8, Schema as Schema18 } from "effect";
+class CompactionRepositoryError extends Schema18.TaggedErrorClass()("CompactionRepositoryError", {
+  message: Schema18.String
 }) {
 }
 
@@ -2141,37 +2181,37 @@ __export(exports_envelope_repository, {
   EnvelopeNotFound: () => EnvelopeNotFound
 });
 import { and as and2, asc as asc5, desc as desc2, eq as eq7, inArray, lte, or, sql as sql5 } from "drizzle-orm";
-import { Context as Context9, Effect as Effect9, Layer as Layer9, Schema as Schema18 } from "effect";
-var WaitState = Schema18.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
+import { Context as Context9, Effect as Effect9, Layer as Layer9, Schema as Schema19 } from "effect";
+var WaitState = Schema19.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Store.WaitState"
 });
-var EnvelopeReadyState = Schema18.Literals(["ready", "claimed", "acknowledged"]).annotate({
+var EnvelopeReadyState = Schema19.Literals(["ready", "claimed", "acknowledged"]).annotate({
   identifier: "Relay.Store.EnvelopeReadyState"
 });
 
-class EnvelopeRepositoryError extends Schema18.TaggedErrorClass()("EnvelopeRepositoryError", {
-  message: Schema18.String
+class EnvelopeRepositoryError extends Schema19.TaggedErrorClass()("EnvelopeRepositoryError", {
+  message: Schema19.String
 }) {
 }
 
-class EnvelopeNotFound extends Schema18.TaggedErrorClass()("EnvelopeNotFound", {
+class EnvelopeNotFound extends Schema19.TaggedErrorClass()("EnvelopeNotFound", {
   id: exports_ids_schema.EnvelopeId
 }) {
 }
 
-class WaitNotFound extends Schema18.TaggedErrorClass()("WaitNotFound", {
+class WaitNotFound extends Schema19.TaggedErrorClass()("WaitNotFound", {
   id: exports_ids_schema.WaitId
 }) {
 }
 
-class EnvelopeReadyNotFound extends Schema18.TaggedErrorClass()("EnvelopeReadyNotFound", {
+class EnvelopeReadyNotFound extends Schema19.TaggedErrorClass()("EnvelopeReadyNotFound", {
   id: exports_ids_schema.EnvelopeReadyId
 }) {
 }
 
-class EnvelopeReadyClaimMismatch extends Schema18.TaggedErrorClass()("EnvelopeReadyClaimMismatch", {
+class EnvelopeReadyClaimMismatch extends Schema19.TaggedErrorClass()("EnvelopeReadyClaimMismatch", {
   id: exports_ids_schema.EnvelopeReadyId,
-  worker_id: Schema18.String
+  worker_id: Schema19.String
 }) {
 }
 
@@ -2629,31 +2669,31 @@ __export(exports_execution_event_repository, {
   DuplicateExecutionEvent: () => DuplicateExecutionEvent
 });
 import { asc as asc6, desc as desc3, eq as eq8, gt, max, or as or2, sql as sql6 } from "drizzle-orm";
-import { Context as Context10, Effect as Effect10, Filter, Layer as Layer10, Option as Option2, Schema as Schema19, Stream } from "effect";
+import { Context as Context10, Effect as Effect10, Filter, Layer as Layer10, Option as Option2, Schema as Schema20, Stream } from "effect";
 var executionEventsChannel = "relay_execution_events";
 
-class DuplicateExecutionEvent extends Schema19.TaggedErrorClass()("DuplicateExecutionEvent", {
+class DuplicateExecutionEvent extends Schema20.TaggedErrorClass()("DuplicateExecutionEvent", {
   execution_id: exports_ids_schema.ExecutionId,
   sequence: exports_execution_schema.ExecutionEventSequence,
   cursor: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ExecutionEventOrderViolation extends Schema19.TaggedErrorClass()("ExecutionEventOrderViolation", {
+class ExecutionEventOrderViolation extends Schema20.TaggedErrorClass()("ExecutionEventOrderViolation", {
   execution_id: exports_ids_schema.ExecutionId,
   sequence: exports_execution_schema.ExecutionEventSequence,
   previous_sequence: exports_execution_schema.ExecutionEventSequence
 }) {
 }
 
-class ExecutionEventCursorNotFound extends Schema19.TaggedErrorClass()("ExecutionEventCursorNotFound", {
+class ExecutionEventCursorNotFound extends Schema20.TaggedErrorClass()("ExecutionEventCursorNotFound", {
   execution_id: exports_ids_schema.ExecutionId,
   cursor: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ExecutionEventRepositoryError extends Schema19.TaggedErrorClass()("ExecutionEventRepositoryError", {
-  message: Schema19.String
+class ExecutionEventRepositoryError extends Schema20.TaggedErrorClass()("ExecutionEventRepositoryError", {
+  message: Schema20.String
 }) {
 }
 
@@ -2938,18 +2978,18 @@ __export(exports_execution_repository, {
   DuplicateExecution: () => DuplicateExecution
 });
 import { and as and3, desc as desc4, eq as eq9, lt, or as or3 } from "drizzle-orm";
-import { Context as Context11, Effect as Effect11, Layer as Layer11, Schema as Schema20 } from "effect";
-class ExecutionRepositoryError extends Schema20.TaggedErrorClass()("ExecutionRepositoryError", {
-  message: Schema20.String
+import { Context as Context11, Effect as Effect11, Layer as Layer11, Schema as Schema21 } from "effect";
+class ExecutionRepositoryError extends Schema21.TaggedErrorClass()("ExecutionRepositoryError", {
+  message: Schema21.String
 }) {
 }
 
-class DuplicateExecution extends Schema20.TaggedErrorClass()("DuplicateExecution", {
+class DuplicateExecution extends Schema21.TaggedErrorClass()("DuplicateExecution", {
   id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class ExecutionNotFound extends Schema20.TaggedErrorClass()("ExecutionNotFound", {
+class ExecutionNotFound extends Schema21.TaggedErrorClass()("ExecutionNotFound", {
   id: exports_ids_schema.ExecutionId
 }) {
 }
@@ -2981,7 +3021,7 @@ var validateCreateInput = (input) => {
   }
   return Effect11.void;
 };
-var cloneAgentDefinition = (definition) => Schema20.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
+var cloneAgentDefinition = (definition) => Schema21.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
 var cloneRecord3 = (record2) => ({
   ...record2,
   metadata: globalThis.structuredClone(record2.metadata),
@@ -3148,9 +3188,9 @@ var transition = Effect11.fn("ExecutionRepository.transition.call")(function* (i
 });
 // ../store-sql/src/idempotency/idempotency-repository.ts
 import { eq as eq10, sql as sql7 } from "drizzle-orm";
-import { Context as Context12, Effect as Effect12, HashMap, Layer as Layer12, Option as Option3, Ref, Schema as Schema21, Semaphore } from "effect";
-class IdempotencyRepositoryError extends Schema21.TaggedErrorClass()("IdempotencyRepositoryError", {
-  message: Schema21.String
+import { Context as Context12, Effect as Effect12, HashMap, Layer as Layer12, Option as Option3, Ref, Schema as Schema22, Semaphore } from "effect";
+class IdempotencyRepositoryError extends Schema22.TaggedErrorClass()("IdempotencyRepositoryError", {
+  message: Schema22.String
 }) {
 }
 
@@ -3248,9 +3288,9 @@ __export(exports_memory_repository, {
   MemoryRepositoryError: () => MemoryRepositoryError
 });
 import { sql as sql8 } from "drizzle-orm";
-import { Context as Context13, Effect as Effect13, Layer as Layer13, Ref as Ref2, Schema as Schema22 } from "effect";
-class MemoryRepositoryError extends Schema22.TaggedErrorClass()("MemoryRepositoryError", {
-  message: Schema22.String
+import { Context as Context13, Effect as Effect13, Layer as Layer13, Ref as Ref2, Schema as Schema23 } from "effect";
+class MemoryRepositoryError extends Schema23.TaggedErrorClass()("MemoryRepositoryError", {
+  message: Schema23.String
 }) {
 }
 
@@ -3490,9 +3530,9 @@ __export(exports_permission_rule_repository, {
   PermissionRuleRepositoryError: () => PermissionRuleRepositoryError
 });
 import { asc as asc7, eq as eq11 } from "drizzle-orm";
-import { Context as Context14, Effect as Effect14, Layer as Layer14, Schema as Schema23 } from "effect";
-class PermissionRuleRepositoryError extends Schema23.TaggedErrorClass()("PermissionRuleRepositoryError", {
-  message: Schema23.String
+import { Context as Context14, Effect as Effect14, Layer as Layer14, Schema as Schema24 } from "effect";
+class PermissionRuleRepositoryError extends Schema24.TaggedErrorClass()("PermissionRuleRepositoryError", {
+  message: Schema24.String
 }) {
 }
 
@@ -3581,9 +3621,9 @@ __export(exports_context_epoch_repository, {
   ContextEpochRepositoryError: () => ContextEpochRepositoryError
 });
 import { eq as eq12 } from "drizzle-orm";
-import { Context as Context15, Effect as Effect15, Layer as Layer15, Schema as Schema24 } from "effect";
-class ContextEpochRepositoryError extends Schema24.TaggedErrorClass()("ContextEpochRepositoryError", {
-  message: Schema24.String
+import { Context as Context15, Effect as Effect15, Layer as Layer15, Schema as Schema25 } from "effect";
+class ContextEpochRepositoryError extends Schema25.TaggedErrorClass()("ContextEpochRepositoryError", {
+  message: Schema25.String
 }) {
 }
 
@@ -3683,20 +3723,20 @@ __export(exports_schedule_repository, {
   ScheduleClaimMismatch: () => ScheduleClaimMismatch
 });
 import { and as and4, asc as asc8, eq as eq13, inArray as inArray2, lte as lte2, or as or4, sql as sql9 } from "drizzle-orm";
-import { Context as Context16, Effect as Effect16, Layer as Layer16, Schema as Schema25 } from "effect";
-class ScheduleRepositoryError extends Schema25.TaggedErrorClass()("ScheduleRepositoryError", {
-  message: Schema25.String
+import { Context as Context16, Effect as Effect16, Layer as Layer16, Schema as Schema26 } from "effect";
+class ScheduleRepositoryError extends Schema26.TaggedErrorClass()("ScheduleRepositoryError", {
+  message: Schema26.String
 }) {
 }
 
-class ScheduleNotFound extends Schema25.TaggedErrorClass()("ScheduleNotFound", {
+class ScheduleNotFound extends Schema26.TaggedErrorClass()("ScheduleNotFound", {
   id: exports_ids_schema.ScheduleId
 }) {
 }
 
-class ScheduleClaimMismatch extends Schema25.TaggedErrorClass()("ScheduleClaimMismatch", {
+class ScheduleClaimMismatch extends Schema26.TaggedErrorClass()("ScheduleClaimMismatch", {
   id: exports_ids_schema.ScheduleId,
-  worker_id: Schema25.String
+  worker_id: Schema26.String
 }) {
 }
 
@@ -4020,13 +4060,13 @@ __export(exports_session_repository, {
   DuplicateSession: () => DuplicateSession
 });
 import { and as and5, count, desc as desc5, eq as eq14, lt as lt2, or as or5 } from "drizzle-orm";
-import { Context as Context17, Effect as Effect17, Layer as Layer17, Schema as Schema26 } from "effect";
-class SessionRepositoryError extends Schema26.TaggedErrorClass()("SessionRepositoryError", {
-  message: Schema26.String
+import { Context as Context17, Effect as Effect17, Layer as Layer17, Schema as Schema27 } from "effect";
+class SessionRepositoryError extends Schema27.TaggedErrorClass()("SessionRepositoryError", {
+  message: Schema27.String
 }) {
 }
 
-class DuplicateSession extends Schema26.TaggedErrorClass()("DuplicateSession", {
+class DuplicateSession extends Schema27.TaggedErrorClass()("DuplicateSession", {
   id: exports_ids_schema.SessionId
 }) {
 }
@@ -4509,9 +4549,9 @@ __export(exports_skill_definition_repository, {
   Service: () => Service18
 });
 import { asc as asc9, desc as desc6, eq as eq15, inArray as inArray3, sql as sql10 } from "drizzle-orm";
-import { Context as Context18, Effect as Effect18, HashSet, Layer as Layer18, Schema as Schema27, Semaphore as Semaphore2 } from "effect";
-class SkillDefinitionRepositoryError extends Schema27.TaggedErrorClass()("SkillDefinitionRepositoryError", {
-  message: Schema27.String
+import { Context as Context18, Effect as Effect18, HashSet, Layer as Layer18, Schema as Schema28, Semaphore as Semaphore2 } from "effect";
+class SkillDefinitionRepositoryError extends Schema28.TaggedErrorClass()("SkillDefinitionRepositoryError", {
+  message: Schema28.String
 }) {
 }
 
@@ -4537,7 +4577,7 @@ var toPinRecord = (row) => ({
   skillDefinitionSnapshot: row.skillDefinitionSnapshotJson,
   createdAt: fromPgDate(row.createdAt)
 });
-var cloneDefinition2 = (definition) => Schema27.decodeUnknownSync(exports_skill_schema.Definition)(globalThis.structuredClone(definition));
+var cloneDefinition2 = (definition) => Schema28.decodeUnknownSync(exports_skill_schema.Definition)(globalThis.structuredClone(definition));
 var cloneRecord6 = (record2) => ({
   ...record2,
   definition: cloneDefinition2(record2.definition)
@@ -4812,22 +4852,22 @@ __export(exports_steering_repository, {
   Service: () => Service19
 });
 import { asc as asc10, eq as eq16, inArray as inArray4, isNull, max as max2, sql as sql11 } from "drizzle-orm";
-import { Context as Context19, Effect as Effect19, Layer as Layer19, Ref as Ref3, Schema as Schema28 } from "effect";
-class SteeringRepositoryError extends Schema28.TaggedErrorClass()("SteeringRepositoryError", {
-  message: Schema28.String
+import { Context as Context19, Effect as Effect19, Layer as Layer19, Ref as Ref3, Schema as Schema29 } from "effect";
+class SteeringRepositoryError extends Schema29.TaggedErrorClass()("SteeringRepositoryError", {
+  message: Schema29.String
 }) {
 }
 
 class Service19 extends Context19.Service()("@relayfx/store-sql/SteeringRepository") {
 }
-var SteeringKindSchema = Schema28.Literals(["steering", "follow_up"]);
+var SteeringKindSchema = Schema29.Literals(["steering", "follow_up"]);
 var mapDatabaseError15 = (effect) => effect.pipe(Effect19.mapError((error) => new SteeringRepositoryError({ message: String(error) })));
 var mapTransactionError = (effect) => effect.pipe(Effect19.mapError((error) => error instanceof SteeringRepositoryError ? error : new SteeringRepositoryError({ message: String(error) })));
 var toMessageRecord = (row) => {
   const consumedAt = fromNullablePgDate(row.consumedAt);
   return {
     executionId: exports_ids_schema.ExecutionId.make(row.executionId),
-    kind: Schema28.decodeUnknownSync(SteeringKindSchema)(row.kind),
+    kind: Schema29.decodeUnknownSync(SteeringKindSchema)(row.kind),
     sequence: row.sequence,
     content: row.contentJson,
     ...row.drainId === null || row.drainId === undefined ? {} : { drainId: row.drainId },
@@ -4837,7 +4877,7 @@ var toMessageRecord = (row) => {
 };
 var toDrainRecord = (row) => ({
   executionId: exports_ids_schema.ExecutionId.make(row.executionId),
-  kind: Schema28.decodeUnknownSync(SteeringKindSchema)(row.kind),
+  kind: Schema29.decodeUnknownSync(SteeringKindSchema)(row.kind),
   drainId: row.drainId,
   messageSequences: row.messageSequencesJson,
   createdAt: fromPgDate(row.createdAt)
@@ -5048,23 +5088,23 @@ __export(exports_tool_call_repository, {
   DuplicateToolCall: () => DuplicateToolCall
 });
 import { asc as asc11, eq as eq17 } from "drizzle-orm";
-import { Context as Context20, Effect as Effect20, Layer as Layer20, Schema as Schema29 } from "effect";
-class ToolCallRepositoryError extends Schema29.TaggedErrorClass()("ToolCallRepositoryError", {
-  message: Schema29.String
+import { Context as Context20, Effect as Effect20, Layer as Layer20, Schema as Schema30 } from "effect";
+class ToolCallRepositoryError extends Schema30.TaggedErrorClass()("ToolCallRepositoryError", {
+  message: Schema30.String
 }) {
 }
 
-class ToolCallNotFound extends Schema29.TaggedErrorClass()("ToolCallNotFound", {
+class ToolCallNotFound extends Schema30.TaggedErrorClass()("ToolCallNotFound", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class DuplicateToolCall extends Schema29.TaggedErrorClass()("DuplicateToolCall", {
+class DuplicateToolCall extends Schema30.TaggedErrorClass()("DuplicateToolCall", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class DuplicateToolResult extends Schema29.TaggedErrorClass()("DuplicateToolResult", {
+class DuplicateToolResult extends Schema30.TaggedErrorClass()("DuplicateToolResult", {
   call_id: exports_ids_schema.ToolCallId
 }) {
 }
@@ -5233,18 +5273,18 @@ __export(exports_workspace_lease_repository, {
   DuplicateWorkspaceLease: () => DuplicateWorkspaceLease
 });
 import { eq as eq18, notInArray } from "drizzle-orm";
-import { Context as Context21, Effect as Effect21, Layer as Layer21, Schema as Schema30 } from "effect";
-class WorkspaceLeaseRepositoryError extends Schema30.TaggedErrorClass()("WorkspaceLeaseRepositoryError", {
-  message: Schema30.String
+import { Context as Context21, Effect as Effect21, Layer as Layer21, Schema as Schema31 } from "effect";
+class WorkspaceLeaseRepositoryError extends Schema31.TaggedErrorClass()("WorkspaceLeaseRepositoryError", {
+  message: Schema31.String
 }) {
 }
 
-class DuplicateWorkspaceLease extends Schema30.TaggedErrorClass()("DuplicateWorkspaceLease", {
+class DuplicateWorkspaceLease extends Schema31.TaggedErrorClass()("DuplicateWorkspaceLease", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspaceLeaseNotFound extends Schema30.TaggedErrorClass()("WorkspaceLeaseNotFound", {
+class WorkspaceLeaseNotFound extends Schema31.TaggedErrorClass()("WorkspaceLeaseNotFound", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
@@ -5254,8 +5294,8 @@ class Service21 extends Context21.Service()("@relayfx/store-sql/WorkspaceLeaseRe
 var metadata9 = (input) => input ?? {};
 var terminalStatuses = ["released", "failed"];
 var isActive = (record2) => !terminalStatuses.includes(record2.status);
-var cloneLease = (record2) => Schema30.decodeUnknownSync(exports_workspace_schema.WorkspaceLeaseRecord)(globalThis.structuredClone(record2));
-var cloneSnapshot = (record2) => Schema30.decodeUnknownSync(exports_workspace_schema.WorkspaceSnapshotRecord)(globalThis.structuredClone(record2));
+var cloneLease = (record2) => Schema31.decodeUnknownSync(exports_workspace_schema.WorkspaceLeaseRecord)(globalThis.structuredClone(record2));
+var cloneSnapshot = (record2) => Schema31.decodeUnknownSync(exports_workspace_schema.WorkspaceSnapshotRecord)(globalThis.structuredClone(record2));
 var toPlanInsert = (tenantId2, input) => ({
   tenantId: tenantId2,
   id: input.id,
@@ -5518,7 +5558,7 @@ var markFailed = Effect21.fn("WorkspaceLeaseRepository.markFailed.call")(functio
   return yield* repository.markFailed(input);
 });
 // ../runtime/src/address/address-book-service.ts
-import { Context as Context22, Effect as Effect23, Layer as Layer22, Ref as Ref4, Schema as Schema31 } from "effect";
+import { Context as Context22, Effect as Effect23, Layer as Layer22, Ref as Ref4, Schema as Schema32 } from "effect";
 
 // ../runtime/src/observability/runtime-metrics.ts
 import { Effect as Effect22, Metric } from "effect";
@@ -5563,25 +5603,25 @@ var RouteKind3 = exports_address_schema.RouteKind;
 var Route2 = exports_address_schema.Route;
 var RouteRecord2 = exports_address_schema.RouteRecord;
 
-class AddressNotFound2 extends Schema31.TaggedErrorClass()("AddressNotFound", {
+class AddressNotFound2 extends Schema32.TaggedErrorClass()("AddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class AddressUnavailable extends Schema31.TaggedErrorClass()("AddressUnavailable", {
+class AddressUnavailable extends Schema32.TaggedErrorClass()("AddressUnavailable", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema31.String
+  route_key: Schema32.String
 }) {
 }
 
-class AddressDeferred extends Schema31.TaggedErrorClass()("AddressDeferred", {
+class AddressDeferred extends Schema32.TaggedErrorClass()("AddressDeferred", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema31.String
+  route_key: Schema32.String
 }) {
 }
 
-class AddressBookServiceError extends Schema31.TaggedErrorClass()("AddressBookServiceError", {
-  message: Schema31.String
+class AddressBookServiceError extends Schema32.TaggedErrorClass()("AddressBookServiceError", {
+  message: Schema32.String
 }) {
 }
 
@@ -5609,7 +5649,7 @@ var recordFromEntry = (entry) => ({
   updated_at: entry.updatedAt
 });
 var entryIdFor = (addressId) => exports_ids_schema.AddressBookEntryId.make(`address-book:${addressId}`);
-var validateRoute = (route) => Schema31.decodeUnknownEffect(Route2)(route).pipe(Effect23.mapError((error) => new AddressBookServiceError({ message: String(error) })));
+var validateRoute = (route) => Schema32.decodeUnknownEffect(Route2)(route).pipe(Effect23.mapError((error) => new AddressBookServiceError({ message: String(error) })));
 var mapRepositoryError = (error) => {
   if (error._tag === "AddressNotFound") {
     return new AddressNotFound2({ address_id: error.address_id });
@@ -5749,7 +5789,7 @@ __export(exports_address_resolution_service, {
   AddressResolutionError: () => AddressResolutionError,
   AddressAgentDefinitionNotFound: () => AddressAgentDefinitionNotFound
 });
-import { Context as Context27, Effect as Effect29, Layer as Layer27, Schema as Schema36 } from "effect";
+import { Context as Context27, Effect as Effect29, Layer as Layer27, Schema as Schema37 } from "effect";
 
 // ../runtime/src/agent/agent-registry-service.ts
 var exports_agent_registry_service = {};
@@ -5765,7 +5805,7 @@ __export(exports_agent_registry_service, {
   AgentRegistryError: () => AgentRegistryError,
   AgentDefinitionInvalid: () => AgentDefinitionInvalid
 });
-import { Clock, Context as Context26, Crypto as Crypto2, Effect as Effect28, HashSet as HashSet4, Layer as Layer26, Option as Option7, Schema as Schema35 } from "effect";
+import { Clock, Context as Context26, Crypto as Crypto2, Effect as Effect28, HashSet as HashSet4, Layer as Layer26, Option as Option7, Schema as Schema36 } from "effect";
 
 // ../runtime/src/tool/tool-input-schema-digest.ts
 import { Crypto, Effect as Effect24 } from "effect";
@@ -5809,7 +5849,7 @@ __export(exports_tool_runtime_service, {
   Service: () => Service25
 });
 import * as Ai from "effect/unstable/ai";
-import { Chunk, Context as Context25, Effect as Effect27, HashSet as HashSet3, Layer as Layer25, Option as Option6, Ref as Ref6, Schema as Schema34, Sink, Stream as Stream3 } from "effect";
+import { Chunk, Context as Context25, Effect as Effect27, HashSet as HashSet3, Layer as Layer25, Option as Option6, Ref as Ref6, Schema as Schema35, Sink, Stream as Stream3 } from "effect";
 
 // ../runtime/src/execution/event-log-service.ts
 var exports_event_log_service = {};
@@ -5843,17 +5883,17 @@ import {
   Option as Option4,
   PubSub,
   Ref as Ref5,
-  Schema as Schema32,
+  Schema as Schema33,
   Stream as Stream2
 } from "effect";
-class EventLogCursorNotFound extends Schema32.TaggedErrorClass()("EventLogCursorNotFound", {
+class EventLogCursorNotFound extends Schema33.TaggedErrorClass()("EventLogCursorNotFound", {
   execution_id: exports_ids_schema.ExecutionId,
   cursor: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class EventLogError extends Schema32.TaggedErrorClass()("EventLogError", {
-  message: Schema32.String
+class EventLogError extends Schema33.TaggedErrorClass()("EventLogError", {
+  message: Schema33.String
 }) {
 }
 
@@ -6112,19 +6152,19 @@ __export(exports_wait_service, {
   WaitDefinitionMissing: () => WaitDefinitionMissing,
   Service: () => Service24
 });
-import { Context as Context24, Duration as Duration2, Effect as Effect26, Layer as Layer24, Option as Option5, Schema as Schema33 } from "effect";
-class WaitNotFound2 extends Schema33.TaggedErrorClass()("WaitNotFound", {
+import { Context as Context24, Duration as Duration2, Effect as Effect26, Layer as Layer24, Option as Option5, Schema as Schema34 } from "effect";
+class WaitNotFound2 extends Schema34.TaggedErrorClass()("WaitNotFound", {
   wait_id: exports_ids_schema.WaitId
 }) {
 }
 
-class WaitDefinitionMissing extends Schema33.TaggedErrorClass()("WaitDefinitionMissing", {
+class WaitDefinitionMissing extends Schema34.TaggedErrorClass()("WaitDefinitionMissing", {
   envelope_id: exports_ids_schema.EnvelopeId
 }) {
 }
 
-class WaitServiceError extends Schema33.TaggedErrorClass()("WaitServiceError", {
-  message: Schema33.String
+class WaitServiceError extends Schema34.TaggedErrorClass()("WaitServiceError", {
+  message: Schema34.String
 }) {
 }
 
@@ -6312,37 +6352,37 @@ var cancel2 = Effect26.fn("WaitService.cancel.call")(function* (input) {
 });
 
 // ../runtime/src/tool/tool-runtime-service.ts
-class ToolNotRegistered extends Schema34.TaggedErrorClass()("ToolNotRegistered", {
+class ToolNotRegistered extends Schema35.TaggedErrorClass()("ToolNotRegistered", {
   tool_name: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ToolPermissionDenied extends Schema34.TaggedErrorClass()("ToolPermissionDenied", {
+class ToolPermissionDenied extends Schema35.TaggedErrorClass()("ToolPermissionDenied", {
   tool_name: exports_shared_schema.NonEmptyString,
   permission_name: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ToolInputInvalid extends Schema34.TaggedErrorClass()("ToolInputInvalid", {
+class ToolInputInvalid extends Schema35.TaggedErrorClass()("ToolInputInvalid", {
   tool_name: exports_shared_schema.NonEmptyString,
-  message: Schema34.String
+  message: Schema35.String
 }) {
 }
 
-class ToolExecutionFailed extends Schema34.TaggedErrorClass()("ToolExecutionFailed", {
+class ToolExecutionFailed extends Schema35.TaggedErrorClass()("ToolExecutionFailed", {
   tool_name: exports_shared_schema.NonEmptyString,
-  message: Schema34.String
+  message: Schema35.String
 }) {
 }
 
-class ToolExecutionWaitRequested extends Schema34.TaggedErrorClass()("ToolExecutionWaitRequested", {
+class ToolExecutionWaitRequested extends Schema35.TaggedErrorClass()("ToolExecutionWaitRequested", {
   tool_name: exports_shared_schema.NonEmptyString,
   wait_id: exports_ids_schema.WaitId
 }) {
 }
 
-class ToolRuntimeError extends Schema34.TaggedErrorClass()("ToolRuntimeError", {
-  message: Schema34.String
+class ToolRuntimeError extends Schema35.TaggedErrorClass()("ToolRuntimeError", {
+  message: Schema35.String
 }) {
 }
 
@@ -6363,7 +6403,7 @@ var ensureAllowed = (tool, input) => {
 var validateInput = (tool, input) => {
   if (tool.inputSchema === undefined)
     return Effect27.void;
-  return Schema34.decodeUnknownEffect(tool.inputSchema)(input.call.input).pipe(Effect27.mapError((error) => new ToolInputInvalid({ tool_name: input.call.name, message: error.message })), Effect27.asVoid);
+  return Schema35.decodeUnknownEffect(tool.inputSchema)(input.call.input).pipe(Effect27.mapError((error) => new ToolInputInvalid({ tool_name: input.call.name, message: error.message })), Effect27.asVoid);
 };
 var mapRepositoryError3 = (error) => new ToolRuntimeError({ message: error._tag });
 var mapEventLogError2 = (error) => new ToolRuntimeError({ message: error._tag });
@@ -6418,8 +6458,8 @@ var upsertTool = (registry, tool) => {
   return Chunk.map(registry, (registered) => registered.definition.name === tool.definition.name ? tool : registered);
 };
 var registerTool = (tools, tool) => Ref6.update(tools, (registry) => upsertTool(registry, tool));
-var jsonValue = (value) => Schema34.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
-var fallbackParametersSchema = Schema34.Struct({});
+var jsonValue = (value) => Schema35.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var fallbackParametersSchema = Schema35.Struct({});
 var parametersForRegisteredTool = (inputSchema) => {
   const schema = exports_tool_schema.parametersSchema(inputSchema);
   return schema.ast._tag === "Unknown" ? { parameters: fallbackParametersSchema, jsonSchema: inputSchema } : { parameters: schema };
@@ -6432,7 +6472,7 @@ var aiToolFromRegistered = (tool) => {
   return attachJsonSchema(Ai.Tool.dynamic(tool.definition.name, {
     description: tool.definition.description,
     parameters: parameters.parameters,
-    success: Schema34.Unknown,
+    success: Schema35.Unknown,
     needsApproval: tool.definition.needs_approval
   }), parameters.jsonSchema);
 };
@@ -6621,13 +6661,13 @@ var run = Effect27.fn("ToolRuntime.run.call")(function* (input) {
 });
 
 // ../runtime/src/agent/agent-registry-service.ts
-class AgentDefinitionInvalid extends Schema35.TaggedErrorClass()("AgentDefinitionInvalid", {
-  message: Schema35.String
+class AgentDefinitionInvalid extends Schema36.TaggedErrorClass()("AgentDefinitionInvalid", {
+  message: Schema36.String
 }) {
 }
 
-class AgentRegistryError extends Schema35.TaggedErrorClass()("AgentRegistryError", {
-  message: Schema35.String
+class AgentRegistryError extends Schema36.TaggedErrorClass()("AgentRegistryError", {
+  message: Schema36.String
 }) {
 }
 
@@ -6771,41 +6811,41 @@ var listRevisions3 = Effect28.fn("AgentRegistry.listRevisions.call")(function* (
 });
 
 // ../runtime/src/address/address-resolution-service.ts
-class AddressRouteNotFound extends Schema36.TaggedErrorClass()("AddressRouteNotFound", {
+class AddressRouteNotFound extends Schema37.TaggedErrorClass()("AddressRouteNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class AddressRouteKindMismatch extends Schema36.TaggedErrorClass()("AddressRouteKindMismatch", {
+class AddressRouteKindMismatch extends Schema37.TaggedErrorClass()("AddressRouteKindMismatch", {
   address_id: exports_ids_schema.AddressId,
-  expected: Schema36.Literal("local-agent"),
+  expected: Schema37.Literal("local-agent"),
   actual: exports_address_schema.RouteKind,
-  route_key: Schema36.String
+  route_key: Schema37.String
 }) {
 }
 
-class AddressAgentDefinitionNotFound extends Schema36.TaggedErrorClass()("AddressAgentDefinitionNotFound", {
+class AddressAgentDefinitionNotFound extends Schema37.TaggedErrorClass()("AddressAgentDefinitionNotFound", {
   address_id: exports_ids_schema.AddressId,
   agent_definition_id: exports_ids_schema.AgentDefinitionId
 }) {
 }
 
-class AddressResolutionError extends Schema36.TaggedErrorClass()("AddressResolutionError", {
-  message: Schema36.String
+class AddressResolutionError extends Schema37.TaggedErrorClass()("AddressResolutionError", {
+  message: Schema37.String
 }) {
 }
-var LocalAgentRoute = Schema36.Struct({
-  kind: Schema36.Literal("local-agent"),
+var LocalAgentRoute = Schema37.Struct({
+  kind: Schema37.Literal("local-agent"),
   route_key: exports_shared_schema.NonEmptyString,
-  metadata: Schema36.optionalKey(exports_shared_schema.Metadata)
+  metadata: Schema37.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.AddressResolution.LocalAgentRoute" });
-var LocalAgentTarget = Schema36.Struct({
+var LocalAgentTarget = Schema37.Struct({
   address_id: exports_ids_schema.AddressId,
   route: LocalAgentRoute,
   agent_definition_id: exports_ids_schema.AgentDefinitionId,
   agent_definition_revision: exports_agent_schema.DefinitionRevision,
   agent_definition_snapshot: exports_agent_schema.Definition,
-  tool_input_schema_digests: Schema36.optionalKey(exports_agent_schema.ToolInputSchemaDigests)
+  tool_input_schema_digests: Schema37.optionalKey(exports_agent_schema.ToolInputSchemaDigests)
 }).annotate({ identifier: "Relay.AddressResolution.LocalAgentTarget" });
 
 class Service27 extends Context27.Service()("@relayfx/runtime/AddressResolution") {
@@ -6838,7 +6878,7 @@ var layer25 = Layer27.effect(Service27, Effect29.gen(function* () {
         return yield* Effect29.fail(new AddressRouteNotFound({ address_id: addressId }));
       }
       const route = yield* routeToLocalAgent(addressId, record2.route);
-      const agentDefinitionId = yield* Schema36.decodeUnknownEffect(exports_ids_schema.AgentDefinitionId)(route.route_key).pipe(Effect29.mapError((error) => new AddressResolutionError({ message: String(error) })));
+      const agentDefinitionId = yield* Schema37.decodeUnknownEffect(exports_ids_schema.AgentDefinitionId)(route.route_key).pipe(Effect29.mapError((error) => new AddressResolutionError({ message: String(error) })));
       const definition = yield* agentRegistry.get(agentDefinitionId).pipe(Effect29.mapError(mapAgentRegistryError));
       if (definition === undefined) {
         return yield* Effect29.fail(new AddressAgentDefinitionNotFound({
@@ -6903,7 +6943,7 @@ __export(exports_agent_event, {
   AgentSuspended: () => AgentSuspended,
   AgentError: () => AgentError
 });
-import { Schema as Schema37 } from "effect";
+import { Schema as Schema38 } from "effect";
 import * as Ai2 from "effect/unstable/ai";
 var addUsageField = (left, right) => left === undefined && right === undefined ? undefined : (left ?? 0) + (right ?? 0);
 var addUsage = (left, right) => new Ai2.Response.Usage({
@@ -6920,34 +6960,34 @@ var addUsage = (left, right) => new Ai2.Response.Usage({
   }
 });
 
-class AgentError extends Schema37.TaggedErrorClass()("@batonfx/core/AgentError", {
-  message: Schema37.String,
-  turn: Schema37.Number,
-  cause: Schema37.optionalKey(Schema37.Defect())
+class AgentError extends Schema38.TaggedErrorClass()("@batonfx/core/AgentError", {
+  message: Schema38.String,
+  turn: Schema38.Number,
+  cause: Schema38.optionalKey(Schema38.Defect())
 }) {
 }
 
-class TurnLimitExceeded extends Schema37.TaggedErrorClass()("@batonfx/core/TurnLimitExceeded", {
-  turn: Schema37.Number,
-  pending: Schema37.Array(Schema37.Struct({
-    tool_call_id: Schema37.String,
-    tool_name: Schema37.String
+class TurnLimitExceeded extends Schema38.TaggedErrorClass()("@batonfx/core/TurnLimitExceeded", {
+  turn: Schema38.Number,
+  pending: Schema38.Array(Schema38.Struct({
+    tool_call_id: Schema38.String,
+    tool_name: Schema38.String
   }))
 }) {
 }
 
-class MiddlewareViolation extends Schema37.TaggedErrorClass()("@batonfx/core/MiddlewareViolation", {
-  turn: Schema37.Number,
-  detail: Schema37.String
+class MiddlewareViolation extends Schema38.TaggedErrorClass()("@batonfx/core/MiddlewareViolation", {
+  turn: Schema38.Number,
+  detail: Schema38.String
 }) {
 }
 
-class AgentSuspended extends Schema37.TaggedErrorClass()("@batonfx/core/AgentSuspended", {
-  token: Schema37.String,
-  reason: Schema37.Literals(["tool-wait", "approval"]),
-  tool_call_id: Schema37.String,
-  tool_name: Schema37.String,
-  tool_params: Schema37.Unknown
+class AgentSuspended extends Schema38.TaggedErrorClass()("@batonfx/core/AgentSuspended", {
+  token: Schema38.String,
+  reason: Schema38.Literals(["tool-wait", "approval"]),
+  tool_call_id: Schema38.String,
+  tool_name: Schema38.String,
+  tool_params: Schema38.Unknown
 }) {
 }
 
@@ -6982,7 +7022,7 @@ __export(exports_compaction, {
   CompactionError: () => CompactionError,
   Compaction: () => Compaction
 });
-import { Context as Context31, Effect as Effect33, Layer as Layer31, Option as Option10, Schema as Schema40 } from "effect";
+import { Context as Context31, Effect as Effect33, Layer as Layer31, Option as Option10, Schema as Schema41 } from "effect";
 import * as Ai4 from "effect/unstable/ai";
 
 // ../../node_modules/.bun/@batonfx+core@0.1.1/node_modules/@batonfx/core/src/session.ts
@@ -6994,11 +7034,11 @@ __export(exports_session, {
   SessionStoreError: () => SessionStoreError,
   SessionStore: () => SessionStore
 });
-import { Context as Context29, Effect as Effect31, HashMap as HashMap3, Layer as Layer29, Option as Option8, Ref as Ref7, Schema as Schema38 } from "effect";
+import { Context as Context29, Effect as Effect31, HashMap as HashMap3, Layer as Layer29, Option as Option8, Ref as Ref7, Schema as Schema39 } from "effect";
 import * as Ai3 from "effect/unstable/ai";
 
-class SessionStoreError extends Schema38.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
-  message: Schema38.String
+class SessionStoreError extends Schema39.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
+  message: Schema39.String
 }) {
 }
 
@@ -7127,13 +7167,13 @@ __export(exports_tool_output, {
   ToolOutputStore: () => ToolOutputStore,
   ToolOutputError: () => ToolOutputError
 });
-import { Context as Context30, Effect as Effect32, HashMap as HashMap4, Layer as Layer30, Option as Option9, Ref as Ref8, Schema as Schema39 } from "effect";
+import { Context as Context30, Effect as Effect32, HashMap as HashMap4, Layer as Layer30, Option as Option9, Ref as Ref8, Schema as Schema40 } from "effect";
 
 class ToolOutputStore extends Context30.Service()("@batonfx/core/ToolOutputStore") {
 }
 
-class ToolOutputError extends Schema39.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
-  message: Schema39.String
+class ToolOutputError extends Schema40.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
+  message: Schema40.String
 }) {
 }
 var layerNoop = Layer30.succeed(ToolOutputStore, ToolOutputStore.of({ put: () => Effect32.succeed(Option9.none()) }));
@@ -7196,9 +7236,9 @@ Use Markdown with these sections:
 
 Do not mention that context was compacted.`;
 
-class CompactionError extends Schema40.TaggedErrorClass()("@batonfx/core/CompactionError", {
-  message: Schema40.String,
-  cause: Schema40.optionalKey(Schema40.Defect())
+class CompactionError extends Schema41.TaggedErrorClass()("@batonfx/core/CompactionError", {
+  message: Schema41.String,
+  cause: Schema41.optionalKey(Schema41.Defect())
 }) {
 }
 
@@ -7417,10 +7457,10 @@ __export(exports_memory, {
   MemoryError: () => MemoryError,
   Memory: () => Memory
 });
-import { Context as Context33, Effect as Effect35, Layer as Layer33, Schema as Schema41 } from "effect";
+import { Context as Context33, Effect as Effect35, Layer as Layer33, Schema as Schema42 } from "effect";
 
-class MemoryError extends Schema41.TaggedErrorClass()("@batonfx/core/MemoryError", {
-  message: Schema41.String
+class MemoryError extends Schema42.TaggedErrorClass()("@batonfx/core/MemoryError", {
+  message: Schema42.String
 }) {
 }
 
@@ -7510,10 +7550,10 @@ __export(exports_permissions, {
   Permissions: () => Permissions,
   PermissionError: () => PermissionError
 });
-import { Context as Context36, Effect as Effect38, Layer as Layer36, Option as Option13, Ref as Ref9, Schema as Schema42 } from "effect";
+import { Context as Context36, Effect as Effect38, Layer as Layer36, Option as Option13, Ref as Ref9, Schema as Schema43 } from "effect";
 
-class PermissionError extends Schema42.TaggedErrorClass()("@batonfx/core/PermissionError", {
-  message: Schema42.String
+class PermissionError extends Schema43.TaggedErrorClass()("@batonfx/core/PermissionError", {
+  message: Schema43.String
 }) {
 }
 
@@ -8309,16 +8349,16 @@ var generateObject = (agent, options) => Stream6.runFold(streamObject(agent, opt
   })
 })));
 // ../../node_modules/.bun/@batonfx+core@0.1.1/node_modules/@batonfx/core/src/agent-tool.ts
-import { Cause as Cause4, Effect as Effect44, Schema as Schema43 } from "effect";
+import { Cause as Cause4, Effect as Effect44, Schema as Schema44 } from "effect";
 import * as Ai7 from "effect/unstable/ai";
-var defaultParameters = Schema43.Struct({ prompt: Schema43.String });
+var defaultParameters = Schema44.Struct({ prompt: Schema44.String });
 // ../../node_modules/.bun/@batonfx+core@0.1.1/node_modules/@batonfx/core/src/guardrail.ts
 import { Effect as Effect45, Option as Option16 } from "effect";
 import * as Ai8 from "effect/unstable/ai";
 // ../../node_modules/.bun/@batonfx+core@0.1.1/node_modules/@batonfx/core/src/handoff.ts
-import { Effect as Effect46, Schema as Schema44 } from "effect";
+import { Effect as Effect46, Schema as Schema45 } from "effect";
 import * as Ai9 from "effect/unstable/ai";
-var defaultTransferParameters = Schema44.Struct({ prompt: Schema44.String });
+var defaultTransferParameters = Schema45.Struct({ prompt: Schema45.String });
 // ../../node_modules/.bun/@batonfx+core@0.1.1/node_modules/@batonfx/core/src/model-registry.ts
 var exports_model_registry = {};
 __export(exports_model_registry, {
@@ -8333,13 +8373,13 @@ __export(exports_model_registry, {
   Service: () => Service28,
   LanguageModelNotRegistered: () => LanguageModelNotRegistered
 });
-import { Chunk as Chunk2, Context as Context40, Effect as Effect47, Layer as Layer41, Option as Option17, Ref as Ref11, Schema as Schema45, Semaphore as Semaphore3 } from "effect";
+import { Chunk as Chunk2, Context as Context40, Effect as Effect47, Layer as Layer41, Option as Option17, Ref as Ref11, Schema as Schema46, Semaphore as Semaphore3 } from "effect";
 import * as Ai10 from "effect/unstable/ai";
 
-class LanguageModelNotRegistered extends Schema45.TaggedErrorClass()("LanguageModelNotRegistered", {
-  provider: Schema45.String,
-  model: Schema45.String,
-  registration_key: Schema45.optionalKey(Schema45.String)
+class LanguageModelNotRegistered extends Schema46.TaggedErrorClass()("LanguageModelNotRegistered", {
+  provider: Schema46.String,
+  model: Schema46.String,
+  registration_key: Schema46.optionalKey(Schema46.String)
 }) {
 }
 
@@ -8417,12 +8457,12 @@ __export(exports_skill_source, {
   SkillSource: () => SkillSource,
   DESCRIPTION_CAP: () => DESCRIPTION_CAP
 });
-import { Context as Context41, Effect as Effect48, Layer as Layer42, Schema as Schema46 } from "effect";
+import { Context as Context41, Effect as Effect48, Layer as Layer42, Schema as Schema47 } from "effect";
 
-class SkillSourceError extends Schema46.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
-  source: Schema46.String,
-  message: Schema46.String,
-  cause: Schema46.optionalKey(Schema46.Defect())
+class SkillSourceError extends Schema47.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
+  source: Schema47.String,
+  message: Schema47.String,
+  cause: Schema47.optionalKey(Schema47.Defect())
 }) {
 }
 var DESCRIPTION_CAP = 1536;
@@ -8463,7 +8503,7 @@ var selectListings = (skills, budgetTokens, recentlyUsed) => {
   return selected;
 };
 // ../runtime/src/agent/agent-loop-service.ts
-import { Config as Config3, Context as Context53, Crypto as Crypto3, Effect as Effect66, HashSet as HashSet6, Layer as Layer59, Option as Option22, Ref as Ref18, Schema as Schema59, Stream as Stream7 } from "effect";
+import { Config as Config3, Context as Context53, Crypto as Crypto3, Effect as Effect66, HashSet as HashSet6, Layer as Layer59, Option as Option22, Ref as Ref18, Schema as Schema60, Stream as Stream7 } from "effect";
 import * as Ai17 from "effect/unstable/ai";
 
 // ../runtime/src/child/child-run-service.ts
@@ -8483,31 +8523,31 @@ __export(exports_child_run_service, {
   ChildRunScopeBroadened: () => ChildRunScopeBroadened,
   ChildRunModelMissing: () => ChildRunModelMissing
 });
-import { Context as Context43, Effect as Effect50, HashSet as HashSet5, Layer as Layer44, Option as Option18, Result as Result2, Schema as Schema48 } from "effect";
+import { Context as Context43, Effect as Effect50, HashSet as HashSet5, Layer as Layer44, Option as Option18, Result as Result2, Schema as Schema49 } from "effect";
 
 // ../runtime/src/workspace/workspace-provider-service.ts
-import { Context as Context42, Effect as Effect49, Layer as Layer43, Ref as Ref12, Schema as Schema47 } from "effect";
+import { Context as Context42, Effect as Effect49, Layer as Layer43, Ref as Ref12, Schema as Schema48 } from "effect";
 
-class WorkspaceNotFound extends Schema47.TaggedErrorClass()("WorkspaceNotFound", {
+class WorkspaceNotFound extends Schema48.TaggedErrorClass()("WorkspaceNotFound", {
   sandbox_ref: exports_ids_schema.WorkspaceRef
 }) {
 }
 
-class WorkspaceUnavailable extends Schema47.TaggedErrorClass()("WorkspaceUnavailable", {
+class WorkspaceUnavailable extends Schema48.TaggedErrorClass()("WorkspaceUnavailable", {
   sandbox_ref: exports_ids_schema.WorkspaceRef,
-  message: Schema47.String
+  message: Schema48.String
 }) {
 }
 
-class WorkspaceCapabilityUnsupported extends Schema47.TaggedErrorClass()("WorkspaceCapabilityUnsupported", {
-  capability: Schema47.Literals(["suspend", "snapshot", "fork"]),
+class WorkspaceCapabilityUnsupported extends Schema48.TaggedErrorClass()("WorkspaceCapabilityUnsupported", {
+  capability: Schema48.Literals(["suspend", "snapshot", "fork"]),
   provider_key: exports_workspace_schema.WorkspaceProviderKey
 }) {
 }
 
-class WorkspaceProviderError extends Schema47.TaggedErrorClass()("WorkspaceProviderError", {
+class WorkspaceProviderError extends Schema48.TaggedErrorClass()("WorkspaceProviderError", {
   provider_key: exports_workspace_schema.WorkspaceProviderKey,
-  message: Schema47.String
+  message: Schema48.String
 }) {
 }
 
@@ -8539,28 +8579,28 @@ var destroy = Effect49.fn("WorkspaceProvider.destroy.call")(function* (ref) {
 });
 
 // ../runtime/src/child/child-run-service.ts
-class StaticChildRunPresetNotFound extends Schema48.TaggedErrorClass()("StaticChildRunPresetNotFound", {
+class StaticChildRunPresetNotFound extends Schema49.TaggedErrorClass()("StaticChildRunPresetNotFound", {
   preset_name: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ChildRunScopeBroadened extends Schema48.TaggedErrorClass()("ChildRunScopeBroadened", {
-  field: Schema48.Literals(["tool_names", "permissions"]),
+class ChildRunScopeBroadened extends Schema49.TaggedErrorClass()("ChildRunScopeBroadened", {
+  field: Schema49.Literals(["tool_names", "permissions"]),
   value: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ChildRunServiceError extends Schema48.TaggedErrorClass()("ChildRunServiceError", {
-  message: Schema48.String
+class ChildRunServiceError extends Schema49.TaggedErrorClass()("ChildRunServiceError", {
+  message: Schema49.String
 }) {
 }
 
-class ChildRunWorkspaceUnavailable extends Schema48.TaggedErrorClass()("ChildRunWorkspaceUnavailable", {
-  reason: Schema48.String
+class ChildRunWorkspaceUnavailable extends Schema49.TaggedErrorClass()("ChildRunWorkspaceUnavailable", {
+  reason: Schema49.String
 }) {
 }
 
-class ChildRunModelMissing extends Schema48.TaggedErrorClass()("ChildRunModelMissing", {}) {
+class ChildRunModelMissing extends Schema49.TaggedErrorClass()("ChildRunModelMissing", {}) {
 }
 
 class Service30 extends Context43.Service()("@relayfx/runtime/ChildRunService") {
@@ -8788,34 +8828,34 @@ var spawnDynamic = Effect50.fn("ChildRunService.spawnDynamic.call")(function* (i
 });
 
 // ../runtime/src/child/spawn-child-run-tool.ts
-import { Effect as Effect51, Schema as Schema49 } from "effect";
+import { Effect as Effect51, Schema as Schema50 } from "effect";
 import * as Ai11 from "effect/unstable/ai";
 var toolName = "spawn_child_run";
 var permissionName = "relay.child_run.spawn";
-var Input = Schema49.Struct({
-  preset_name: Schema49.optionalKey(exports_shared_schema.NonEmptyString),
-  instructions: Schema49.optionalKey(Schema49.String),
-  model: Schema49.optionalKey(exports_agent_schema.ModelSelection),
-  tool_names: Schema49.optionalKey(Schema49.Array(Schema49.String)),
-  permissions: Schema49.optionalKey(Schema49.Array(Schema49.String)),
-  output_schema_ref: Schema49.optionalKey(Schema49.String),
-  metadata: Schema49.optionalKey(exports_shared_schema.Metadata),
-  input: Schema49.optionalKey(Schema49.Array(exports_content_schema.Part))
+var Input = Schema50.Struct({
+  preset_name: Schema50.optionalKey(exports_shared_schema.NonEmptyString),
+  instructions: Schema50.optionalKey(Schema50.String),
+  model: Schema50.optionalKey(exports_agent_schema.ModelSelection),
+  tool_names: Schema50.optionalKey(Schema50.Array(Schema50.String)),
+  permissions: Schema50.optionalKey(Schema50.Array(Schema50.String)),
+  output_schema_ref: Schema50.optionalKey(Schema50.String),
+  metadata: Schema50.optionalKey(exports_shared_schema.Metadata),
+  input: Schema50.optionalKey(Schema50.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Input" });
-var Output = Schema49.Struct({
+var Output = Schema50.Struct({
   child_execution_id: exports_ids_schema.ChildExecutionId,
-  status: Schema49.Literals(["completed", "failed", "cancelled"]),
-  output: Schema49.Array(exports_content_schema.Part)
+  status: Schema50.Literals(["completed", "failed", "cancelled"]),
+  output: Schema50.Array(exports_content_schema.Part)
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Output" });
-var TransferInput = Schema49.Struct({
-  input: Schema49.optionalKey(Schema49.Array(exports_content_schema.Part))
+var TransferInput = Schema50.Struct({
+  input: Schema50.optionalKey(Schema50.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.TransferInput" });
 var aiTool = Ai11.Tool.dynamic(toolName, {
   description: "Spawn a durable child run and wait for its terminal output.",
   parameters: Input,
   success: Output
 });
-var jsonValue2 = (value) => Schema49.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue2 = (value) => Schema50.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var enabled = (agent) => agent.metadata?.multi_agent_enabled === true;
 var parentContext = (agent) => ({
   ...agent.instructions === undefined ? {} : { instructions: agent.instructions },
@@ -8937,7 +8977,7 @@ var resultFromTerminal = Effect51.fn("SpawnChildRunTool.resultFromTerminal")(fun
   return jsonValue2({ child_execution_id: id2, status, output });
 });
 var run2 = (config, activeToolName = toolName, fixedPresetName) => Effect51.fn("SpawnChildRunTool.run")(function* (rawInput, context) {
-  const input = fixedPresetName === undefined ? yield* Schema49.decodeUnknownEffect(Input)(rawInput).pipe(Effect51.mapError((error) => new ToolExecutionFailed({ tool_name: activeToolName, message: error.message }))) : yield* Schema49.decodeUnknownEffect(TransferInput)(rawInput).pipe(Effect51.map((transfer) => ({ preset_name: fixedPresetName, input: transfer.input ?? [] })), Effect51.mapError((error) => new ToolExecutionFailed({ tool_name: activeToolName, message: error.message })));
+  const input = fixedPresetName === undefined ? yield* Schema50.decodeUnknownEffect(Input)(rawInput).pipe(Effect51.mapError((error) => new ToolExecutionFailed({ tool_name: activeToolName, message: error.message }))) : yield* Schema50.decodeUnknownEffect(TransferInput)(rawInput).pipe(Effect51.map((transfer) => ({ preset_name: fixedPresetName, input: transfer.input ?? [] })), Effect51.mapError((error) => new ToolExecutionFailed({ tool_name: activeToolName, message: error.message })));
   if (fixedPresetName === undefined)
     yield* ensureStaticOrDynamic(input);
   const id2 = childExecutionId(context);
@@ -9010,17 +9050,17 @@ var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target
 });
 
 // ../runtime/src/memory/memory-service.ts
-import { Clock as Clock2, Context as Context45, Effect as Effect53, Layer as Layer46, Schema as Schema51 } from "effect";
+import { Clock as Clock2, Context as Context45, Effect as Effect53, Layer as Layer46, Schema as Schema52 } from "effect";
 import * as Ai13 from "effect/unstable/ai";
 
 // ../runtime/src/model/embedding-model-service.ts
-import { Context as Context44, Effect as Effect52, Layer as Layer45, Ref as Ref13, Schema as Schema50 } from "effect";
+import { Context as Context44, Effect as Effect52, Layer as Layer45, Ref as Ref13, Schema as Schema51 } from "effect";
 import * as Ai12 from "effect/unstable/ai";
 
-class EmbeddingModelNotRegistered extends Schema50.TaggedErrorClass()("EmbeddingModelNotRegistered", {
-  provider: Schema50.String,
-  model: Schema50.String,
-  registration_key: Schema50.optionalKey(Schema50.String)
+class EmbeddingModelNotRegistered extends Schema51.TaggedErrorClass()("EmbeddingModelNotRegistered", {
+  provider: Schema51.String,
+  model: Schema51.String,
+  registration_key: Schema51.optionalKey(Schema51.String)
 }) {
 }
 
@@ -9146,7 +9186,7 @@ var defaultTopK = 5;
 var memoryError = (error) => new exports_memory.MemoryError({
   message: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
 });
-var decodeSubject = (subject) => Schema51.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect53.mapError(memoryError));
+var decodeSubject = (subject) => Schema52.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect53.mapError(memoryError));
 var textPart = (text3) => Ai13.Prompt.makePart("text", { text: text3 });
 var textFromParts = (parts) => parts.filter((part) => part.type === "text").map((part) => part.text).join(`
 `).trim();
@@ -9368,9 +9408,9 @@ __export(exports_schema_registry_service, {
   Service: () => Service35,
   SchemaRefNotRegistered: () => SchemaRefNotRegistered
 });
-import { Context as Context48, Effect as Effect55, Layer as Layer49, Ref as Ref14, Schema as Schema52 } from "effect";
+import { Context as Context48, Effect as Effect55, Layer as Layer49, Ref as Ref14, Schema as Schema53 } from "effect";
 
-class SchemaRefNotRegistered extends Schema52.TaggedErrorClass()("SchemaRefNotRegistered", { schema_ref: exports_shared_schema.NonEmptyString }) {
+class SchemaRefNotRegistered extends Schema53.TaggedErrorClass()("SchemaRefNotRegistered", { schema_ref: exports_shared_schema.NonEmptyString }) {
 }
 
 class Service35 extends Context48.Service()("@relayfx/runtime/SchemaRegistry") {
@@ -9503,16 +9543,16 @@ __export(exports_blob_store_service, {
   BlobStoreError: () => BlobStoreError,
   BlobNotResolvable: () => BlobNotResolvable
 });
-import { Context as Context50, Effect as Effect57, Layer as Layer51, Ref as Ref16, Schema as Schema53 } from "effect";
+import { Context as Context50, Effect as Effect57, Layer as Layer51, Ref as Ref16, Schema as Schema54 } from "effect";
 
-class BlobNotResolvable extends Schema53.TaggedErrorClass()("BlobNotResolvable", {
-  uri: Schema53.String,
-  reason: Schema53.String
+class BlobNotResolvable extends Schema54.TaggedErrorClass()("BlobNotResolvable", {
+  uri: Schema54.String,
+  reason: Schema54.String
 }) {
 }
 
-class BlobStoreError extends Schema53.TaggedErrorClass()("BlobStoreError", {
-  message: Schema53.String
+class BlobStoreError extends Schema54.TaggedErrorClass()("BlobStoreError", {
+  message: Schema54.String
 }) {
 }
 
@@ -9585,7 +9625,7 @@ __export(exports_prompt_assembler_service, {
   Service: () => Service39,
   PromptAssemblerError: () => PromptAssemblerError
 });
-import { Context as Context52, Effect as Effect59, Layer as Layer53, Schema as Schema55 } from "effect";
+import { Context as Context52, Effect as Effect59, Layer as Layer53, Schema as Schema56 } from "effect";
 import * as Ai15 from "effect/unstable/ai";
 
 // ../runtime/src/content/artifact-store-service.ts
@@ -9600,11 +9640,11 @@ __export(exports_artifact_store_service, {
   Memory: () => Memory2,
   ArtifactNotResolvable: () => ArtifactNotResolvable
 });
-import { Context as Context51, Effect as Effect58, Layer as Layer52, Schema as Schema54 } from "effect";
+import { Context as Context51, Effect as Effect58, Layer as Layer52, Schema as Schema55 } from "effect";
 
-class ArtifactNotResolvable extends Schema54.TaggedErrorClass()("ArtifactNotResolvable", {
-  artifact_id: Schema54.String,
-  reason: Schema54.String
+class ArtifactNotResolvable extends Schema55.TaggedErrorClass()("ArtifactNotResolvable", {
+  artifact_id: Schema55.String,
+  reason: Schema55.String
 }) {
 }
 
@@ -9646,14 +9686,14 @@ var register8 = Effect58.fn("ArtifactStore.register.call")(function* (artifact_i
 });
 
 // ../runtime/src/agent/prompt-assembler-service.ts
-class PromptAssemblerError extends Schema55.TaggedErrorClass()("PromptAssemblerError", {
-  message: Schema55.String
+class PromptAssemblerError extends Schema56.TaggedErrorClass()("PromptAssemblerError", {
+  message: Schema56.String
 }) {
 }
 
 class Service39 extends Context52.Service()("@relayfx/runtime/PromptAssembler") {
 }
-var jsonValue3 = (value) => Schema55.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue3 = (value) => Schema56.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var stringifyJson = (value) => JSON.stringify(jsonValue3(value));
 var contentToPromptPart = (part) => {
   const options = part.provider_options;
@@ -9797,8 +9837,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 Clock5, Effect as Effect61, Equal as Equal2, Layer as Layer55, Option as Option19, Schema as Schema56 } from "effect";
-var jsonValue4 = (value) => Schema56.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
+import { Clock as Clock5, Effect as Effect61, Equal as Equal2, Layer as Layer55, Option as Option19, Schema as Schema57 } from "effect";
+var jsonValue4 = (value) => Schema57.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));
@@ -9964,7 +10004,7 @@ var awaitAnswer = Effect61.fn("RelayPermissions.awaitAnswer")(function* (config,
 });
 var rememberRule = Effect61.fn("RelayPermissions.rememberRule")(function* (config, rule) {
   const createdAt = yield* Clock5.currentTimeMillis;
-  const decodedRule = yield* Schema56.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect61.mapError((error) => permissionError(error.message)));
+  const decodedRule = yield* Schema57.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect61.mapError((error) => permissionError(error.message)));
   yield* config.repository.remember({
     agent: config.agentName,
     scope: config.scope,
@@ -9980,9 +10020,9 @@ var layer40 = (config) => Layer55.mergeAll(Layer55.succeed(exports_permissions.P
 })));
 
 // ../runtime/src/agent/relay-steering.ts
-import { Clock as Clock6, Effect as Effect62, Layer as Layer56, Schema as Schema57 } from "effect";
+import { Clock as Clock6, Effect as Effect62, Layer as Layer56, Schema as Schema58 } from "effect";
 import * as Ai16 from "effect/unstable/ai";
-var jsonValue5 = (value) => Schema57.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue5 = (value) => Schema58.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var stringifyJson2 = (value) => JSON.stringify(jsonValue5(value));
 var createdAtForSequence2 = (config, sequence) => config.startedAt + sequence - config.eventSequence;
 var drainId = (config, kind, sequence) => `drain:${config.executionId}:steering:${kind}:sequence:${sequence}`;
@@ -10015,7 +10055,7 @@ var contentFromMessage = (message) => {
   const textParts = promptTextParts(prompt);
   if (textParts.length > 0)
     return textParts;
-  return [exports_content_schema.text(stringifyJson2(Schema57.encodeSync(Ai16.Prompt.Prompt)(prompt)))];
+  return [exports_content_schema.text(stringifyJson2(Schema58.encodeSync(Ai16.Prompt.Prompt)(prompt)))];
 };
 var steeringReceivedEvent = (config, kind, drain2, messages, sequence) => ({
   id: exports_ids_schema.EventId.make(`event:${drain2.drainId}:received`),
@@ -10060,8 +10100,8 @@ var layer41 = (config) => Layer56.succeed(exports_steering.Steering, exports_ste
 }));
 
 // ../runtime/src/agent/relay-tool-executor.ts
-import { Effect as Effect63, Layer as Layer57, Option as Option20, Schema as Schema58 } from "effect";
-var jsonValue6 = (value) => Schema58.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+import { Effect as Effect63, Layer as Layer57, Option as Option20, Schema as Schema59 } from "effect";
+var jsonValue6 = (value) => Schema59.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var errorDetail = (error) => {
   switch (error._tag) {
     case "ToolNotRegistered":
@@ -10168,29 +10208,29 @@ var make12 = (first) => Ref17.make(first).pipe(Effect65.map((ref) => ({
 })));
 
 // ../runtime/src/agent/agent-loop-service.ts
-class AgentLoopError extends Schema59.TaggedErrorClass()("AgentLoopError", {
-  message: Schema59.String,
-  next_event_sequence: Schema59.optionalKey(exports_execution_schema.ExecutionEventSequence)
+class AgentLoopError extends Schema60.TaggedErrorClass()("AgentLoopError", {
+  message: Schema60.String,
+  next_event_sequence: Schema60.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
-class AgentLoopWaitRequested extends Schema59.TaggedErrorClass()("AgentLoopWaitRequested", {
+class AgentLoopWaitRequested extends Schema60.TaggedErrorClass()("AgentLoopWaitRequested", {
   wait_id: exports_ids_schema.WaitId,
   tool_call: exports_tool_schema.Call,
   next_event_sequence: exports_execution_schema.ExecutionEventSequence
 }) {
 }
 
-class AgentLoopBudgetExceeded extends Schema59.TaggedErrorClass()("AgentLoopBudgetExceeded", {
-  tokens_used: Schema59.Int,
-  token_budget: Schema59.Int,
+class AgentLoopBudgetExceeded extends Schema60.TaggedErrorClass()("AgentLoopBudgetExceeded", {
+  tokens_used: Schema60.Int,
+  token_budget: Schema60.Int,
   next_event_sequence: exports_execution_schema.ExecutionEventSequence
 }) {
 }
 
 class Service40 extends Context53.Service()("@relayfx/runtime/AgentLoop") {
 }
-var jsonValue7 = (value) => Schema59.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue7 = (value) => Schema60.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var toolNames = (agent) => HashSet6.fromIterable(agent.tool_names);
 var availableRegisteredTools = (agent, registered) => {
   const names = toolNames(agent);
@@ -10752,7 +10792,7 @@ __export(exports_execution_entity, {
 });
 import { ClusterSchema, Entity } from "effect/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
-import { Schema as Schema66 } from "effect";
+import { Schema as Schema67 } from "effect";
 
 // ../runtime/src/workflow/execution-workflow.ts
 var exports_execution_workflow = {};
@@ -10783,15 +10823,15 @@ __export(exports_execution_workflow, {
   ActivityNameTemplates: () => ActivityNameTemplates
 });
 import { Activity, DurableDeferred, Workflow } from "effect/unstable/workflow";
-import { Effect as Effect72, Exit as Exit2, Option as Option26, Schema as Schema65 } from "effect";
+import { Effect as Effect72, Exit as Exit2, Option as Option26, Schema as Schema66 } from "effect";
 
 // ../runtime/src/child/parent-notifier-service.ts
-import { Context as Context54, Effect as Effect67, Layer as Layer60, Option as Option23, Ref as Ref19, Schema as Schema60 } from "effect";
-class ParentNotifyError extends Schema60.TaggedErrorClass()("ParentNotifyError", {
-  message: Schema60.String
+import { Context as Context54, Effect as Effect67, Layer as Layer60, Option as Option23, Ref as Ref19, Schema as Schema61 } from "effect";
+class ParentNotifyError extends Schema61.TaggedErrorClass()("ParentNotifyError", {
+  message: Schema61.String
 }) {
 }
-var ChildTerminalStatus = Schema60.Literals(["completed", "failed", "cancelled"]).annotate({
+var ChildTerminalStatus = Schema61.Literals(["completed", "failed", "cancelled"]).annotate({
   identifier: "Relay.ParentNotifier.ChildTerminalStatus"
 });
 
@@ -10890,15 +10930,15 @@ __export(exports_skill_registry_service, {
   SkillDefinitionInvalid: () => SkillDefinitionInvalid,
   Service: () => Service42
 });
-import { Clock as Clock7, Context as Context55, Effect as Effect68, Layer as Layer61, Schema as Schema61 } from "effect";
+import { Clock as Clock7, Context as Context55, Effect as Effect68, Layer as Layer61, Schema as Schema62 } from "effect";
 
-class SkillDefinitionInvalid extends Schema61.TaggedErrorClass()("SkillDefinitionInvalid", {
-  message: Schema61.String
+class SkillDefinitionInvalid extends Schema62.TaggedErrorClass()("SkillDefinitionInvalid", {
+  message: Schema62.String
 }) {
 }
 
-class SkillRegistryError extends Schema61.TaggedErrorClass()("SkillRegistryError", {
-  message: Schema61.String
+class SkillRegistryError extends Schema62.TaggedErrorClass()("SkillRegistryError", {
+  message: Schema62.String
 }) {
 }
 
@@ -11067,11 +11107,11 @@ __export(exports_execution_service, {
   Service: () => Service43,
   ExecutionServiceError: () => ExecutionServiceError
 });
-import { Clock as Clock8, Context as Context56, Effect as Effect69, Layer as Layer62, Option as Option24, Schema as Schema62, Stream as Stream8 } from "effect";
+import { Clock as Clock8, Context as Context56, Effect as Effect69, Layer as Layer62, Option as Option24, Schema as Schema63, Stream as Stream8 } from "effect";
 import { ShardingConfig } from "effect/unstable/cluster";
-class ExecutionServiceError extends Schema62.TaggedErrorClass()("ExecutionServiceError", {
-  message: Schema62.String,
-  next_event_sequence: Schema62.optionalKey(exports_execution_schema.ExecutionEventSequence)
+class ExecutionServiceError extends Schema63.TaggedErrorClass()("ExecutionServiceError", {
+  message: Schema63.String,
+  next_event_sequence: Schema63.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
@@ -11391,13 +11431,13 @@ var spawnChildRun = Effect69.fn("ExecutionService.spawnChildRun.call")(function*
 var stream3 = (input) => Stream8.unwrap(Service43.pipe(Effect69.map((service) => service.stream(input))));
 
 // ../runtime/src/workspace/workspace-planner-service.ts
-import { Context as Context58, Effect as Effect71, HashSet as HashSet7, Layer as Layer64, Option as Option25, Schema as Schema64 } from "effect";
+import { Context as Context58, Effect as Effect71, HashSet as HashSet7, Layer as Layer64, Option as Option25, Schema as Schema65 } from "effect";
 
 // ../runtime/src/workspace/workspace-runtime-service.ts
-import { Context as Context57, Effect as Effect70, Layer as Layer63, Schema as Schema63 } from "effect";
+import { Context as Context57, Effect as Effect70, Layer as Layer63, Schema as Schema64 } from "effect";
 
-class WorkspaceRuntimeError extends Schema63.TaggedErrorClass()("WorkspaceRuntimeError", {
-  message: Schema63.String
+class WorkspaceRuntimeError extends Schema64.TaggedErrorClass()("WorkspaceRuntimeError", {
+  message: Schema64.String
 }) {
 }
 
@@ -11425,18 +11465,18 @@ var exec = Effect70.fn("WorkspaceRuntime.exec.call")(function* (input) {
 });
 
 // ../runtime/src/workspace/workspace-planner-service.ts
-class WorkspaceRuntimeMissing extends Schema64.TaggedErrorClass()("WorkspaceRuntimeMissing", {
+class WorkspaceRuntimeMissing extends Schema65.TaggedErrorClass()("WorkspaceRuntimeMissing", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspaceLeaseMissingRef extends Schema64.TaggedErrorClass()("WorkspaceLeaseMissingRef", {
+class WorkspaceLeaseMissingRef extends Schema65.TaggedErrorClass()("WorkspaceLeaseMissingRef", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspacePlannerError extends Schema64.TaggedErrorClass()("WorkspacePlannerError", {
-  message: Schema64.String
+class WorkspacePlannerError extends Schema65.TaggedErrorClass()("WorkspacePlannerError", {
+  message: Schema65.String
 }) {
 }
 
@@ -11622,67 +11662,67 @@ var fail = Effect71.fn("WorkspacePlanner.fail.call")(function* (input) {
 });
 
 // ../runtime/src/workflow/execution-workflow.ts
-class ExecutionWorkflowFailed extends Schema65.TaggedErrorClass()("ExecutionWorkflowFailed", {
-  message: Schema65.String
+class ExecutionWorkflowFailed extends Schema66.TaggedErrorClass()("ExecutionWorkflowFailed", {
+  message: Schema66.String
 }) {
 }
-var StartInput = Schema65.Struct({
+var StartInput = Schema66.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   root_address_id: exports_ids_schema.AddressId,
-  session_id: Schema65.optionalKey(exports_ids_schema.SessionId),
-  input: Schema65.optionalKey(Schema65.Array(exports_content_schema.Part)),
+  session_id: Schema66.optionalKey(exports_ids_schema.SessionId),
+  input: Schema66.optionalKey(Schema66.Array(exports_content_schema.Part)),
   event_sequence: exports_execution_schema.ExecutionEventSequence,
   started_at: exports_shared_schema.TimestampMillis,
   completed_at: exports_shared_schema.TimestampMillis,
-  agent_definition_id: Schema65.optionalKey(exports_ids_schema.AgentDefinitionId),
-  agent_definition_revision: Schema65.optionalKey(exports_agent_schema.DefinitionRevision),
-  agent_definition_snapshot: Schema65.optionalKey(exports_agent_schema.Definition),
-  agent_definition_tool_input_schema_digests: Schema65.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
-  wait_id: Schema65.optionalKey(exports_ids_schema.WaitId),
-  resume_tool_call: Schema65.optionalKey(exports_tool_schema.Call),
-  workflow_generation: Schema65.optionalKey(Schema65.Int.check(Schema65.isGreaterThanOrEqualTo(0))),
-  metadata: Schema65.optionalKey(exports_shared_schema.Metadata)
+  agent_definition_id: Schema66.optionalKey(exports_ids_schema.AgentDefinitionId),
+  agent_definition_revision: Schema66.optionalKey(exports_agent_schema.DefinitionRevision),
+  agent_definition_snapshot: Schema66.optionalKey(exports_agent_schema.Definition),
+  agent_definition_tool_input_schema_digests: Schema66.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
+  wait_id: Schema66.optionalKey(exports_ids_schema.WaitId),
+  resume_tool_call: Schema66.optionalKey(exports_tool_schema.Call),
+  workflow_generation: Schema66.optionalKey(Schema66.Int.check(Schema66.isGreaterThanOrEqualTo(0))),
+  metadata: Schema66.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartInput" });
-var WaitSignalState = Schema65.Literals(["resolved", "timed_out", "cancelled"]).annotate({
+var WaitSignalState = Schema66.Literals(["resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.ExecutionWorkflow.WaitSignalState"
 });
-var WaitSignal = Schema65.Struct({
+var WaitSignal = Schema66.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitSignalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionWorkflow.WaitSignal" });
-var SignalWaitInput = Schema65.Struct({
-  workflow_execution_id: Schema65.String,
+var SignalWaitInput = Schema66.Struct({
+  workflow_execution_id: Schema66.String,
   wait_id: exports_ids_schema.WaitId,
   state: WaitSignalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionWorkflow.SignalWaitInput" });
-var CancelExecutionInput = Schema65.Struct({
+var CancelExecutionInput = Schema66.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   cancelled_at: exports_shared_schema.TimestampMillis,
-  reason: Schema65.optionalKey(Schema65.String)
+  reason: Schema66.optionalKey(Schema66.String)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.CancelExecutionInput" });
-var CancelExecutionResult = Schema65.Struct({
+var CancelExecutionResult = Schema66.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus
 }).annotate({ identifier: "Relay.ExecutionWorkflow.CancelExecutionResult" });
-var WaitSnapshot = Schema65.Struct({
+var WaitSnapshot = Schema66.Struct({
   id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
-  envelope_id: Schema65.optionalKey(exports_ids_schema.EnvelopeId),
+  envelope_id: Schema66.optionalKey(exports_ids_schema.EnvelopeId),
   mode: exports_envelope_schema.WaitMode,
-  correlation_key: Schema65.optionalKey(Schema65.String),
-  state: Schema65.Literals(["open", "resolved", "timed_out", "cancelled"]),
+  correlation_key: Schema66.optionalKey(Schema66.String),
+  state: Schema66.Literals(["open", "resolved", "timed_out", "cancelled"]),
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
-  resolved_at: Schema65.optionalKey(exports_shared_schema.TimestampMillis)
+  resolved_at: Schema66.optionalKey(exports_shared_schema.TimestampMillis)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.WaitSnapshot" });
-var StartResult = Schema65.Struct({
+var StartResult = Schema66.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus,
-  wait_id: Schema65.optionalKey(exports_ids_schema.WaitId),
-  wait_state: Schema65.optionalKey(Schema65.Literals(["resolved", "timed_out", "cancelled"])),
-  metadata: Schema65.optionalKey(exports_shared_schema.Metadata)
+  wait_id: Schema66.optionalKey(exports_ids_schema.WaitId),
+  wait_state: Schema66.optionalKey(Schema66.Literals(["resolved", "timed_out", "cancelled"])),
+  metadata: Schema66.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartResult" });
 var StartExecutionWorkflowName = "Relay/Execution/Start";
 var ActivityNames = {
@@ -11896,7 +11936,7 @@ var cancelExecution = (input, turn, reason) => Activity.make({
 });
 var loadCancellationRequested = (input, turn) => Activity.make({
   name: ActivityNames.checkCancel(turn),
-  success: Schema65.Boolean,
+  success: Schema66.Boolean,
   error: ExecutionWorkflowFailed,
   execute: Effect72.gen(function* () {
     const repository = yield* exports_execution_repository.Service;
@@ -11906,7 +11946,7 @@ var loadCancellationRequested = (input, turn) => Activity.make({
 });
 var loadWait = (name, waitId) => Activity.make({
   name,
-  success: Schema65.UndefinedOr(WaitSnapshot),
+  success: Schema66.UndefinedOr(WaitSnapshot),
   error: ExecutionWorkflowFailed,
   execute: get11(waitId).pipe(Effect72.map((record2) => record2 === undefined ? undefined : toWaitSnapshot(record2)), Effect72.mapError(mapWaitError2))
 });
@@ -11997,7 +12037,7 @@ var compactionForStart = Effect72.fn("ExecutionWorkflow.compactionForStart")(fun
     ...keepRecentTokens === undefined ? {} : { keepRecentTokens }
   };
 });
-var decodeMemorySubject = (value) => typeof value === "string" ? Schema65.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(value).pipe(Effect72.mapError(() => new ExecutionWorkflowFailed({ message: `Invalid memory_subject_id metadata value: ${value}` }))) : Effect72.fail(new ExecutionWorkflowFailed({ message: "memory_subject_id metadata value must be a string" }));
+var decodeMemorySubject = (value) => typeof value === "string" ? Schema66.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(value).pipe(Effect72.mapError(() => new ExecutionWorkflowFailed({ message: `Invalid memory_subject_id metadata value: ${value}` }))) : Effect72.fail(new ExecutionWorkflowFailed({ message: "memory_subject_id metadata value must be a string" }));
 var memorySubjectForStart = Effect72.fn("ExecutionWorkflow.memorySubjectForStart")(function* (input) {
   const executionSubject = memorySubjectFromMetadata(input.metadata);
   if (executionSubject !== undefined)
@@ -12015,7 +12055,7 @@ var steeringEnabledForStart = (input) => {
 var nextEventSequence4 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect72.map((max3) => max3 === undefined ? 0 : max3 + 1), Effect72.mapError(mapEventLogError6));
 var ensureWorkspace = (input) => Activity.make({
   name: ActivityNames.ensureWorkspace,
-  success: Schema65.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema66.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: Effect72.gen(function* () {
     if (input.agent_definition_snapshot === undefined)
@@ -12032,19 +12072,19 @@ var ensureWorkspace = (input) => Activity.make({
 });
 var suspendWorkspace = (input, key2) => Activity.make({
   name: ActivityNames.suspendWorkspace(key2),
-  success: Schema65.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema66.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: suspend2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect72.mapError(mapWorkspaceError))
 });
 var resumeWorkspace = (input, key2) => Activity.make({
   name: ActivityNames.resumeWorkspace(key2),
-  success: Schema65.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema66.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: resume2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect72.map((plan2) => plan2?.lease), Effect72.mapError(mapWorkspaceError))
 });
 var releaseWorkspace = (input) => Activity.make({
   name: ActivityNames.releaseWorkspace,
-  success: Schema65.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema66.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: release2({ executionId: input.execution_id, now: input.completed_at }).pipe(Effect72.mapError(mapWorkspaceError))
 });
@@ -12145,7 +12185,7 @@ var childDispatchContext = (input) => {
 };
 var loadChildCancellationRequested = (input) => Activity.make({
   name: ActivityNames.checkQueuedChildCancellation,
-  success: Schema65.Boolean,
+  success: Schema66.Boolean,
   error: ExecutionWorkflowFailed,
   execute: Effect72.gen(function* () {
     const context = childDispatchContext(input);
@@ -12157,7 +12197,7 @@ var loadChildCancellationRequested = (input) => Activity.make({
 });
 var notifyParentActivity = (input, context, status, output) => Activity.make({
   name: ActivityNames.notifyParent(status),
-  success: Schema65.Void,
+  success: Schema66.Void,
   error: ExecutionWorkflowFailed,
   execute: Effect72.gen(function* () {
     const notifier = yield* Effect72.serviceOption(Service41);
@@ -12210,7 +12250,7 @@ var waitIdFromExecution = (execution) => {
 };
 var pendingToolCallFromExecution = (execution) => {
   const pending = execution.metadata?.pending_tool_call;
-  return Schema65.decodeUnknownOption(exports_tool_schema.Call)(pending).pipe(Option26.getOrUndefined);
+  return Schema66.decodeUnknownOption(exports_tool_schema.Call)(pending).pipe(Option26.getOrUndefined);
 };
 var finishCancelledWait = Effect72.fn("ExecutionWorkflow.finishCancelledWait")(function* (startInput, turn, waitId) {
   const cancelled = yield* cancelExecution(startInput, turn, "wait cancelled");
@@ -12424,7 +12464,7 @@ var Start = Rpc.make("start", {
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var SignalWait = Rpc.make("signalWait", {
   payload: SignalWaitInput,
-  success: Schema66.Void,
+  success: Schema67.Void,
   error: ExecutionWorkflowFailed
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var Cancel = Rpc.make("cancel", {
@@ -12452,26 +12492,26 @@ __export(exports_envelope_service, {
   EnvelopeRouteDeferred: () => EnvelopeRouteDeferred,
   EnvelopeAddressNotFound: () => EnvelopeAddressNotFound
 });
-import { Context as Context59, Effect as Effect73, Layer as Layer66, Schema as Schema67 } from "effect";
-class EnvelopeAddressNotFound extends Schema67.TaggedErrorClass()("EnvelopeAddressNotFound", {
+import { Context as Context59, Effect as Effect73, Layer as Layer66, Schema as Schema68 } from "effect";
+class EnvelopeAddressNotFound extends Schema68.TaggedErrorClass()("EnvelopeAddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class EnvelopeRouteUnavailable extends Schema67.TaggedErrorClass()("EnvelopeRouteUnavailable", {
+class EnvelopeRouteUnavailable extends Schema68.TaggedErrorClass()("EnvelopeRouteUnavailable", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema67.String
+  route_key: Schema68.String
 }) {
 }
 
-class EnvelopeRouteDeferred extends Schema67.TaggedErrorClass()("EnvelopeRouteDeferred", {
+class EnvelopeRouteDeferred extends Schema68.TaggedErrorClass()("EnvelopeRouteDeferred", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema67.String
+  route_key: Schema68.String
 }) {
 }
 
-class EnvelopeServiceError extends Schema67.TaggedErrorClass()("EnvelopeServiceError", {
-  message: Schema67.String
+class EnvelopeServiceError extends Schema68.TaggedErrorClass()("EnvelopeServiceError", {
+  message: Schema68.String
 }) {
 }
 
@@ -12629,7 +12669,7 @@ __export(exports_runner_runtime_service, {
   DatabaseMode: () => DatabaseMode,
   ClusterConfigMismatch: () => ClusterConfigMismatch
 });
-import { Config as Config5, Context as Context61, Crypto as Crypto4, Duration as Duration5, Effect as Effect76, Layer as Layer68, Option as Option27, Schema as Schema69, Stream as Stream9 } from "effect";
+import { Config as Config5, Context as Context61, Crypto as Crypto4, Duration as Duration5, Effect as Effect76, Layer as Layer68, Option as Option27, Schema as Schema70, Stream as Stream9 } from "effect";
 import {
   ClusterWorkflowEngine,
   HttpRunner,
@@ -12666,7 +12706,7 @@ __export(exports_scheduler_service, {
   SchedulerError: () => SchedulerError,
   ScheduleCronInvalid: () => ScheduleCronInvalid
 });
-import { Clock as Clock9, Config as Config4, Context as Context60, Cron, Duration as Duration4, Effect as Effect75, Layer as Layer67, Random, Result as Result3, Schema as Schema68 } from "effect";
+import { Clock as Clock9, Config as Config4, Context as Context60, Cron, Duration as Duration4, Effect as Effect75, Layer as Layer67, Random, Result as Result3, Schema as Schema69 } from "effect";
 
 // ../runtime/src/wait/wait-signal.ts
 var exports_wait_signal = {};
@@ -12686,14 +12726,14 @@ var signalWorkflowWait = Effect74.fn("WaitSignal.signalWorkflowWait")(function*
 });
 
 // ../runtime/src/schedule/scheduler-service.ts
-class SchedulerError extends Schema68.TaggedErrorClass()("SchedulerError", {
-  message: Schema68.String
+class SchedulerError extends Schema69.TaggedErrorClass()("SchedulerError", {
+  message: Schema69.String
 }) {
 }
 
-class ScheduleCronInvalid extends Schema68.TaggedErrorClass()("ScheduleCronInvalid", {
-  cron_expr: Schema68.String,
-  message: Schema68.String
+class ScheduleCronInvalid extends Schema69.TaggedErrorClass()("ScheduleCronInvalid", {
+  cron_expr: Schema69.String,
+  message: Schema69.String
 }) {
 }
 
@@ -12844,25 +12884,25 @@ var runOnce = Effect75.fn("SchedulerService.runOnce.call")(function* () {
 });
 
 // ../runtime/src/runner/runner-runtime-service.ts
-var DatabaseMode = Schema69.Literals(["sql", "memory"]).annotate({
+var DatabaseMode = Schema70.Literals(["sql", "memory"]).annotate({
   identifier: "Relay.RunnerRuntime.DatabaseMode"
 });
-var ReadinessStatus = Schema69.Struct({
+var ReadinessStatus = Schema70.Struct({
   database: DatabaseMode,
-  cluster: Schema69.Literal("ready"),
-  workflow: Schema69.Literals(["ready", "client"]),
-  executionEntity: Schema69.Literals(["registered", "client"])
+  cluster: Schema70.Literal("ready"),
+  workflow: Schema70.Literals(["ready", "client"]),
+  executionEntity: Schema70.Literals(["registered", "client"])
 }).annotate({ identifier: "Relay.RunnerRuntime.ReadinessStatus" });
 
-class RunnerRuntimeError extends Schema69.TaggedErrorClass()("RunnerRuntimeError", {
-  message: Schema69.String
+class RunnerRuntimeError extends Schema70.TaggedErrorClass()("RunnerRuntimeError", {
+  message: Schema70.String
 }) {
 }
 
-class ClusterConfigMismatch extends Schema69.TaggedErrorClass()("ClusterConfigMismatch", {
-  field: Schema69.String,
-  expected: Schema69.String,
-  actual: Schema69.String
+class ClusterConfigMismatch extends Schema70.TaggedErrorClass()("ClusterConfigMismatch", {
+  field: Schema70.String,
+  expected: Schema70.String,
+  actual: Schema70.String
 }) {
 }
 
@@ -12876,7 +12916,7 @@ var memoryClusterLayer = Sharding.layer.pipe(Layer68.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(Schema69.String), "RELAY_CLUSTER_SHARD_GROUPS").pipe(Config5.withDefault(["default", "execution"]));
+var clusterShardGroups = Config5.schema(Config5.Array(Schema70.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 = () => Layer68.effect(ShardingConfig2.ShardingConfig, Effect76.gen(function* () {
@@ -13180,51 +13220,51 @@ __export(exports_activity_version_registry, {
   ActivityManifestChange: () => ActivityManifestChange,
   ActivityManifest: () => ActivityManifest
 });
-import { Crypto as Crypto5, Effect as Effect77, Schema as Schema70 } from "effect";
+import { Crypto as Crypto5, Effect as Effect77, Schema as Schema71 } from "effect";
 var generatedFrom = "@relayfx/runtime/ExecutionWorkflow";
-var ActivityManifestEntry = Schema70.Struct({
-  name: Schema70.String,
-  signature_hash: Schema70.String
+var ActivityManifestEntry = Schema71.Struct({
+  name: Schema71.String,
+  signature_hash: Schema71.String
 }).annotate({ identifier: "Relay.ActivityManifestEntry" });
-var ActivityManifest = Schema70.Struct({
-  version: Schema70.Literal(1),
-  generated_from: Schema70.String,
-  hash_algorithm: Schema70.Literal("sha256-json-schema-v1"),
-  activities: Schema70.Array(ActivityManifestEntry)
+var ActivityManifest = Schema71.Struct({
+  version: Schema71.Literal(1),
+  generated_from: Schema71.String,
+  hash_algorithm: Schema71.Literal("sha256-json-schema-v1"),
+  activities: Schema71.Array(ActivityManifestEntry)
 }).annotate({ identifier: "Relay.ActivityManifest" });
-var ActivityManifestChange = Schema70.Struct({
-  type: Schema70.Literals(["removed", "changed", "added"]),
-  name: Schema70.String,
-  baseline_hash: Schema70.optionalKey(Schema70.String),
-  current_hash: Schema70.optionalKey(Schema70.String)
+var ActivityManifestChange = Schema71.Struct({
+  type: Schema71.Literals(["removed", "changed", "added"]),
+  name: Schema71.String,
+  baseline_hash: Schema71.optionalKey(Schema71.String),
+  current_hash: Schema71.optionalKey(Schema71.String)
 }).annotate({ identifier: "Relay.ActivityManifestChange" });
-var ActivityManifestGuardResult = Schema70.Struct({
-  status: Schema70.Literals(["pass", "fail"]),
-  waiting_executions: Schema70.Int.check(Schema70.isGreaterThanOrEqualTo(0)),
-  breaking_changes: Schema70.Array(ActivityManifestChange),
-  additive_changes: Schema70.Array(ActivityManifestChange)
+var ActivityManifestGuardResult = Schema71.Struct({
+  status: Schema71.Literals(["pass", "fail"]),
+  waiting_executions: Schema71.Int.check(Schema71.isGreaterThanOrEqualTo(0)),
+  breaking_changes: Schema71.Array(ActivityManifestChange),
+  additive_changes: Schema71.Array(ActivityManifestChange)
 }).annotate({ identifier: "Relay.ActivityManifestGuardResult" });
 
-class ActivityManifestGuardFailed extends Schema70.TaggedErrorClass()("ActivityManifestGuardFailed", {
-  message: Schema70.String,
+class ActivityManifestGuardFailed extends Schema71.TaggedErrorClass()("ActivityManifestGuardFailed", {
+  message: Schema71.String,
   result: ActivityManifestGuardResult
 }) {
 }
-var TurnInput = Schema70.Struct({
+var TurnInput = Schema71.Struct({
   start: StartInput,
-  turn: Schema70.Int.check(Schema70.isGreaterThanOrEqualTo(0))
+  turn: Schema71.Int.check(Schema71.isGreaterThanOrEqualTo(0))
 });
-var WaitIdInput = Schema70.Struct({
+var WaitIdInput = Schema71.Struct({
   wait_id: exports_ids_schema.WaitId
 });
-var WorkspaceKeyInput = Schema70.Struct({
+var WorkspaceKeyInput = Schema71.Struct({
   start: StartInput,
-  key: Schema70.String
+  key: Schema71.String
 });
 var contracts = [
   {
     name: ActivityNameTemplates.resolveLocalAgent,
-    input: Schema70.Struct({ address_id: exports_ids_schema.AddressId }),
+    input: Schema71.Struct({ address_id: exports_ids_schema.AddressId }),
     success: LocalAgentTarget,
     error: ExecutionWorkflowFailed
   },
@@ -13236,66 +13276,66 @@ var contracts = [
   },
   {
     name: ActivityNameTemplates.cancel,
-    input: Schema70.Struct({ start: StartInput, turn: Schema70.Int, reason: Schema70.String }),
+    input: Schema71.Struct({ start: StartInput, turn: Schema71.Int, reason: Schema71.String }),
     success: exports_execution_schema.Execution,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.checkCancel,
     input: TurnInput,
-    success: Schema70.Boolean,
+    success: Schema71.Boolean,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.loadWaitBeforeSleep,
     input: WaitIdInput,
-    success: Schema70.UndefinedOr(WaitSnapshot),
+    success: Schema71.UndefinedOr(WaitSnapshot),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.loadWaitAfterWake,
     input: WaitIdInput,
-    success: Schema70.UndefinedOr(WaitSnapshot),
+    success: Schema71.UndefinedOr(WaitSnapshot),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.markWaiting,
-    input: Schema70.Struct({ start: StartInput, wait: WaitSnapshot }),
+    input: Schema71.Struct({ start: StartInput, wait: WaitSnapshot }),
     success: exports_execution_schema.Execution,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.ensureWorkspace,
     input: StartInput,
-    success: Schema70.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+    success: Schema71.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.suspendWorkspace,
     input: WorkspaceKeyInput,
-    success: Schema70.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+    success: Schema71.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.resumeWorkspace,
     input: WorkspaceKeyInput,
-    success: Schema70.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+    success: Schema71.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.releaseWorkspace,
     input: StartInput,
-    success: Schema70.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+    success: Schema71.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.complete,
-    input: Schema70.Struct({
+    input: Schema71.Struct({
       start: StartInput,
-      turn: Schema70.Int.check(Schema70.isGreaterThanOrEqualTo(0)),
-      wait_id: Schema70.optionalKey(exports_ids_schema.WaitId),
-      wait_state: Schema70.optionalKey(WaitSignalState),
-      pending_tool_call: Schema70.optionalKey(exports_tool_schema.Call)
+      turn: Schema71.Int.check(Schema71.isGreaterThanOrEqualTo(0)),
+      wait_id: Schema71.optionalKey(exports_ids_schema.WaitId),
+      wait_state: Schema71.optionalKey(WaitSignalState),
+      pending_tool_call: Schema71.optionalKey(exports_tool_schema.Call)
     }),
     success: exports_execution_schema.Execution,
     error: ExecutionWorkflowFailed
@@ -13303,24 +13343,24 @@ var contracts = [
   {
     name: ActivityNameTemplates.checkQueuedChildCancellation,
     input: StartInput,
-    success: Schema70.Boolean,
+    success: Schema71.Boolean,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.notifyParent,
-    input: Schema70.Struct({
+    input: Schema71.Struct({
       start: StartInput,
       status: ChildTerminalStatus,
-      output: Schema70.Array(exports_content_schema.Part)
+      output: Schema71.Array(exports_content_schema.Part)
     }),
-    success: Schema70.Void,
+    success: Schema71.Void,
     error: ExecutionWorkflowFailed
   },
   {
     name: ActivityNameTemplates.continueAsNew,
-    input: Schema70.Struct({
+    input: Schema71.Struct({
       start: StartInput,
-      turn: Schema70.Int.check(Schema70.isGreaterThanOrEqualTo(0)),
+      turn: Schema71.Int.check(Schema71.isGreaterThanOrEqualTo(0)),
       wait_id: exports_ids_schema.WaitId,
       pending_tool_call: exports_tool_schema.Call
     }),
@@ -13328,7 +13368,7 @@ var contracts = [
     error: ExecutionWorkflowFailed
   }
 ];
-var schemaJson = (schema) => Schema70.decodeUnknownSync(exports_shared_schema.JsonValue)(Schema70.toJsonSchemaDocument(schema));
+var schemaJson = (schema) => Schema71.decodeUnknownSync(exports_shared_schema.JsonValue)(Schema71.toJsonSchemaDocument(schema));
 var canonical = (value) => {
   if (value === null || typeof value !== "object")
     return value;
@@ -13419,11 +13459,11 @@ var guard = Effect77.fn("ActivityVersionRegistry.guard")(function* (input) {
   }));
 });
 // src/client.ts
-import { Clock as Clock10, Context as Context62, Effect as Effect78, Layer as Layer69, Option as Option28, Schema as Schema71, SchemaGetter, SchemaIssue, Stream as Stream10 } from "effect";
+import { Clock as Clock10, Context as Context62, Effect as Effect78, Layer as Layer69, Option as Option28, Schema as Schema72, SchemaGetter, SchemaIssue, Stream as Stream10 } from "effect";
 import { EntityId, ShardId, Sharding as Sharding2, ShardingConfig as ShardingConfig3 } from "effect/unstable/cluster";
 
-class ClientError extends Schema71.TaggedErrorClass()("ClientError", {
-  message: Schema71.String
+class ClientError extends Schema72.TaggedErrorClass()("ClientError", {
+  message: Schema72.String
 }) {
 }
 
@@ -13455,11 +13495,11 @@ var decodeCursorFields = (wire) => Effect78.gen(function* () {
     return yield* Effect78.fail(malformedCursor(wire));
   return { updatedAt, id: decoded.slice(separator + 1) };
 });
-var ExecutionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema71.decodeTo(Schema71.Struct({ updatedAt: Schema71.Int, id: exports_ids_schema.ExecutionId }), {
+var ExecutionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema72.decodeTo(Schema72.Struct({ updatedAt: Schema72.Int, id: exports_ids_schema.ExecutionId }), {
   decode: SchemaGetter.transformOrFail((wire) => decodeCursorFields(wire)),
   encode: SchemaGetter.transform((cursor) => globalThis.btoa(`${cursor.updatedAt}:${cursor.id}`))
 })).annotate({ identifier: "Relay.Client.ExecutionCursor" });
-var SessionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema71.decodeTo(Schema71.Struct({ updatedAt: Schema71.Int, id: exports_ids_schema.SessionId }), {
+var SessionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema72.decodeTo(Schema72.Struct({ updatedAt: Schema72.Int, id: exports_ids_schema.SessionId }), {
   decode: SchemaGetter.transformOrFail((wire) => decodeCursorFields(wire)),
   encode: SchemaGetter.transform((cursor) => globalThis.btoa(`${cursor.updatedAt}:${cursor.id}`))
 })).annotate({ identifier: "Relay.Client.SessionCursor" });
@@ -13765,27 +13805,27 @@ var layerFromRuntime = Layer69.effect(Service49, Effect78.gen(function* () {
       return records.map(toWaitView);
     }),
     listExecutions: Effect78.fn("Client.runtime.listExecutions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema71.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect78.mapError(toClientError));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema72.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect78.mapError(toClientError));
       const result = yield* executionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.status === undefined ? {} : { status: input.status },
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
       }).pipe(Effect78.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema71.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect78.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema72.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect78.mapError(toClientError));
       return {
         records: result.records.map(toConversationSummary),
         ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
       };
     }),
     listSessions: Effect78.fn("Client.runtime.listSessions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema71.decodeEffect(SessionCursorFromString)(input.cursor).pipe(Effect78.mapError(toClientError));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema72.decodeEffect(SessionCursorFromString)(input.cursor).pipe(Effect78.mapError(toClientError));
       const result = yield* sessionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
       }).pipe(Effect78.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema71.encodeEffect(SessionCursorFromString)(result.nextCursor).pipe(Effect78.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema72.encodeEffect(SessionCursorFromString)(result.nextCursor).pipe(Effect78.mapError(toClientError));
       return {
         records: result.records.map(toSessionSummary),
         ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
@@ -13795,13 +13835,13 @@ var layerFromRuntime = Layer69.effect(Service49, Effect78.gen(function* () {
       const session = yield* sessionRepository.get(input.session_id).pipe(Effect78.mapError(toClientError));
       if (session === undefined)
         return yield* new ClientError({ message: `Session not found: ${input.session_id}` });
-      const cursor = input.cursor === undefined ? undefined : yield* Schema71.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect78.mapError(toClientError));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema72.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect78.mapError(toClientError));
       const result = yield* executionRepository.list({
         sessionId: input.session_id,
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
       }).pipe(Effect78.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema71.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect78.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema72.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect78.mapError(toClientError));
       return {
         session: toSessionSummary(session),
         executions: result.records.map(toConversationSummary),
@@ -14210,92 +14250,92 @@ __export(exports_operation, {
   CancelExecutionAccepted: () => CancelExecutionAccepted,
   AckEnvelopeReadyInput: () => AckEnvelopeReadyInput
 });
-import { Schema as Schema72 } from "effect";
-var StartExecutionInput = Schema72.Struct({
+import { Schema as Schema73 } from "effect";
+var StartExecutionInput = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   root_address_id: exports_ids_schema.AddressId,
-  session_id: Schema72.optionalKey(exports_ids_schema.SessionId),
-  input: Schema72.optionalKey(Schema72.Array(exports_content_schema.Part)),
+  session_id: Schema73.optionalKey(exports_ids_schema.SessionId),
+  input: Schema73.optionalKey(Schema73.Array(exports_content_schema.Part)),
   event_sequence: exports_execution_schema.ExecutionEventSequence,
   started_at: exports_shared_schema.TimestampMillis,
   completed_at: exports_shared_schema.TimestampMillis,
-  agent_definition_id: Schema72.optionalKey(exports_ids_schema.AgentDefinitionId),
-  agent_definition_revision: Schema72.optionalKey(exports_agent_schema.DefinitionRevision),
-  agent_definition_snapshot: Schema72.optionalKey(exports_agent_schema.Definition),
-  agent_definition_tool_input_schema_digests: Schema72.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
-  wait_id: Schema72.optionalKey(exports_ids_schema.WaitId),
-  metadata: Schema72.optionalKey(exports_shared_schema.Metadata)
+  agent_definition_id: Schema73.optionalKey(exports_ids_schema.AgentDefinitionId),
+  agent_definition_revision: Schema73.optionalKey(exports_agent_schema.DefinitionRevision),
+  agent_definition_snapshot: Schema73.optionalKey(exports_agent_schema.Definition),
+  agent_definition_tool_input_schema_digests: Schema73.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
+  wait_id: Schema73.optionalKey(exports_ids_schema.WaitId),
+  metadata: Schema73.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.StartExecutionInput" });
-var StartExecutionResult = Schema72.Struct({
+var StartExecutionResult = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus,
-  metadata: Schema72.optionalKey(exports_shared_schema.Metadata)
+  metadata: Schema73.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.StartExecutionResult" });
-var StreamExecutionInput = Schema72.Struct({
+var StreamExecutionInput = Schema73.Struct({
   execution_id: exports_execution_schema.Execution.fields.id,
-  after_cursor: Schema72.optionalKey(exports_shared_schema.NonEmptyString),
-  limit: Schema72.optionalKey(Schema72.Int.check(Schema72.isGreaterThan(0)))
+  after_cursor: Schema73.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema73.optionalKey(Schema73.Int.check(Schema73.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.StreamExecutionInput" });
-var WaitTerminalState = Schema72.Literals(["resolved", "timed_out", "cancelled"]).annotate({
+var WaitTerminalState = Schema73.Literals(["resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Operation.WaitTerminalState"
 });
-var CancelExecutionInput2 = Schema72.Struct({
+var CancelExecutionInput2 = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   cancelled_at: exports_shared_schema.TimestampMillis,
-  reason: Schema72.optionalKey(Schema72.String)
+  reason: Schema73.optionalKey(Schema73.String)
 }).annotate({ identifier: "Relay.Operation.CancelExecutionInput" });
-var CancelExecutionAccepted = Schema72.Struct({
+var CancelExecutionAccepted = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus
 }).annotate({ identifier: "Relay.Operation.CancelExecutionAccepted" });
-var SteeringKind = Schema72.Literals(["steering", "follow_up"]).annotate({
+var SteeringKind = Schema73.Literals(["steering", "follow_up"]).annotate({
   identifier: "Relay.Operation.SteeringKind"
 });
-var SteerInput = Schema72.Struct({
+var SteerInput = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   kind: SteeringKind,
-  content: Schema72.Array(exports_content_schema.Part),
+  content: Schema73.Array(exports_content_schema.Part),
   created_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.SteerInput" });
-var SteerAccepted = Schema72.Struct({
+var SteerAccepted = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   kind: SteeringKind,
-  sequence: Schema72.Int.check(Schema72.isGreaterThanOrEqualTo(0))
+  sequence: Schema73.Int.check(Schema73.isGreaterThanOrEqualTo(0))
 }).annotate({ identifier: "Relay.Operation.SteerAccepted" });
-var WakeInput = Schema72.Struct({
+var WakeInput = Schema73.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitTerminalState,
   signaled_at: exports_shared_schema.TimestampMillis,
-  from: Schema72.optionalKey(exports_ids_schema.AddressId),
-  content: Schema72.optionalKey(Schema72.Array(exports_content_schema.Part)),
-  correlation_key: Schema72.optionalKey(Schema72.String),
-  metadata: Schema72.optionalKey(exports_shared_schema.Metadata)
+  from: Schema73.optionalKey(exports_ids_schema.AddressId),
+  content: Schema73.optionalKey(Schema73.Array(exports_content_schema.Part)),
+  correlation_key: Schema73.optionalKey(Schema73.String),
+  metadata: Schema73.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.WakeInput" });
-var WakeAccepted = Schema72.Struct({
+var WakeAccepted = Schema73.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitTerminalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.WakeAccepted" });
-var WaitState2 = Schema72.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
+var WaitState2 = Schema73.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Operation.WaitState"
 });
-var ListWaitsInput = Schema72.Struct({
-  state: Schema72.optionalKey(WaitState2),
-  execution_id: Schema72.optionalKey(exports_ids_schema.ExecutionId),
-  limit: Schema72.optionalKey(Schema72.Int.check(Schema72.isGreaterThan(0)))
+var ListWaitsInput = Schema73.Struct({
+  state: Schema73.optionalKey(WaitState2),
+  execution_id: Schema73.optionalKey(exports_ids_schema.ExecutionId),
+  limit: Schema73.optionalKey(Schema73.Int.check(Schema73.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.ListWaitsInput" });
-var WaitView = Schema72.Struct({
+var WaitView = Schema73.Struct({
   wait_id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
-  envelope_id: Schema72.optionalKey(exports_ids_schema.EnvelopeId),
+  envelope_id: Schema73.optionalKey(exports_ids_schema.EnvelopeId),
   mode: exports_envelope_schema.WaitMode,
-  correlation_key: Schema72.optionalKey(Schema72.String),
+  correlation_key: Schema73.optionalKey(Schema73.String),
   state: WaitState2,
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
-  resolved_at: Schema72.optionalKey(exports_shared_schema.TimestampMillis)
+  resolved_at: Schema73.optionalKey(exports_shared_schema.TimestampMillis)
 }).annotate({ identifier: "Relay.Operation.WaitView" });
-var PendingToolApproval = Schema72.Struct({
+var PendingToolApproval = Schema73.Struct({
   wait_id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
   tool_call_id: exports_ids_schema.ToolCallId,
@@ -14303,169 +14343,169 @@ var PendingToolApproval = Schema72.Struct({
   input: exports_shared_schema.JsonValue,
   requested_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.PendingToolApproval" });
-var ListPendingApprovalsInput = Schema72.Struct({
+var ListPendingApprovalsInput = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId
 }).annotate({ identifier: "Relay.Operation.ListPendingApprovalsInput" });
-var PendingToolApprovalList = Schema72.Struct({
-  approvals: Schema72.Array(PendingToolApproval)
+var PendingToolApprovalList = Schema73.Struct({
+  approvals: Schema73.Array(PendingToolApproval)
 }).annotate({ identifier: "Relay.Operation.PendingToolApprovalList" });
-var ResolveToolApprovalInput = Schema72.Struct({
+var ResolveToolApprovalInput = Schema73.Struct({
   wait_id: exports_ids_schema.WaitId,
-  approved: Schema72.Boolean,
-  comment: Schema72.optionalKey(Schema72.String),
+  approved: Schema73.Boolean,
+  comment: Schema73.optionalKey(Schema73.String),
   resolved_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.ResolveToolApprovalInput" });
-var PermissionAnswer = Schema72.Literals(["Approved", "Denied", "Always"]).annotate({
+var PermissionAnswer = Schema73.Literals(["Approved", "Denied", "Always"]).annotate({
   identifier: "Relay.Operation.PermissionAnswer"
 });
-var ResolvePermissionInput = Schema72.Struct({
+var ResolvePermissionInput = Schema73.Struct({
   wait_id: exports_ids_schema.WaitId,
   answer: PermissionAnswer,
-  reason: Schema72.optionalKey(Schema72.String),
+  reason: Schema73.optionalKey(Schema73.String),
   resolved_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.ResolvePermissionInput" });
-var SubmitInboundEnvelopeInput = Schema72.Struct({
+var SubmitInboundEnvelopeInput = Schema73.Struct({
   envelope: exports_envelope_schema.SendInput,
   wake: WakeInput
 }).annotate({ identifier: "Relay.Operation.SubmitInboundEnvelopeInput" });
-var SubmitInboundEnvelopeAccepted = Schema72.Struct({
+var SubmitInboundEnvelopeAccepted = Schema73.Struct({
   envelope: exports_envelope_schema.EnvelopeAccepted,
   wake: WakeAccepted
 }).annotate({ identifier: "Relay.Operation.SubmitInboundEnvelopeAccepted" });
-var ClaimEnvelopeReadyInput = Schema72.Struct({
+var ClaimEnvelopeReadyInput = Schema73.Struct({
   route_type: exports_address_schema.RouteKind,
-  route_key: Schema72.optionalKey(Schema72.String),
+  route_key: Schema73.optionalKey(Schema73.String),
   worker_id: exports_shared_schema.NonEmptyString,
   now: exports_shared_schema.TimestampMillis,
   claim_expires_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.ClaimEnvelopeReadyInput" });
-var EnvelopeReadyLease = Schema72.Struct({
+var EnvelopeReadyLease = Schema73.Struct({
   ready: exports_envelope_schema.EnvelopeReady,
   worker_id: exports_shared_schema.NonEmptyString,
   claim_expires_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.EnvelopeReadyLease" });
-var AckEnvelopeReadyInput = Schema72.Struct({
+var AckEnvelopeReadyInput = Schema73.Struct({
   envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
   worker_id: exports_shared_schema.NonEmptyString,
   acknowledged_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.AckEnvelopeReadyInput" });
-var EnvelopeReadyAcked = Schema72.Struct({
+var EnvelopeReadyAcked = Schema73.Struct({
   envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
-  state: Schema72.Literal("acknowledged"),
+  state: Schema73.Literal("acknowledged"),
   acknowledged_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.EnvelopeReadyAcked" });
-var ReleaseEnvelopeReadyInput = Schema72.Struct({
+var ReleaseEnvelopeReadyInput = Schema73.Struct({
   envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
   worker_id: exports_shared_schema.NonEmptyString,
   next_available_at: exports_shared_schema.TimestampMillis,
-  error: Schema72.optionalKey(Schema72.String)
+  error: Schema73.optionalKey(Schema73.String)
 }).annotate({ identifier: "Relay.Operation.ReleaseEnvelopeReadyInput" });
-var EnvelopeReadyReleased = Schema72.Struct({
+var EnvelopeReadyReleased = Schema73.Struct({
   envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
-  state: Schema72.Literal("ready"),
+  state: Schema73.Literal("ready"),
   next_available_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.EnvelopeReadyReleased" });
-var CreateScheduleInput = Schema72.Struct({
+var CreateScheduleInput = Schema73.Struct({
   schedule_id: exports_ids_schema.ScheduleId,
   kind: exports_schedule_schema.ScheduleKind,
   target_kind: exports_schedule_schema.ScheduleTargetKind,
-  address_id: Schema72.optionalKey(exports_ids_schema.AddressId),
-  wait_id: Schema72.optionalKey(exports_ids_schema.WaitId),
-  cron_expr: Schema72.optionalKey(exports_shared_schema.NonEmptyString),
-  input: Schema72.optionalKey(Schema72.Array(exports_content_schema.Part)),
+  address_id: Schema73.optionalKey(exports_ids_schema.AddressId),
+  wait_id: Schema73.optionalKey(exports_ids_schema.WaitId),
+  cron_expr: Schema73.optionalKey(exports_shared_schema.NonEmptyString),
+  input: Schema73.optionalKey(Schema73.Array(exports_content_schema.Part)),
   next_run_at: exports_shared_schema.TimestampMillis,
-  idempotency_key: Schema72.optionalKey(exports_shared_schema.NonEmptyString),
-  metadata: Schema72.optionalKey(exports_shared_schema.Metadata)
+  idempotency_key: Schema73.optionalKey(exports_shared_schema.NonEmptyString),
+  metadata: Schema73.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.CreateScheduleInput" });
-var CreateScheduleResult = Schema72.Struct({
+var CreateScheduleResult = Schema73.Struct({
   schedule: exports_schedule_schema.ScheduleRecord
 }).annotate({ identifier: "Relay.Operation.CreateScheduleResult" });
-var CancelScheduleInput = Schema72.Struct({
+var CancelScheduleInput = Schema73.Struct({
   schedule_id: exports_ids_schema.ScheduleId,
   cancelled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.CancelScheduleInput" });
-var CancelScheduleResult = Schema72.Struct({
+var CancelScheduleResult = Schema73.Struct({
   schedule: exports_schedule_schema.ScheduleRecord
 }).annotate({ identifier: "Relay.Operation.CancelScheduleResult" });
-var ListSchedulesInput = Schema72.Struct({
-  state: Schema72.optionalKey(exports_schedule_schema.ScheduleState)
+var ListSchedulesInput = Schema73.Struct({
+  state: Schema73.optionalKey(exports_schedule_schema.ScheduleState)
 }).annotate({ identifier: "Relay.Operation.ListSchedulesInput" });
-var ListSchedulesResult = Schema72.Struct({
-  schedules: Schema72.Array(exports_schedule_schema.ScheduleRecord)
+var ListSchedulesResult = Schema73.Struct({
+  schedules: Schema73.Array(exports_schedule_schema.ScheduleRecord)
 }).annotate({ identifier: "Relay.Operation.ListSchedulesResult" });
-var ListExecutionsInput = Schema72.Struct({
-  root_address_id: Schema72.optionalKey(exports_ids_schema.AddressId),
-  status: Schema72.optionalKey(exports_execution_schema.ExecutionStatus),
-  limit: Schema72.optionalKey(Schema72.Int.check(Schema72.isGreaterThan(0))),
-  cursor: Schema72.optionalKey(exports_shared_schema.NonEmptyString)
+var ListExecutionsInput = Schema73.Struct({
+  root_address_id: Schema73.optionalKey(exports_ids_schema.AddressId),
+  status: Schema73.optionalKey(exports_execution_schema.ExecutionStatus),
+  limit: Schema73.optionalKey(Schema73.Int.check(Schema73.isGreaterThan(0))),
+  cursor: Schema73.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.ListExecutionsInput" });
-var ConversationKind = Schema72.Literals(["user-agent", "agent-agent"]).annotate({
+var ConversationKind = Schema73.Literals(["user-agent", "agent-agent"]).annotate({
   identifier: "Relay.Operation.ConversationKind"
 });
-var ConversationSummary = Schema72.Struct({
+var ConversationSummary = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   root_address_id: exports_ids_schema.AddressId,
-  session_id: Schema72.optionalKey(exports_ids_schema.SessionId),
+  session_id: Schema73.optionalKey(exports_ids_schema.SessionId),
   status: exports_execution_schema.ExecutionStatus,
   kind: ConversationKind,
-  agent_definition_id: Schema72.optionalKey(exports_ids_schema.AgentDefinitionId),
+  agent_definition_id: Schema73.optionalKey(exports_ids_schema.AgentDefinitionId),
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
   updated_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.ConversationSummary" });
-var ListExecutionsResult = Schema72.Struct({
-  records: Schema72.Array(ConversationSummary),
-  next_cursor: Schema72.optionalKey(exports_shared_schema.NonEmptyString)
+var ListExecutionsResult = Schema73.Struct({
+  records: Schema73.Array(ConversationSummary),
+  next_cursor: Schema73.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.ListExecutionsResult" });
-var ListSessionsInput = Schema72.Struct({
-  root_address_id: Schema72.optionalKey(exports_ids_schema.AddressId),
-  limit: Schema72.optionalKey(Schema72.Int.check(Schema72.isGreaterThan(0))),
-  cursor: Schema72.optionalKey(exports_shared_schema.NonEmptyString)
+var ListSessionsInput = Schema73.Struct({
+  root_address_id: Schema73.optionalKey(exports_ids_schema.AddressId),
+  limit: Schema73.optionalKey(Schema73.Int.check(Schema73.isGreaterThan(0))),
+  cursor: Schema73.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.ListSessionsInput" });
-var SessionSummary = Schema72.Struct({
+var SessionSummary = Schema73.Struct({
   session_id: exports_ids_schema.SessionId,
   root_address_id: exports_ids_schema.AddressId,
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
   updated_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.SessionSummary" });
-var ListSessionsResult = Schema72.Struct({
-  records: Schema72.Array(SessionSummary),
-  next_cursor: Schema72.optionalKey(exports_shared_schema.NonEmptyString)
+var ListSessionsResult = Schema73.Struct({
+  records: Schema73.Array(SessionSummary),
+  next_cursor: Schema73.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.ListSessionsResult" });
-var GetSessionInput = Schema72.Struct({
+var GetSessionInput = Schema73.Struct({
   session_id: exports_ids_schema.SessionId,
-  limit: Schema72.optionalKey(Schema72.Int.check(Schema72.isGreaterThan(0))),
-  cursor: Schema72.optionalKey(exports_shared_schema.NonEmptyString)
+  limit: Schema73.optionalKey(Schema73.Int.check(Schema73.isGreaterThan(0))),
+  cursor: Schema73.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.GetSessionInput" });
-var GetSessionResult = Schema72.Struct({
+var GetSessionResult = Schema73.Struct({
   session: SessionSummary,
-  executions: Schema72.Array(ConversationSummary),
-  next_cursor: Schema72.optionalKey(exports_shared_schema.NonEmptyString)
+  executions: Schema73.Array(ConversationSummary),
+  next_cursor: Schema73.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.GetSessionResult" });
-var ReplayExecutionInput = Schema72.Struct({
+var ReplayExecutionInput = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  after_cursor: Schema72.optionalKey(exports_shared_schema.NonEmptyString),
-  limit: Schema72.optionalKey(Schema72.Int.check(Schema72.isGreaterThan(0)))
+  after_cursor: Schema73.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema73.optionalKey(Schema73.Int.check(Schema73.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.ReplayExecutionInput" });
-var ReplayExecutionResult = Schema72.Struct({
-  events: Schema72.Array(exports_execution_schema.ExecutionEvent)
+var ReplayExecutionResult = Schema73.Struct({
+  events: Schema73.Array(exports_execution_schema.ExecutionEvent)
 }).annotate({ identifier: "Relay.Operation.ReplayExecutionResult" });
-var RunnerSummary = Schema72.Struct({
-  address: Schema72.String,
-  healthy: Schema72.Boolean,
+var RunnerSummary = Schema73.Struct({
+  address: Schema73.String,
+  healthy: Schema73.Boolean,
   last_heartbeat: exports_shared_schema.TimestampMillis,
-  owned_shards: Schema72.Int
+  owned_shards: Schema73.Int
 }).annotate({ identifier: "Relay.Operation.RunnerSummary" });
-var ListRunnersResult = Schema72.Struct({
-  runners: Schema72.Array(RunnerSummary),
-  total_shards: Schema72.Int
+var ListRunnersResult = Schema73.Struct({
+  runners: Schema73.Array(RunnerSummary),
+  total_shards: Schema73.Int
 }).annotate({ identifier: "Relay.Operation.ListRunnersResult" });
-var RouteExecutionResult = Schema72.Struct({
+var RouteExecutionResult = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  shard: Schema72.String,
-  runner_address: Schema72.NullOr(Schema72.String),
-  owned: Schema72.Boolean
+  shard: Schema73.String,
+  runner_address: Schema73.NullOr(Schema73.String),
+  owned: Schema73.Boolean
 }).annotate({ identifier: "Relay.Operation.RouteExecutionResult" });
 // ../ai/src/embedding-model/embedding-model-registration.ts
 import * as OpenAiClient from "@effect/ai-openai/OpenAiClient";