@relayfx/sdk 0.2.13 → 0.2.15

package/dist/{index-3e4cs8s6.js → index-z9xk02sv.js}

@@ -328,7 +328,8 @@ var PositiveSafeInteger = Schema5.Number.check(Schema5.makeFilter((value) => Num
 var CompactionPolicy = Schema5.Struct({
   context_window: PositiveSafeInteger,
   reserve_tokens: PositiveSafeInteger,
-  keep_recent_tokens: PositiveSafeInteger
+  keep_recent_tokens: PositiveSafeInteger,
+  summary_model: Schema5.optionalKey(ModelSelection)
 }).check(Schema5.makeFilter((policy) => policy.reserve_tokens + policy.keep_recent_tokens < policy.context_window ? undefined : "reserve_tokens + keep_recent_tokens must be less than context_window")).annotate({ identifier: "Relay.Agent.CompactionPolicy" });
 var ChildRunWorkspacePolicy = Schema5.Struct({
   mode: Schema5.Literals(["share", "fork"]),
@@ -2962,10 +2963,17 @@ var layer7 = Layer7.effect(Service7, Effect8.gen(function* () {
         return yield* new ChildFanOutConflict({ fan_out_id: definition.fan_out_id });
       return existing;
     }
-    yield* sql.withTransaction(Effect8.gen(function* () {
+    const inserted = sql.withTransaction(Effect8.gen(function* () {
       yield* sql`INSERT INTO relay_child_fan_outs (tenant_id, id, parent_execution_id, definition_json, state, created_at) VALUES (${tenantId}, ${definition.fan_out_id}, ${definition.parent_execution_id}, ${encodeJson(definition)}, 'joining', ${timestampParam(sql, definition.created_at)})`;
       yield* Effect8.forEach(definition.children, (child, ordinal) => sql`INSERT INTO relay_child_fan_out_members (tenant_id, fan_out_id, child_execution_id, ordinal, state) VALUES (${tenantId}, ${definition.fan_out_id}, ${child.child_execution_id}, ${ordinal}, 'queued')`, { discard: true });
-    })).pipe(Effect8.mapError(repositoryError));
+    }));
+    yield* inserted.pipe(Effect8.mapError(repositoryError), Effect8.catch((error) => Effect8.gen(function* () {
+      const current2 = yield* load(tenantId, definition.fan_out_id).pipe(Effect8.mapError(repositoryError));
+      if (current2 === undefined)
+        return yield* error;
+      if (!sameDefinition(cloneDefinition3(current2), definition))
+        return yield* new ChildFanOutConflict({ fan_out_id: definition.fan_out_id });
+    })));
     const created = yield* load(tenantId, definition.fan_out_id).pipe(Effect8.mapError(repositoryError));
     if (created === undefined)
       return yield* new ChildFanOutRepositoryError({ message: "Fan-out insert returned no row" });
@@ -9706,12 +9714,20 @@ var memoryLayer27 = Layer28.sync(Service28, () => {
     inspect,
     listNonterminal: Effect29.fn("WorkflowDefinitionRepository.memory.listNonterminal")(() => Effect29.sync(() => [...runs.values()].filter((record2) => record2.status === "running").map(clone3))),
     cancel: Effect29.fn("WorkflowDefinitionRepository.memory.cancel")(function* (id2) {
+      const now = yield* Clock3.currentTimeMillis;
       const record2 = runs.get(id2);
       if (record2 === undefined)
-        return;
-      const updated = { ...record2, status: "cancelled", updated_at: yield* Clock3.currentTimeMillis };
+        return { transitioned: false, record: undefined };
+      if (record2.status !== "running")
+        return { transitioned: false, record: clone3(record2) };
+      const updated = { ...record2, status: "cancelled", updated_at: now };
       runs.set(id2, updated);
-      return clone3(updated);
+      const events = lifecycle.get(id2) ?? [];
+      lifecycle.set(id2, [
+        ...events,
+        { execution_id: id2, sequence: events.length + 1, type: "workflow.cancelled", created_at: now }
+      ]);
+      return { transitioned: true, record: clone3(updated) };
     }),
     getOperation: Effect29.fn("WorkflowDefinitionRepository.memory.getOperation")((executionId, operationId2) => Effect29.sync(() => clone3(operations.get(`${executionId}:${operationId2}`)))),
     putOperation: Effect29.fn("WorkflowDefinitionRepository.memory.putOperation")((state) => Effect29.sync(() => {
@@ -9726,18 +9742,34 @@ var memoryLayer27 = Layer28.sync(Service28, () => {
       return clone3(stored);
     })),
     listLifecycle: Effect29.fn("WorkflowDefinitionRepository.memory.listLifecycle")((executionId) => Effect29.sync(() => clone3(lifecycle.get(executionId) ?? []))),
-    finish: Effect29.fn("WorkflowDefinitionRepository.memory.finish")(function* (id2, status) {
+    finish: Effect29.fn("WorkflowDefinitionRepository.memory.finish")(function* (id2, status, data) {
+      const now = yield* Clock3.currentTimeMillis;
       const record2 = runs.get(id2);
-      if (record2 === undefined)
-        return;
-      const updated = { ...record2, status, updated_at: yield* Clock3.currentTimeMillis };
+      if (record2 === undefined || record2.status !== "running")
+        return { transitioned: false, record: record2 === undefined ? undefined : clone3(record2) };
+      const updated = { ...record2, status, updated_at: now };
       runs.set(id2, updated);
-      return clone3(updated);
+      const events = lifecycle.get(id2) ?? [];
+      lifecycle.set(id2, [
+        ...events,
+        {
+          execution_id: id2,
+          sequence: events.length + 1,
+          type: status === "completed" ? "workflow.completed" : "workflow.failed",
+          ...data === undefined ? {} : { data: clone3(data) },
+          created_at: now
+        }
+      ]);
+      return { transitioned: true, record: clone3(updated) };
     })
   });
 });
 var layer27 = Layer28.effect(Service28, Effect29.gen(function* () {
   const sql = yield* SqlClient28;
+  const operationUpsert = sql.onDialectOrElse({
+    mysql: () => sql.literal("ON DUPLICATE KEY UPDATE status=VALUES(status), fan_out_id=VALUES(fan_out_id), decision=VALUES(decision), output_json=VALUES(output_json), attempt=VALUES(attempt), backoff_until=VALUES(backoff_until), compensation_operation_id=VALUES(compensation_operation_id), started_at=VALUES(started_at), completed_at=VALUES(completed_at), updated_at=VALUES(updated_at)"),
+    orElse: () => sql.literal("ON CONFLICT (tenant_id, execution_id, operation_id) DO UPDATE SET status=excluded.status, fan_out_id=excluded.fan_out_id, decision=excluded.decision, output_json=excluded.output_json, attempt=excluded.attempt, backoff_until=excluded.backoff_until, compensation_operation_id=excluded.compensation_operation_id, started_at=excluded.started_at, completed_at=excluded.completed_at, updated_at=excluded.updated_at")
+  });
   const register = Effect29.fn("WorkflowDefinitionRepository.register")(function* (input) {
     const tenant = yield* current();
     const digest = yield* Effect29.promise(() => exports_workflow_schema.digestDefinition(input.definition));
@@ -9768,7 +9800,7 @@ var layer27 = Layer28.effect(Service28, Effect29.gen(function* () {
     start: Effect29.fn("WorkflowDefinitionRepository.start")(function* (input) {
       const tenant = yield* current();
       const now = yield* Clock3.currentTimeMillis;
-      return yield* sql.withTransaction(Effect29.gen(function* () {
+      const insert = sql.withTransaction(Effect29.gen(function* () {
         const old = yield* sql`SELECT execution_id, workflow_definition_id, workflow_definition_revision, workflow_definition_digest, status, created_at, updated_at FROM relay_workflow_runs WHERE tenant_id=${tenant} AND execution_id=${input.execution_id}`;
         if (old[0] !== undefined)
           return decodeRun(old[0]);
@@ -9788,6 +9820,7 @@ var layer27 = Layer28.effect(Service28, Effect29.gen(function* () {
           updated_at: now
         };
       }));
+      return yield* insert.pipe(Effect29.catch((error5) => sql`SELECT execution_id, workflow_definition_id, workflow_definition_revision, workflow_definition_digest, status, created_at, updated_at FROM relay_workflow_runs WHERE tenant_id=${tenant} AND execution_id=${input.execution_id}`.pipe(Effect29.flatMap((rows) => rows[0] === undefined ? Effect29.fail(error5) : Effect29.succeed(decodeRun(rows[0]))))));
     }),
     inspect: Effect29.fn("WorkflowDefinitionRepository.inspect")(function* (id2) {
       const tenant = yield* current();
@@ -9802,9 +9835,7 @@ var layer27 = Layer28.effect(Service28, Effect29.gen(function* () {
     cancel: Effect29.fn("WorkflowDefinitionRepository.cancel")(function* (id2) {
       const tenant = yield* current();
       const now = yield* Clock3.currentTimeMillis;
-      yield* sql`UPDATE relay_workflow_runs SET status='cancelled', updated_at=${timestampParam(sql, now)} WHERE tenant_id=${tenant} AND execution_id=${id2}`;
-      const rows = yield* sql`SELECT execution_id, workflow_definition_id, workflow_definition_revision, workflow_definition_digest, status, created_at, updated_at FROM relay_workflow_runs WHERE tenant_id=${tenant} AND execution_id=${id2}`;
-      return rows[0] === undefined ? undefined : decodeRun(rows[0]);
+      return yield* transition2(sql, tenant, id2, "cancelled", now);
     }),
     getOperation: Effect29.fn("WorkflowDefinitionRepository.getOperation")(function* (executionId, operationId2) {
       const tenant = yield* current();
@@ -9813,8 +9844,7 @@ var layer27 = Layer28.effect(Service28, Effect29.gen(function* () {
     }),
     putOperation: Effect29.fn("WorkflowDefinitionRepository.putOperation")(function* (state) {
       const tenant = yield* current();
-      yield* sql`DELETE FROM relay_workflow_operation_states WHERE tenant_id=${tenant} AND execution_id=${state.execution_id} AND operation_id=${state.operation_id}`;
-      yield* sql`INSERT INTO relay_workflow_operation_states (tenant_id, execution_id, operation_id, status, fan_out_id, decision, output_json, attempt, backoff_until, compensation_operation_id, started_at, completed_at, updated_at) VALUES (${tenant}, ${state.execution_id}, ${state.operation_id}, ${state.status}, ${state.fan_out_id ?? null}, ${state.decision === undefined ? null : state.decision}, ${state.output === undefined ? null : encodeJson(state.output)}, ${state.attempt ?? null}, ${state.backoff_until === undefined ? null : timestampParam(sql, state.backoff_until)}, ${state.compensation_operation_id ?? null}, ${state.started_at === undefined ? null : timestampParam(sql, state.started_at)}, ${state.completed_at === undefined ? null : timestampParam(sql, state.completed_at)}, ${timestampParam(sql, state.updated_at)})`;
+      yield* sql`INSERT INTO relay_workflow_operation_states (tenant_id, execution_id, operation_id, status, fan_out_id, decision, output_json, attempt, backoff_until, compensation_operation_id, started_at, completed_at, updated_at) VALUES (${tenant}, ${state.execution_id}, ${state.operation_id}, ${state.status}, ${state.fan_out_id ?? null}, ${state.decision === undefined ? null : state.decision}, ${state.output === undefined ? null : encodeJson(state.output)}, ${state.attempt ?? null}, ${state.backoff_until === undefined ? null : timestampParam(sql, state.backoff_until)}, ${state.compensation_operation_id ?? null}, ${state.started_at === undefined ? null : timestampParam(sql, state.started_at)}, ${state.completed_at === undefined ? null : timestampParam(sql, state.completed_at)}, ${timestampParam(sql, state.updated_at)}) ${operationUpsert}`;
       return state;
     }),
     listOperations: Effect29.fn("WorkflowDefinitionRepository.listOperations")(function* (executionId) {
@@ -9836,14 +9866,40 @@ var layer27 = Layer28.effect(Service28, Effect29.gen(function* () {
       const rows = yield* sql`SELECT * FROM relay_workflow_lifecycle_events WHERE tenant_id=${tenant} AND execution_id=${executionId} ORDER BY sequence`;
       return rows.map(decodeLifecycle);
     }),
-    finish: Effect29.fn("WorkflowDefinitionRepository.finish")(function* (id2, status) {
+    finish: Effect29.fn("WorkflowDefinitionRepository.finish")(function* (id2, status, data) {
       const tenant = yield* current();
       const now = yield* Clock3.currentTimeMillis;
-      yield* sql`UPDATE relay_workflow_runs SET status=${status}, updated_at=${timestampParam(sql, now)} WHERE tenant_id=${tenant} AND execution_id=${id2}`;
-      const rows = yield* sql`SELECT execution_id, workflow_definition_id, workflow_definition_revision, workflow_definition_digest, status, created_at, updated_at FROM relay_workflow_runs WHERE tenant_id=${tenant} AND execution_id=${id2}`;
-      return rows[0] === undefined ? undefined : decodeRun(rows[0]);
+      return yield* transition2(sql, tenant, id2, status, now, data);
+    })
+  });
+}));
+var transition2 = (sql, tenant, id2, status, now, data) => sql.withTransaction(Effect29.gen(function* () {
+  const result = yield* sql.onDialectOrElse({
+    mysql: () => Effect29.gen(function* () {
+      const before = yield* sql`SELECT execution_id, workflow_definition_id, workflow_definition_revision, workflow_definition_digest, status, created_at, updated_at FROM relay_workflow_runs WHERE tenant_id=${tenant} AND execution_id=${id2} FOR UPDATE`;
+      if (before[0] === undefined)
+        return { transitioned: false, record: undefined };
+      if (before[0].status !== "running")
+        return { transitioned: false, record: decodeRun(before[0]) };
+      yield* sql`UPDATE relay_workflow_runs SET status=${status}, updated_at=${timestampParam(sql, now)} WHERE tenant_id=${tenant} AND execution_id=${id2} AND status='running'`;
+      const rows2 = yield* sql`SELECT execution_id, workflow_definition_id, workflow_definition_revision, workflow_definition_digest, status, created_at, updated_at FROM relay_workflow_runs WHERE tenant_id=${tenant} AND execution_id=${id2}`;
+      return { transitioned: true, record: decodeRun(rows2[0]) };
+    }),
+    orElse: () => Effect29.gen(function* () {
+      const changed = yield* sql`UPDATE relay_workflow_runs SET status=${status}, updated_at=${timestampParam(sql, now)} WHERE tenant_id=${tenant} AND execution_id=${id2} AND status='running' RETURNING execution_id, workflow_definition_id, workflow_definition_revision, workflow_definition_digest, status, created_at, updated_at`;
+      if (changed[0] !== undefined)
+        return { transitioned: true, record: decodeRun(changed[0]) };
+      const rows2 = yield* sql`SELECT execution_id, workflow_definition_id, workflow_definition_revision, workflow_definition_digest, status, created_at, updated_at FROM relay_workflow_runs WHERE tenant_id=${tenant} AND execution_id=${id2}`;
+      return { transitioned: false, record: rows2[0] === undefined ? undefined : decodeRun(rows2[0]) };
     })
   });
+  if (!result.transitioned)
+    return result;
+  const rows = yield* sql`SELECT COALESCE(MAX(sequence), 0) AS sequence FROM relay_workflow_lifecycle_events WHERE tenant_id=${tenant} AND execution_id=${id2}`;
+  const sequence = Number(rows[0]?.sequence ?? 0) + 1;
+  const eventType = status === "cancelled" ? "workflow.cancelled" : status === "completed" ? "workflow.completed" : "workflow.failed";
+  yield* sql`INSERT INTO relay_workflow_lifecycle_events (tenant_id, execution_id, sequence, event_type, operation_id, data_json, created_at) VALUES (${tenant}, ${id2}, ${sequence}, ${eventType}, ${null}, ${data === undefined ? null : encodeJson(data)}, ${timestampParam(sql, now)})`;
+  return result;
 }));
 var decodeDefinition = (row) => ({
   id: exports_ids_schema.WorkflowDefinitionId.make(row.workflow_definition_id),
@@ -10306,7 +10362,10 @@ var layerFromRepository2 = Layer30.effect(Service30, Effect32.gen(function* () {
       yield* recordEventReplayed("repository", replay.history.length);
       return replay.history;
     }),
-    stream: (input) => Stream5.unwrap(loadReplay(input).pipe(Effect32.map(({ history, sequence }) => Stream5.fromIterable(history).pipe(Stream5.concat(liveTail(repository, hubs, input, history.at(-1)?.sequence ?? sequence).pipe(Stream5.takeUntil(isTerminal))))))),
+    stream: (input) => Stream5.unwrap(loadReplay(input).pipe(Effect32.map(({ history, sequence }) => {
+      const replay = Stream5.fromIterable(history);
+      return history.some(isTerminal) ? replay : replay.pipe(Stream5.concat(liveTail(repository, hubs, input, history.at(-1)?.sequence ?? sequence).pipe(Stream5.takeUntil(isTerminal))));
+    }))),
     findBySequenceOrCursor: Effect32.fn("EventLog.repository.findBySequenceOrCursor")((input) => repository.findBySequenceOrCursor(input).pipe(Effect32.mapError(mapRepositoryFindError))),
     findByCursor: Effect32.fn("EventLog.repository.findByCursor")((input) => repository.findByCursor(input).pipe(Effect32.mapError(mapRepositoryFindError))),
     findBySequence: Effect32.fn("EventLog.repository.findBySequence")((input) => repository.findBySequence(input).pipe(Effect32.mapError(mapRepositoryFindError))),
@@ -10358,7 +10417,10 @@ var memoryLayer29 = Layer30.effect(Service30, Effect32.gen(function* () {
       yield* recordEventReplayed("memory", replay.history.length);
       return replay.history;
     }),
-    stream: (input) => Stream5.unwrap(loadReplay(input).pipe(Effect32.map(({ history, sequence }) => Stream5.fromIterable(history).pipe(Stream5.concat(liveEvents(pubsub, input, history, sequence)))))),
+    stream: (input) => Stream5.unwrap(loadReplay(input).pipe(Effect32.map(({ history, sequence }) => {
+      const replay = Stream5.fromIterable(history);
+      return history.some(isTerminal) ? replay : replay.pipe(Stream5.concat(liveEvents(pubsub, input, history, sequence)));
+    }))),
     findBySequenceOrCursor: Effect32.fn("EventLog.memory.findBySequenceOrCursor")(function* (input) {
       const executionEvents = yield* allEvents(input.executionId);
       const event = executionEvents.find((item) => item.sequence === input.sequence || item.cursor === input.cursor);
@@ -13984,76 +14046,246 @@ var spawnDynamic = Effect58.fn("ChildRunService.spawnDynamic.call")(function* (i
   return yield* service.spawnDynamic(input);
 });
 
-// ../runtime/src/model/language-model-service.ts
-var exports_language_model_service = {};
-__export(exports_language_model_service, {
+// ../runtime/src/model/embedding-model-service.ts
+var exports_embedding_model_service = {};
+__export(exports_embedding_model_service, {
   testLayer: () => testLayer46,
   registrations: () => registrations2,
   registrationFromLayer: () => registrationFromLayer2,
   register: () => register5,
   provideForAgent: () => provideForAgent,
+  provideDefault: () => provideDefault,
   provide: () => provide2,
   memoryLayer: () => memoryLayer35,
   layerFromRegistrationEffects: () => layerFromRegistrationEffects2,
   layer: () => layer40,
+  deterministicTestLayer: () => deterministicTestLayer,
+  deterministicRegistration: () => deterministicRegistration,
+  deterministicLayer: () => deterministicLayer,
   Service: () => Service38,
+  EmbeddingModelNotRegistered: () => EmbeddingModelNotRegistered
+});
+import { Context as Context51, Effect as Effect59, Layer as Layer52, Ref as Ref16, Schema as Schema67 } from "effect";
+import { EmbeddingModel as EmbeddingModel2, Model as Model3 } from "effect/unstable/ai";
+
+class EmbeddingModelNotRegistered extends Schema67.TaggedErrorClass()("EmbeddingModelNotRegistered", {
+  provider: Schema67.String,
+  model: Schema67.String,
+  registration_key: Schema67.optionalKey(Schema67.String)
+}) {
+}
+
+class Service38 extends Context51.Service()("@relayfx/runtime/EmbeddingModelService") {
+}
+var toRegistration = (input) => ({
+  provider: input.provider,
+  model: input.model,
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  layer: input.layer,
+  ...input.metadata === undefined ? {} : { metadata: input.metadata }
+});
+var selectionError = (selection) => new EmbeddingModelNotRegistered({
+  provider: selection.provider,
+  model: selection.model,
+  ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
+});
+var defaultSelectionError = () => new EmbeddingModelNotRegistered({ provider: "default", model: "default" });
+var matchesSelection2 = (selection, registration) => registration.provider === selection.provider && registration.model === selection.model && (selection.registrationKey === undefined || registration.registrationKey === selection.registrationKey);
+var resolve3 = (registrations2, selection) => {
+  const matches2 = registrations2.filter((registration) => matchesSelection2(selection, registration));
+  if (selection.registrationKey !== undefined)
+    return matches2[0];
+  if (matches2.length === 1)
+    return matches2[0];
+  return matches2.find((registration) => registration.registrationKey === undefined);
+};
+var resolveDefault = (registrations2, options) => {
+  if (options?.defaultSelection !== undefined) {
+    return resolve3(registrations2, options.defaultSelection);
+  }
+  return registrations2.length === 1 ? registrations2[0] : undefined;
+};
+var registrationFromLayer2 = (input) => Model3.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect59.map((layer40) => toRegistration({
+  provider: input.provider,
+  model: input.model,
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  layer: layer40,
+  ...input.metadata === undefined ? {} : { metadata: input.metadata }
+})));
+var layer40 = (initialRegistrations = [], options) => Layer52.effect(Service38, Effect59.gen(function* () {
+  const registry = yield* Ref16.make([...initialRegistrations]);
+  const register5 = Effect59.fn("EmbeddingModelService.register")(function* (input) {
+    const registration = toRegistration(input);
+    yield* Ref16.update(registry, (current2) => [
+      ...current2.filter((item) => !(item.provider === registration.provider && item.model === registration.model && item.registrationKey === registration.registrationKey)),
+      registration
+    ]);
+  });
+  const registrations2 = Ref16.get(registry);
+  const provide2 = (selection, effect) => Effect59.gen(function* () {
+    const current2 = yield* Ref16.get(registry);
+    const registration = resolve3(current2, selection);
+    if (registration === undefined)
+      return yield* Effect59.fail(selectionError(selection));
+    return yield* effect.pipe(Effect59.provide(registration.layer));
+  });
+  const provideDefault = (effect) => Effect59.gen(function* () {
+    const current2 = yield* Ref16.get(registry);
+    const registration = resolveDefault(current2, options);
+    if (registration === undefined)
+      return yield* Effect59.fail(defaultSelectionError());
+    return yield* effect.pipe(Effect59.provide(registration.layer));
+  });
+  const provideForAgent = (agent, effect) => {
+    return provideDefault(effect);
+  };
+  return Service38.of({ register: register5, registrations: registrations2, provide: provide2, provideDefault, provideForAgent });
+}));
+var layerFromRegistrationEffects2 = (registrations2, options) => Layer52.unwrap(Effect59.all(registrations2).pipe(Effect59.map((items) => layer40(items, options))));
+var memoryLayer35 = layer40;
+var testLayer46 = (implementation) => Layer52.succeed(Service38, Service38.of(implementation));
+var words = (input) => input.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+var hashWord = (word) => {
+  let hash = 2166136261;
+  for (let index = 0;index < word.length; index += 1) {
+    hash ^= word.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var deterministicVector = (input, dimensions) => {
+  const vector = Array.from({ length: dimensions }, () => 0);
+  for (const word of words(input)) {
+    const hash = hashWord(word);
+    const index = hash % dimensions;
+    vector[index] = (vector[index] ?? 0) + 1;
+  }
+  return vector;
+};
+var deterministicLayer = (options = {}) => {
+  const dimensions = options.dimensions ?? 64;
+  return Layer52.mergeAll(Layer52.effect(EmbeddingModel2.EmbeddingModel, EmbeddingModel2.make({
+    embedMany: ({ inputs }) => Effect59.succeed({
+      results: inputs.map((input) => deterministicVector(input, dimensions)),
+      usage: { inputTokens: inputs.reduce((total, input) => total + words(input).length, 0) }
+    })
+  })), Layer52.succeed(EmbeddingModel2.Dimensions, dimensions));
+};
+var deterministicRegistration = (options = {}) => registrationFromLayer2({
+  provider: options.provider ?? "test",
+  model: options.model ?? "deterministic-embedding",
+  layer: deterministicLayer(options)
+});
+var deterministicTestLayer = (options = {}) => layerFromRegistrationEffects2([deterministicRegistration(options)], {
+  defaultSelection: {
+    provider: options.provider ?? "test",
+    model: options.model ?? "deterministic-embedding"
+  }
+});
+var register5 = Effect59.fn("EmbeddingModelService.register.call")(function* (input) {
+  const service = yield* Service38;
+  return yield* service.register(input);
+});
+var registrations2 = Effect59.fn("EmbeddingModelService.registrations.call")(function* () {
+  const service = yield* Service38;
+  return yield* service.registrations;
+});
+var provide2 = (selection, effect) => Effect59.gen(function* () {
+  const service = yield* Service38;
+  return yield* service.provide(selection, effect);
+});
+var provideDefault = (effect) => Effect59.gen(function* () {
+  const service = yield* Service38;
+  return yield* service.provideDefault(effect);
+});
+var provideForAgent = (agent, effect) => Effect59.gen(function* () {
+  const service = yield* Service38;
+  return yield* service.provideForAgent(agent, effect);
+});
+
+// ../runtime/src/model/language-model-service.ts
+var exports_language_model_service = {};
+__export(exports_language_model_service, {
+  testLayer: () => testLayer47,
+  resolve: () => resolve4,
+  registrations: () => registrations3,
+  registrationFromLayer: () => registrationFromLayer3,
+  register: () => register6,
+  provideForAgent: () => provideForAgent2,
+  provide: () => provide3,
+  memoryLayer: () => memoryLayer36,
+  layerFromRegistrationEffects: () => layerFromRegistrationEffects3,
+  layer: () => layer41,
+  Service: () => Service39,
   LanguageModelNotRegistered: () => LanguageModelNotRegistered2
 });
-import { Context as Context51, Effect as Effect59, Layer as Layer52 } from "effect";
+import { Context as Context52, Effect as Effect60, Layer as Layer53 } from "effect";
 var LanguageModelNotRegistered2 = exports_model_registry.LanguageModelNotRegistered;
 var toSelection = (selection) => ({
   provider: selection.provider,
   model: selection.model,
   ...selection.registration_key === undefined ? {} : { registrationKey: selection.registration_key }
 });
+var registrationKey = (value) => value.registration_key ?? value.registrationKey;
+var matchesSelection3 = (selection, registration) => registration.provider === selection.provider && registration.model === selection.model && registrationKey(registration) === registrationKey(selection);
+var notRegistered = (selection) => new LanguageModelNotRegistered2({
+  provider: selection.provider,
+  model: selection.model,
+  ...selection.registration_key === undefined ? {} : { registration_key: selection.registration_key }
+});
 
-class Service38 extends Context51.Service()("@relayfx/runtime/LanguageModelService") {
+class Service39 extends Context52.Service()("@relayfx/runtime/LanguageModelService") {
 }
-var registrationFromLayer2 = exports_model_registry.registrationFromLayer;
-var layer40 = (initialRegistrations = [], options) => Layer52.effect(Service38, Effect59.gen(function* () {
+var registrationFromLayer3 = exports_model_registry.registrationFromLayer;
+var layer41 = (initialRegistrations = [], options) => Layer53.effect(Service39, Effect60.gen(function* () {
   const registry = yield* exports_model_registry.Service;
-  return Service38.of({
+  return Service39.of({
     register: (input) => registry.register(input),
     registrations: registry.registrations,
     provide: (selection, effect) => registry.provide(toSelection(selection), effect),
     provideForAgent: (agent, effect) => registry.provide(toSelection(agent.model), effect)
   });
-})).pipe(Layer52.provide(exports_model_registry.layer(initialRegistrations, options)));
-var layerFromRegistrationEffects2 = (registrations2, options) => Layer52.unwrap(Effect59.all(registrations2).pipe(Effect59.map((items) => layer40(items, options))));
-var memoryLayer35 = layer40;
-var testLayer46 = (implementation) => Layer52.succeed(Service38, Service38.of(implementation));
-var register5 = Effect59.fn("LanguageModelService.register.call")(function* (input) {
-  const service = yield* Service38;
+})).pipe(Layer53.provide(exports_model_registry.layer(initialRegistrations, options)));
+var layerFromRegistrationEffects3 = (registrations3, options) => Layer53.unwrap(Effect60.all(registrations3).pipe(Effect60.map((items) => layer41(items, options))));
+var memoryLayer36 = layer41;
+var testLayer47 = (implementation) => Layer53.succeed(Service39, Service39.of(implementation));
+var register6 = Effect60.fn("LanguageModelService.register.call")(function* (input) {
+  const service = yield* Service39;
   return yield* service.register(input);
 });
-var registrations2 = Effect59.fn("LanguageModelService.registrations.call")(function* () {
-  const service = yield* Service38;
+var registrations3 = Effect60.fn("LanguageModelService.registrations.call")(function* () {
+  const service = yield* Service39;
   return yield* service.registrations;
 });
-var provide2 = (selection, effect) => Effect59.gen(function* () {
-  const service = yield* Service38;
+var resolve4 = Effect60.fn("LanguageModelService.resolve.call")(function* (selection) {
+  const service = yield* Service39;
+  const registered = yield* service.registrations;
+  return yield* Effect60.fromNullishOr(registered.find((registration) => matchesSelection3(selection, registration))).pipe(Effect60.mapError(() => notRegistered(selection)));
+});
+var provide3 = (selection, effect) => Effect60.gen(function* () {
+  const service = yield* Service39;
   return yield* service.provide(selection, effect);
 });
-var provideForAgent = (agent, effect) => Effect59.gen(function* () {
-  const service = yield* Service38;
+var provideForAgent2 = (agent, effect) => Effect60.gen(function* () {
+  const service = yield* Service39;
   return yield* service.provideForAgent(agent, effect);
 });
 
 // ../runtime/src/model/model-call-policy.ts
 var exports_model_call_policy = {};
 __export(exports_model_call_policy, {
-  testLayer: () => testLayer47,
+  testLayer: () => testLayer48,
   noRetryLayer: () => noRetryLayer,
   make: () => make6,
-  layer: () => layer41,
+  layer: () => layer42,
   defaultSchedule: () => defaultSchedule,
   defaultClassify: () => defaultClassify2,
-  Service: () => Service39
+  Service: () => Service40
 });
-import { Context as Context52, Duration as Duration3, Layer as Layer53, Schedule as Schedule5 } from "effect";
+import { Context as Context53, Duration as Duration3, Layer as Layer54, Schedule as Schedule5 } from "effect";
 import { AiError as AiError4 } from "effect/unstable/ai";
 
-class Service39 extends Context52.Service()("@relayfx/runtime/ModelCallPolicy") {
+class Service40 extends Context53.Service()("@relayfx/runtime/ModelCallPolicy") {
 }
 var isOutputValidationError = (error5) => AiError4.isAiError(error5) ? error5.reason._tag === "InvalidOutputError" : AiError4.isAiErrorReason(error5) && error5._tag === "InvalidOutputError";
 var defaultClassify2 = (error5) => isOutputValidationError(error5) ? "terminal" : exports_model_resilience.defaultClassify(error5);
@@ -14062,58 +14294,58 @@ var make6 = (input) => ({
   classify: input?.classify ?? defaultClassify2,
   retrySchedule: input?.retrySchedule ?? defaultSchedule
 });
-var layer41 = (input) => Layer53.succeed(Service39, Service39.of(make6(input)));
-var noRetryLayer = layer41({ retrySchedule: Schedule5.recurs(0) });
-var testLayer47 = (implementation) => Layer53.succeed(Service39, Service39.of(implementation));
+var layer42 = (input) => Layer54.succeed(Service40, Service40.of(make6(input)));
+var noRetryLayer = layer42({ retrySchedule: Schedule5.recurs(0) });
+var testLayer48 = (implementation) => Layer54.succeed(Service40, Service40.of(implementation));
 
 // ../runtime/src/presence/presence-service.ts
 var exports_presence_service = {};
 __export(exports_presence_service, {
   watch: () => watch,
-  testLayer: () => testLayer48,
-  register: () => register6,
-  memoryLayer: () => memoryLayer36,
+  testLayer: () => testLayer49,
+  register: () => register7,
+  memoryLayer: () => memoryLayer37,
   list: () => list14,
   layerFromRepository: () => layerFromRepository3,
-  Service: () => Service40,
+  Service: () => Service41,
   PresenceIdentity: () => PresenceIdentity,
   PresenceError: () => PresenceError
 });
-import { Clock as Clock5, Config as Config2, Context as Context53, Effect as Effect60, Layer as Layer54, Random, Schedule as Schedule6, Schema as Schema67, Stream as Stream10 } from "effect";
+import { Clock as Clock5, Config as Config2, Context as Context54, Effect as Effect61, Layer as Layer55, Random, Schedule as Schedule6, Schema as Schema68, Stream as Stream10 } from "effect";
 
-class PresenceError extends Schema67.TaggedErrorClass()("PresenceError", {
-  message: Schema67.String
+class PresenceError extends Schema68.TaggedErrorClass()("PresenceError", {
+  message: Schema68.String
 }) {
 }
 
-class Service40 extends Context53.Service()("@relayfx/runtime/Presence") {
+class Service41 extends Context54.Service()("@relayfx/runtime/Presence") {
 }
-var PresenceIdentity = Context53.Reference("@relayfx/runtime/PresenceIdentity", { defaultValue: () => ({}) });
+var PresenceIdentity = Context54.Reference("@relayfx/runtime/PresenceIdentity", { defaultValue: () => ({}) });
 var readError = (cause) => cause instanceof PresenceError ? cause : new PresenceError({ message: String(cause) });
-var warn = (operation) => (cause) => Effect60.logWarning(`Presence ${operation} failed`).pipe(Effect60.annotateLogs({ cause: String(cause) }));
-var layerFromRepository3 = Layer54.effect(Service40, Effect60.gen(function* () {
+var warn = (operation) => (cause) => Effect61.logWarning(`Presence ${operation} failed`).pipe(Effect61.annotateLogs({ cause: String(cause) }));
+var layerFromRepository3 = Layer55.effect(Service41, Effect61.gen(function* () {
   const repository = yield* exports_presence_repository.Service;
   const heartbeatMillis = yield* Config2.number("RELAY_PRESENCE_HEARTBEAT_MILLIS").pipe(Config2.withDefault(15000));
-  const write = Effect60.fn("Presence.write")(function* (input, connectedAt, notify) {
+  const write = Effect61.fn("Presence.write")(function* (input, connectedAt, notify) {
     const now = yield* Clock5.currentTimeMillis;
     yield* repository.upsertHeartbeat({
       ...input,
       connectedAt,
       expiresAt: now + heartbeatMillis * 3
-    }).pipe(Effect60.catch(warn("heartbeat")));
+    }).pipe(Effect61.catch(warn("heartbeat")));
     if (notify)
-      yield* repository.notifyChanged(input.scope).pipe(Effect60.catch(warn("notification")));
+      yield* repository.notifyChanged(input.scope).pipe(Effect61.catch(warn("notification")));
   });
-  const register6 = Effect60.fn("Presence.register")(function* (input) {
-    const identity = yield* Effect60.serviceOption(PresenceIdentity).pipe(Effect60.map((value) => value._tag === "Some" ? value.value : {}));
+  const register7 = Effect61.fn("Presence.register")(function* (input) {
+    const identity = yield* Effect61.serviceOption(PresenceIdentity).pipe(Effect61.map((value) => value._tag === "Some" ? value.value : {}));
     const registration = { ...input, metadata: { ...identity, ...input.metadata } };
     const connectedAt = yield* Clock5.currentTimeMillis;
-    yield* Effect60.addFinalizer(() => repository.remove(registration).pipe(Effect60.catch(warn("release")), Effect60.andThen(repository.notifyChanged(input.scope).pipe(Effect60.catch(warn("notification"))))));
+    yield* Effect61.addFinalizer(() => repository.remove(registration).pipe(Effect61.catch(warn("release")), Effect61.andThen(repository.notifyChanged(input.scope).pipe(Effect61.catch(warn("notification"))))));
     yield* write(registration, connectedAt, true);
-    yield* write(registration, connectedAt, false).pipe(Effect60.delay(heartbeatMillis), Effect60.repeat(Schedule6.forever), Effect60.forkScoped);
+    yield* write(registration, connectedAt, false).pipe(Effect61.delay(heartbeatMillis), Effect61.repeat(Schedule6.forever), Effect61.forkScoped);
   });
-  const list14 = Effect60.fn("Presence.list")(function* (scope) {
-    const entries = yield* repository.listByScope(scope).pipe(Effect60.mapError(readError));
+  const list14 = Effect61.fn("Presence.list")(function* (scope) {
+    const entries = yield* repository.listByScope(scope).pipe(Effect61.mapError(readError));
     const observed_at = yield* Clock5.currentTimeMillis;
     return {
       scope,
@@ -14126,23 +14358,23 @@ var layerFromRepository3 = Layer54.effect(Service40, Effect60.gen(function* () {
     };
   });
   const watch = (scope) => Stream10.merge(repository.changedSignals(scope).pipe(Stream10.mapError(readError)), Stream10.tick(heartbeatMillis)).pipe(Stream10.mapEffect(() => list14(scope)), Stream10.changesWith((left, right) => JSON.stringify(left.entries) === JSON.stringify(right.entries)));
-  const tracked = (scope, metadata10) => (stream3) => Stream10.scoped(Stream10.concat(Stream10.fromEffect(Effect60.gen(function* () {
+  const tracked = (scope, metadata10) => (stream3) => Stream10.scoped(Stream10.concat(Stream10.fromEffect(Effect61.gen(function* () {
     const id2 = `presence:${yield* Random.nextInt}`;
-    yield* register6({ id: id2, scope, ...metadata10 === undefined ? {} : { metadata: metadata10 } }).pipe(Effect60.forkScoped);
+    yield* register7({ id: id2, scope, ...metadata10 === undefined ? {} : { metadata: metadata10 } }).pipe(Effect61.forkScoped);
   })).pipe(Stream10.drain), stream3));
-  return Service40.of({ register: register6, tracked, list: list14, watch });
+  return Service41.of({ register: register7, tracked, list: list14, watch });
 }));
-var memoryLayer36 = layerFromRepository3.pipe(Layer54.provide(exports_presence_repository.memoryLayer));
-var testLayer48 = (implementation) => Layer54.succeed(Service40, Service40.of(implementation));
-var register6 = Effect60.fn("Presence.register.call")(function* (input) {
-  const service = yield* Service40;
+var memoryLayer37 = layerFromRepository3.pipe(Layer55.provide(exports_presence_repository.memoryLayer));
+var testLayer49 = (implementation) => Layer55.succeed(Service41, Service41.of(implementation));
+var register7 = Effect61.fn("Presence.register.call")(function* (input) {
+  const service = yield* Service41;
   return yield* service.register(input);
 });
-var list14 = Effect60.fn("Presence.list.call")(function* (scope) {
-  const service = yield* Service40;
+var list14 = Effect61.fn("Presence.list.call")(function* (scope) {
+  const service = yield* Service41;
   return yield* service.list(scope);
 });
-var watch = (scope) => Stream10.unwrap(Effect60.map(Service40, (service) => service.watch(scope)));
+var watch = (scope) => Stream10.unwrap(Effect61.map(Service41, (service) => service.watch(scope)));
 
 // ../runtime/src/presence/presence-tool.ts
 var exports_presence_tool = {};
@@ -14153,11 +14385,11 @@ __export(exports_presence_tool, {
   Output: () => Output,
   Input: () => Input
 });
-import { Effect as Effect61, Schema as Schema68 } from "effect";
+import { Effect as Effect62, Schema as Schema69 } from "effect";
 var toolName = "relay_presence";
 var permissionName = "relay.presence.read";
-var Input = Schema68.Struct({ scope: Schema68.optionalKey(exports_presence_schema.Scope) });
-var Output = Schema68.Struct({ watcher_count: Schema68.Number, entries: Schema68.Array(exports_presence_schema.Entry) });
+var Input = Schema69.Struct({ scope: Schema69.optionalKey(exports_presence_schema.Scope) });
+var Output = Schema69.Struct({ watcher_count: Schema69.Number, entries: Schema69.Array(exports_presence_schema.Entry) });
 var registeredTool = (presence) => tool(toolName, {
   description: "List observers currently watching an execution or session.",
   input: Input,
@@ -14165,7 +14397,7 @@ var registeredTool = (presence) => tool(toolName, {
   permissions: [{ name: permissionName, value: true }],
   requiredPermissions: [permissionName],
   metadata: { relay_core_tool: true },
-  run: Effect61.fn("PresenceTool.run")(function* (input, context) {
+  run: Effect62.fn("PresenceTool.run")(function* (input, context) {
     const scope = input.scope ?? { kind: "execution", id: exports_ids_schema.ExecutionId.make(context.executionId) };
     const view = yield* presence.list(scope);
     return { watcher_count: view.entries.length, entries: view.entries };
@@ -14175,21 +14407,21 @@ var registeredTool = (presence) => tool(toolName, {
 // ../runtime/src/schema-registry/schema-registry-service.ts
 var exports_schema_registry_service = {};
 __export(exports_schema_registry_service, {
-  testLayer: () => testLayer49,
-  resolve: () => resolve3,
-  registrations: () => registrations3,
-  register: () => register7,
-  memoryLayer: () => memoryLayer37,
-  layer: () => layer42,
-  Service: () => Service41,
+  testLayer: () => testLayer50,
+  resolve: () => resolve5,
+  registrations: () => registrations4,
+  register: () => register8,
+  memoryLayer: () => memoryLayer38,
+  layer: () => layer43,
+  Service: () => Service42,
   SchemaRefNotRegistered: () => SchemaRefNotRegistered
 });
-import { Context as Context54, Effect as Effect62, Layer as Layer55, Ref as Ref16, Schema as Schema69 } from "effect";
+import { Context as Context55, Effect as Effect63, Layer as Layer56, Ref as Ref17, Schema as Schema70 } from "effect";
 
-class SchemaRefNotRegistered extends Schema69.TaggedErrorClass()("SchemaRefNotRegistered", { schema_ref: exports_shared_schema.NonEmptyString }) {
+class SchemaRefNotRegistered extends Schema70.TaggedErrorClass()("SchemaRefNotRegistered", { schema_ref: exports_shared_schema.NonEmptyString }) {
 }
 
-class Service41 extends Context54.Service()("@relayfx/runtime/SchemaRegistry") {
+class Service42 extends Context55.Service()("@relayfx/runtime/SchemaRegistry") {
 }
 var upsertRegistration2 = (registry, registration) => {
   const exists = registry.some((item) => item.ref === registration.ref);
@@ -14197,63 +14429,63 @@ var upsertRegistration2 = (registry, registration) => {
     return [...registry, registration];
   return registry.map((item) => item.ref === registration.ref ? registration : item);
 };
-var layer42 = (initialRegistrations = []) => Layer55.effect(Service41, Effect62.gen(function* () {
-  const registry = yield* Ref16.make(initialRegistrations.reduce(upsertRegistration2, []));
-  const register7 = Effect62.fn("SchemaRegistry.register")(function* (registration) {
-    yield* Ref16.update(registry, (items) => upsertRegistration2(items, registration));
-  });
-  const registrations3 = Ref16.get(registry);
-  const resolve3 = Effect62.fn("SchemaRegistry.resolve")(function* (ref) {
-    const items = yield* Ref16.get(registry);
+var layer43 = (initialRegistrations = []) => Layer56.effect(Service42, Effect63.gen(function* () {
+  const registry = yield* Ref17.make(initialRegistrations.reduce(upsertRegistration2, []));
+  const register8 = Effect63.fn("SchemaRegistry.register")(function* (registration) {
+    yield* Ref17.update(registry, (items) => upsertRegistration2(items, registration));
+  });
+  const registrations4 = Ref17.get(registry);
+  const resolve5 = Effect63.fn("SchemaRegistry.resolve")(function* (ref) {
+    const items = yield* Ref17.get(registry);
     const found = items.find((item) => item.ref === ref);
     if (found === undefined) {
-      return yield* Effect62.fail(new SchemaRefNotRegistered({ schema_ref: ref }));
+      return yield* Effect63.fail(new SchemaRefNotRegistered({ schema_ref: ref }));
     }
     return found;
   });
-  return Service41.of({ register: register7, registrations: registrations3, resolve: resolve3 });
+  return Service42.of({ register: register8, registrations: registrations4, resolve: resolve5 });
 }));
-var memoryLayer37 = layer42;
-var testLayer49 = (implementation) => Layer55.succeed(Service41, Service41.of(implementation));
-var register7 = Effect62.fn("SchemaRegistry.register.call")(function* (registration) {
-  const service = yield* Service41;
+var memoryLayer38 = layer43;
+var testLayer50 = (implementation) => Layer56.succeed(Service42, Service42.of(implementation));
+var register8 = Effect63.fn("SchemaRegistry.register.call")(function* (registration) {
+  const service = yield* Service42;
   return yield* service.register(registration);
 });
-var registrations3 = Effect62.fn("SchemaRegistry.registrations.call")(function* () {
-  const service = yield* Service41;
+var registrations4 = Effect63.fn("SchemaRegistry.registrations.call")(function* () {
+  const service = yield* Service42;
   return yield* service.registrations;
 });
-var resolve3 = Effect62.fn("SchemaRegistry.resolve.call")(function* (ref) {
-  const service = yield* Service41;
+var resolve5 = Effect63.fn("SchemaRegistry.resolve.call")(function* (ref) {
+  const service = yield* Service42;
   return yield* service.resolve(ref);
 });
 
 // ../runtime/src/content/blob-store-service.ts
 var exports_blob_store_service = {};
 __export(exports_blob_store_service, {
-  testLayer: () => testLayer50,
-  resolve: () => resolve4,
+  testLayer: () => testLayer51,
+  resolve: () => resolve6,
   put: () => put3,
   passthroughLayer: () => passthroughLayer,
-  memoryLayer: () => memoryLayer38,
-  Service: () => Service42,
+  memoryLayer: () => memoryLayer39,
+  Service: () => Service43,
   BlobStoreError: () => BlobStoreError,
   BlobNotResolvable: () => BlobNotResolvable
 });
-import { Context as Context55, Effect as Effect63, Layer as Layer56, Ref as Ref17, Schema as Schema70 } from "effect";
+import { Context as Context56, Effect as Effect64, Layer as Layer57, Ref as Ref18, Schema as Schema71 } from "effect";
 
-class BlobNotResolvable extends Schema70.TaggedErrorClass()("BlobNotResolvable", {
-  uri: Schema70.String,
-  reason: Schema70.String
+class BlobNotResolvable extends Schema71.TaggedErrorClass()("BlobNotResolvable", {
+  uri: Schema71.String,
+  reason: Schema71.String
 }) {
 }
 
-class BlobStoreError extends Schema70.TaggedErrorClass()("BlobStoreError", {
-  message: Schema70.String
+class BlobStoreError extends Schema71.TaggedErrorClass()("BlobStoreError", {
+  message: Schema71.String
 }) {
 }
 
-class Service42 extends Context55.Service()("@relayfx/runtime/BlobStore") {
+class Service43 extends Context56.Service()("@relayfx/runtime/BlobStore") {
 }
 var urlResolution = (part) => ({
   _tag: "Url",
@@ -14262,18 +14494,18 @@ var urlResolution = (part) => ({
   ...part.filename === undefined ? {} : { fileName: part.filename }
 });
 var passthroughInterface = {
-  resolve: (part) => Effect63.succeed(urlResolution(part)),
-  put: () => Effect63.fail(new BlobStoreError({ message: "BlobStore.put is not supported by the passthrough store" }))
+  resolve: (part) => Effect64.succeed(urlResolution(part)),
+  put: () => Effect64.fail(new BlobStoreError({ message: "BlobStore.put is not supported by the passthrough store" }))
 };
-var passthroughLayer = Layer56.succeed(Service42, Service42.of(passthroughInterface));
-var memoryLayer38 = Layer56.effect(Service42, Effect63.gen(function* () {
-  const counter = yield* Ref17.make(0);
+var passthroughLayer = Layer57.succeed(Service43, Service43.of(passthroughInterface));
+var memoryLayer39 = Layer57.effect(Service43, Effect64.gen(function* () {
+  const counter = yield* Ref18.make(0);
   const blobs = new Map;
-  return Service42.of({
-    resolve: Effect63.fn("BlobStore.memory.resolve")(function* (part) {
+  return Service43.of({
+    resolve: Effect64.fn("BlobStore.memory.resolve")(function* (part) {
       const blob = blobs.get(part.uri);
       if (blob === undefined) {
-        return yield* Effect63.fail(new BlobNotResolvable({ uri: part.uri, reason: "unknown blob uri" }));
+        return yield* Effect64.fail(new BlobNotResolvable({ uri: part.uri, reason: "unknown blob uri" }));
       }
       return {
         _tag: "Bytes",
@@ -14282,10 +14514,10 @@ var memoryLayer38 = Layer56.effect(Service42, Effect63.gen(function* () {
         ...blob.fileName === undefined ? {} : { fileName: blob.fileName }
       };
     }),
-    put: Effect63.fn("BlobStore.memory.put")(function* (input) {
-      const next = yield* Ref17.updateAndGet(counter, (value) => value + 1);
+    put: Effect64.fn("BlobStore.memory.put")(function* (input) {
+      const next = yield* Ref18.updateAndGet(counter, (value) => value + 1);
       const uri = `memory://blob/${next}`;
-      yield* Effect63.sync(() => blobs.set(uri, {
+      yield* Effect64.sync(() => blobs.set(uri, {
         bytes: input.bytes,
         mediaType: input.mediaType,
         ...input.fileName === undefined ? {} : { fileName: input.fileName }
@@ -14300,48 +14532,48 @@ var memoryLayer38 = Layer56.effect(Service42, Effect63.gen(function* () {
     })
   });
 }));
-var testLayer50 = (implementation) => Layer56.succeed(Service42, Service42.of(implementation));
-var resolve4 = Effect63.fn("BlobStore.resolve.call")(function* (part) {
-  const service = yield* Service42;
+var testLayer51 = (implementation) => Layer57.succeed(Service43, Service43.of(implementation));
+var resolve6 = Effect64.fn("BlobStore.resolve.call")(function* (part) {
+  const service = yield* Service43;
   return yield* service.resolve(part);
 });
-var put3 = Effect63.fn("BlobStore.put.call")(function* (input) {
-  const service = yield* Service42;
+var put3 = Effect64.fn("BlobStore.put.call")(function* (input) {
+  const service = yield* Service43;
   return yield* service.put(input);
 });
 
 // ../runtime/src/skill/skill-registry-service.ts
 var exports_skill_registry_service = {};
 __export(exports_skill_registry_service, {
-  testLayer: () => testLayer51,
+  testLayer: () => testLayer52,
   sourceLayerForExecution: () => sourceLayerForExecution,
   sourceForExecution: () => sourceForExecution,
-  register: () => register8,
+  register: () => register9,
   pinExecution: () => pinExecution2,
   listRevisions: () => listRevisions4,
   listPins: () => listPins2,
   list: () => list15,
-  layer: () => layer43,
+  layer: () => layer44,
   getRevision: () => getRevision4,
   getPinned: () => getPinned2,
   get: () => get14,
   SkillRegistryError: () => SkillRegistryError,
   SkillDefinitionInvalid: () => SkillDefinitionInvalid,
-  Service: () => Service43
+  Service: () => Service44
 });
-import { Clock as Clock6, Context as Context56, Effect as Effect64, Layer as Layer57, Schema as Schema71 } from "effect";
+import { Clock as Clock6, Context as Context57, Effect as Effect65, Layer as Layer58, Schema as Schema72 } from "effect";
 
-class SkillDefinitionInvalid extends Schema71.TaggedErrorClass()("SkillDefinitionInvalid", {
-  message: Schema71.String
+class SkillDefinitionInvalid extends Schema72.TaggedErrorClass()("SkillDefinitionInvalid", {
+  message: Schema72.String
 }) {
 }
 
-class SkillRegistryError extends Schema71.TaggedErrorClass()("SkillRegistryError", {
-  message: Schema71.String
+class SkillRegistryError extends Schema72.TaggedErrorClass()("SkillRegistryError", {
+  message: Schema72.String
 }) {
 }
 
-class Service43 extends Context56.Service()("@relayfx/runtime/SkillRegistry") {
+class Service44 extends Context57.Service()("@relayfx/runtime/SkillRegistry") {
 }
 var toPublicRecord2 = (record2) => ({
   id: record2.id,
@@ -14364,9 +14596,9 @@ var toPublicPinRecord = (record2) => ({
   created_at: record2.createdAt
 });
 var mapRepositoryError7 = (error5) => new SkillRegistryError({ message: error5.message });
-var requireText2 = (value, field) => value.trim().length === 0 ? Effect64.fail(new SkillDefinitionInvalid({ message: `${field} must not be blank` })) : Effect64.void;
-var requireOptionalText2 = (value, field) => value === undefined || value.trim().length > 0 ? Effect64.void : Effect64.fail(new SkillDefinitionInvalid({ message: `${field} must not be blank` }));
-var validateDefinition2 = Effect64.fn("SkillRegistry.validateDefinition")(function* (definition) {
+var requireText2 = (value, field) => value.trim().length === 0 ? Effect65.fail(new SkillDefinitionInvalid({ message: `${field} must not be blank` })) : Effect65.void;
+var requireOptionalText2 = (value, field) => value === undefined || value.trim().length > 0 ? Effect65.void : Effect65.fail(new SkillDefinitionInvalid({ message: `${field} must not be blank` }));
+var validateDefinition2 = Effect65.fn("SkillRegistry.validateDefinition")(function* (definition) {
   yield* requireText2(definition.frontmatter.name, "definition.frontmatter.name");
   yield* requireText2(definition.frontmatter.description, "definition.frontmatter.description");
   yield* requireOptionalText2(definition.frontmatter.when_to_use, "definition.frontmatter.when_to_use");
@@ -14397,124 +14629,124 @@ var toBatonSkill = (pin) => {
   return {
     frontmatter,
     listing: exports_skill_source.makeListing(frontmatter),
-    body: Effect64.succeed(pin.skill_definition_snapshot.body),
+    body: Effect65.succeed(pin.skill_definition_snapshot.body),
     tools: []
   };
 };
 var sourceError = (error5) => new exports_skill_source.SkillSourceError({ source: "relay.skill_registry", message: error5.message });
-var layer43 = Layer57.effect(Service43, Effect64.gen(function* () {
+var layer44 = Layer58.effect(Service44, Effect65.gen(function* () {
   const repository = yield* exports_skill_definition_repository.Service;
-  return Service43.of({
-    register: Effect64.fn("SkillRegistry.register")(function* (input) {
+  return Service44.of({
+    register: Effect65.fn("SkillRegistry.register")(function* (input) {
       yield* validateDefinition2(input.definition);
       const now = yield* Clock6.currentTimeMillis;
-      const record2 = yield* repository.put({ id: input.id, definition: input.definition, now }).pipe(Effect64.mapError(mapRepositoryError7));
+      const record2 = yield* repository.put({ id: input.id, definition: input.definition, now }).pipe(Effect65.mapError(mapRepositoryError7));
       return { record: toPublicRecord2(record2) };
     }),
-    get: Effect64.fn("SkillRegistry.get")(function* (id2) {
-      const record2 = yield* repository.get(id2).pipe(Effect64.mapError(mapRepositoryError7));
+    get: Effect65.fn("SkillRegistry.get")(function* (id2) {
+      const record2 = yield* repository.get(id2).pipe(Effect65.mapError(mapRepositoryError7));
       return record2 === undefined ? undefined : toPublicRecord2(record2);
     }),
-    getRevision: Effect64.fn("SkillRegistry.getRevision")(function* (input) {
-      const record2 = yield* repository.getRevision(input).pipe(Effect64.mapError(mapRepositoryError7));
+    getRevision: Effect65.fn("SkillRegistry.getRevision")(function* (input) {
+      const record2 = yield* repository.getRevision(input).pipe(Effect65.mapError(mapRepositoryError7));
       return record2 === undefined ? undefined : toPublicRevisionRecord2(record2);
     }),
-    list: Effect64.fn("SkillRegistry.list")(function* () {
-      const records = yield* repository.list().pipe(Effect64.mapError(mapRepositoryError7));
+    list: Effect65.fn("SkillRegistry.list")(function* () {
+      const records = yield* repository.list().pipe(Effect65.mapError(mapRepositoryError7));
       return { records: records.map(toPublicRecord2) };
     }),
-    listRevisions: Effect64.fn("SkillRegistry.listRevisions")(function* (id2) {
-      const records = yield* repository.listRevisions(id2).pipe(Effect64.mapError(mapRepositoryError7));
+    listRevisions: Effect65.fn("SkillRegistry.listRevisions")(function* (id2) {
+      const records = yield* repository.listRevisions(id2).pipe(Effect65.mapError(mapRepositoryError7));
       return { records: records.map(toPublicRevisionRecord2) };
     }),
-    pinExecution: Effect64.fn("SkillRegistry.pinExecution")(function* (input) {
+    pinExecution: Effect65.fn("SkillRegistry.pinExecution")(function* (input) {
       const now = yield* Clock6.currentTimeMillis;
       const records = yield* repository.pinExecution({
         executionId: input.execution_id,
         skillDefinitionIds: input.skill_definition_ids,
         now
-      }).pipe(Effect64.mapError(mapRepositoryError7));
+      }).pipe(Effect65.mapError(mapRepositoryError7));
       return { records: records.map(toPublicPinRecord) };
     }),
-    listPins: Effect64.fn("SkillRegistry.listPins")(function* (executionId) {
-      const records = yield* repository.listPins(executionId).pipe(Effect64.mapError(mapRepositoryError7));
+    listPins: Effect65.fn("SkillRegistry.listPins")(function* (executionId) {
+      const records = yield* repository.listPins(executionId).pipe(Effect65.mapError(mapRepositoryError7));
       return { records: records.map(toPublicPinRecord) };
     }),
-    getPinned: Effect64.fn("SkillRegistry.getPinned")(function* (input) {
-      const record2 = yield* repository.getPinned(input).pipe(Effect64.mapError(mapRepositoryError7));
+    getPinned: Effect65.fn("SkillRegistry.getPinned")(function* (input) {
+      const record2 = yield* repository.getPinned(input).pipe(Effect65.mapError(mapRepositoryError7));
       return record2 === undefined ? undefined : toPublicPinRecord(record2);
     })
   });
 }));
-var testLayer51 = (implementation) => Layer57.succeed(Service43, Service43.of(implementation));
-var register8 = Effect64.fn("SkillRegistry.register.call")(function* (input) {
-  const service = yield* Service43;
+var testLayer52 = (implementation) => Layer58.succeed(Service44, Service44.of(implementation));
+var register9 = Effect65.fn("SkillRegistry.register.call")(function* (input) {
+  const service = yield* Service44;
   return yield* service.register(input);
 });
-var get14 = Effect64.fn("SkillRegistry.get.call")(function* (id2) {
-  const service = yield* Service43;
+var get14 = Effect65.fn("SkillRegistry.get.call")(function* (id2) {
+  const service = yield* Service44;
   return yield* service.get(id2);
 });
-var getRevision4 = Effect64.fn("SkillRegistry.getRevision.call")(function* (input) {
-  const service = yield* Service43;
+var getRevision4 = Effect65.fn("SkillRegistry.getRevision.call")(function* (input) {
+  const service = yield* Service44;
   return yield* service.getRevision(input);
 });
-var list15 = Effect64.fn("SkillRegistry.list.call")(function* () {
-  const service = yield* Service43;
+var list15 = Effect65.fn("SkillRegistry.list.call")(function* () {
+  const service = yield* Service44;
   return yield* service.list();
 });
-var listRevisions4 = Effect64.fn("SkillRegistry.listRevisions.call")(function* (id2) {
-  const service = yield* Service43;
+var listRevisions4 = Effect65.fn("SkillRegistry.listRevisions.call")(function* (id2) {
+  const service = yield* Service44;
   return yield* service.listRevisions(id2);
 });
-var pinExecution2 = Effect64.fn("SkillRegistry.pinExecution.call")(function* (input) {
-  const service = yield* Service43;
+var pinExecution2 = Effect65.fn("SkillRegistry.pinExecution.call")(function* (input) {
+  const service = yield* Service44;
   return yield* service.pinExecution(input);
 });
-var listPins2 = Effect64.fn("SkillRegistry.listPins.call")(function* (executionId) {
-  const service = yield* Service43;
+var listPins2 = Effect65.fn("SkillRegistry.listPins.call")(function* (executionId) {
+  const service = yield* Service44;
   return yield* service.listPins(executionId);
 });
-var getPinned2 = Effect64.fn("SkillRegistry.getPinned.call")(function* (input) {
-  const service = yield* Service43;
+var getPinned2 = Effect65.fn("SkillRegistry.getPinned.call")(function* (input) {
+  const service = yield* Service44;
   return yield* service.getPinned(input);
 });
-var sourceForExecution = Effect64.fn("SkillRegistry.sourceForExecution.call")(function* (executionId) {
-  const service = yield* Service43;
-  const pins = yield* service.listPins(executionId).pipe(Effect64.mapError(sourceError));
+var sourceForExecution = Effect65.fn("SkillRegistry.sourceForExecution.call")(function* (executionId) {
+  const service = yield* Service44;
+  const pins = yield* service.listPins(executionId).pipe(Effect65.mapError(sourceError));
   const skills = pins.records.map(toBatonSkill);
   const byName = new Map(skills.map((skill) => [skill.frontmatter.name, skill]));
   return exports_skill_source.SkillSource.of({
-    all: Effect64.succeed(skills),
-    get: (name) => Effect64.succeed(byName.get(name))
+    all: Effect65.succeed(skills),
+    get: (name) => Effect65.succeed(byName.get(name))
   });
 });
-var sourceLayerForExecution = (executionId) => Layer57.effect(exports_skill_source.SkillSource, sourceForExecution(executionId));
+var sourceLayerForExecution = (executionId) => Layer58.effect(exports_skill_source.SkillSource, sourceForExecution(executionId));
 
 // ../runtime/src/execution/execution-service.ts
 var exports_execution_service = {};
 __export(exports_execution_service, {
-  testLayer: () => testLayer52,
+  testLayer: () => testLayer53,
   stream: () => stream3,
   spawnChildRun: () => spawnChildRun,
   send: () => send,
   run: () => run2,
-  memoryLayer: () => memoryLayer39,
-  layer: () => layer44,
+  memoryLayer: () => memoryLayer40,
+  layer: () => layer45,
   cancel: () => cancel4,
   accept: () => accept,
-  Service: () => Service44,
+  Service: () => Service45,
   ExecutionServiceError: () => ExecutionServiceError
 });
-import { Clock as Clock7, Context as Context57, Effect as Effect65, Layer as Layer58, Option as Option21, Schema as Schema72, Stream as Stream11 } from "effect";
+import { Clock as Clock7, Context as Context58, Effect as Effect66, Layer as Layer59, Option as Option21, Schema as Schema73, Stream as Stream11 } from "effect";
 import { ShardingConfig } from "effect/unstable/cluster";
-class ExecutionServiceError extends Schema72.TaggedErrorClass()("ExecutionServiceError", {
-  message: Schema72.String,
-  next_event_sequence: Schema72.optionalKey(exports_execution_schema.ExecutionEventSequence)
+class ExecutionServiceError extends Schema73.TaggedErrorClass()("ExecutionServiceError", {
+  message: Schema73.String,
+  next_event_sequence: Schema73.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
-class Service44 extends Context57.Service()("@relayfx/runtime/ExecutionService") {
+class Service45 extends Context58.Service()("@relayfx/runtime/ExecutionService") {
 }
 var toExecution = (record2) => ({
   id: record2.id,
@@ -14538,11 +14770,11 @@ var hasCompleteAgentDefinitionPin2 = (input) => {
   const count = present.filter(Boolean).length;
   return count === 0 || count === present.length;
 };
-var validateAcceptInput = (input) => !hasCompleteAgentDefinitionPin2(input) ? Effect65.fail(new ExecutionServiceError({
+var validateAcceptInput = (input) => !hasCompleteAgentDefinitionPin2(input) ? Effect66.fail(new ExecutionServiceError({
   message: "agent pin must include id, revision, and snapshot together"
-})) : input.agentToolInputSchemaDigests !== undefined && input.agentId === undefined ? Effect65.fail(new ExecutionServiceError({
+})) : input.agentToolInputSchemaDigests !== undefined && input.agentId === undefined ? Effect66.fail(new ExecutionServiceError({
   message: "agent tool input schema digests require a complete agent pin"
-})) : Effect65.void;
+})) : Effect66.void;
 var childContext = (input) => ({
   toolNames: input.tool_names,
   permissions: input.permissions,
@@ -14578,13 +14810,13 @@ var dynamicOverride = (input) => {
   });
 };
 var presetMap = (presets) => new Map(Object.entries(presets ?? {}).map(([name, preset]) => [name, childOverride(preset)]));
-var nextEventSequence = Effect65.fn("ExecutionService.nextEventSequence")(function* (eventLog, input) {
+var nextEventSequence = Effect66.fn("ExecutionService.nextEventSequence")(function* (eventLog, input) {
   if (input.event_sequence !== undefined)
     return input.event_sequence;
-  const max = yield* eventLog.maxSequence(input.execution_id).pipe(Effect65.mapError(mapEventLogError4));
+  const max = yield* eventLog.maxSequence(input.execution_id).pipe(Effect66.mapError(mapEventLogError4));
   return max === undefined ? 0 : max + 1;
 });
-var childRunBaseInput = Effect65.fn("ExecutionService.childRunBaseInput")(function* (eventLog, input) {
+var childRunBaseInput = Effect66.fn("ExecutionService.childRunBaseInput")(function* (eventLog, input) {
   const eventSequence = yield* nextEventSequence(eventLog, input);
   const createdAt = input.created_at ?? (yield* Clock7.currentTimeMillis);
   return {
@@ -14645,8 +14877,8 @@ var failedEvent = (input, error5) => ({
   created_at: input.completedAt
 });
 var terminalEvent = (events) => events.find((event) => event.type === "execution.completed" || event.type === "execution.failed");
-var existingTerminalExecution = Effect65.fn("ExecutionService.existingTerminalExecution")(function* (repository, eventLog, input) {
-  const events = yield* eventLog.replay({ executionId: input.executionId }).pipe(Effect65.mapError(mapEventLogError4));
+var existingTerminalExecution = Effect66.fn("ExecutionService.existingTerminalExecution")(function* (repository, eventLog, input) {
+  const events = yield* eventLog.replay({ executionId: input.executionId }).pipe(Effect66.mapError(mapEventLogError4));
   const event = terminalEvent(events);
   if (event === undefined)
     return;
@@ -14673,26 +14905,26 @@ var cancelledEvent = (input) => ({
   data: input.reason === undefined ? {} : { reason: input.reason },
   created_at: input.cancelledAt
 });
-var updateStatus2 = Effect65.fn("ExecutionService.updateStatus")(function* (repository, id2, status, updatedAt, metadata10) {
+var updateStatus2 = Effect66.fn("ExecutionService.updateStatus")(function* (repository, id2, status, updatedAt, metadata10) {
   const record2 = yield* repository.transition({
     id: id2,
     status,
     updatedAt,
     ...metadata10 === undefined ? {} : { metadata: metadata10 }
-  }).pipe(Effect65.mapError(mapRepositoryError8));
+  }).pipe(Effect66.mapError(mapRepositoryError8));
   return toExecution(record2);
 });
-var layer44 = Layer58.effect(Service44, Effect65.gen(function* () {
+var layer45 = Layer59.effect(Service45, Effect66.gen(function* () {
   const repository = yield* exports_execution_repository.Service;
   const eventLog = yield* Service30;
   const childRuns = yield* Service37;
   const shardingConfig = yield* ShardingConfig.ShardingConfig;
-  const sessions = yield* Effect65.serviceOption(exports_session_repository.Service);
+  const sessions = yield* Effect66.serviceOption(exports_session_repository.Service);
   const runnerAddress = runnerAddressOf(shardingConfig);
-  return Service44.of({
-    accept: Effect65.fn("ExecutionService.accept")(function* (input) {
+  return Service45.of({
+    accept: Effect66.fn("ExecutionService.accept")(function* (input) {
       yield* validateAcceptInput(input);
-      yield* Effect65.annotateCurrentSpan({
+      yield* Effect66.annotateCurrentSpan({
         "relay.execution.id": input.executionId,
         "relay.address.root": input.rootAddressId
       });
@@ -14701,7 +14933,7 @@ var layer44 = Layer58.effect(Service44, Effect65.gen(function* () {
           id: input.sessionId,
           rootAddressId: input.rootAddressId,
           now: input.createdAt
-        }).pipe(Effect65.mapError((error5) => new ExecutionServiceError({ message: error5.message })));
+        }).pipe(Effect66.mapError((error5) => new ExecutionServiceError({ message: error5.message })));
       }
       const record2 = yield* repository.create({
         id: input.executionId,
@@ -14714,33 +14946,33 @@ var layer44 = Layer58.effect(Service44, Effect65.gen(function* () {
         ...input.agentSnapshot === undefined ? {} : { agentSnapshot: input.agentSnapshot },
         ...input.agentToolInputSchemaDigests === undefined ? {} : { agentToolInputSchemaDigests: input.agentToolInputSchemaDigests },
         ...input.metadata === undefined ? {} : { metadata: input.metadata }
-      }).pipe(Effect65.mapError(mapRepositoryError8));
-      yield* eventLog.append(acceptedEvent(input)).pipe(Effect65.mapError(mapEventLogError4));
+      }).pipe(Effect66.mapError(mapRepositoryError8));
+      yield* eventLog.append(acceptedEvent(input)).pipe(Effect66.mapError(mapEventLogError4));
       yield* recordExecutionAccepted;
       return toExecution(record2);
     }),
-    run: Effect65.fn("ExecutionService.run")(function* (input) {
-      yield* Effect65.annotateCurrentSpan("relay.execution.id", input.executionId);
+    run: Effect66.fn("ExecutionService.run")(function* (input) {
+      yield* Effect66.annotateCurrentSpan("relay.execution.id", input.executionId);
       const existing = yield* existingTerminalExecution(repository, eventLog, input);
       if (existing?.execution !== undefined)
         return existing.execution;
       if (existing?.failure !== undefined)
-        return yield* Effect65.fail(existing.failure);
+        return yield* Effect66.fail(existing.failure);
       yield* updateStatus2(repository, input.executionId, "running", input.startedAt, undefined);
-      yield* appendIdempotentTo(eventLog, startedEvent(input, runnerAddress)).pipe(Effect65.mapError(mapEventLogError4));
-      return yield* input.program.pipe(Effect65.matchEffect({
-        onFailure: (error5) => Effect65.gen(function* () {
+      yield* appendIdempotentTo(eventLog, startedEvent(input, runnerAddress)).pipe(Effect66.mapError(mapEventLogError4));
+      return yield* input.program.pipe(Effect66.matchEffect({
+        onFailure: (error5) => Effect66.gen(function* () {
           const failedExecution = yield* updateStatus2(repository, input.executionId, "failed", input.completedAt, {
             message: error5.message
           });
           if (failedExecution.status !== "failed")
             return failedExecution;
-          yield* appendIdempotentTo(eventLog, failedEvent(input, error5)).pipe(Effect65.mapError(mapEventLogError4));
+          yield* appendIdempotentTo(eventLog, failedEvent(input, error5)).pipe(Effect66.mapError(mapEventLogError4));
           yield* recordExecutionFinished("failed");
           yield* recordExecutionDuration("failed", failedExecution.updated_at - failedExecution.created_at);
-          return yield* Effect65.fail(error5);
+          return yield* Effect66.fail(error5);
         }),
-        onSuccess: (result) => Effect65.gen(function* () {
+        onSuccess: (result) => Effect66.gen(function* () {
           const resultMetadata = result.metadata ?? {};
           if (result._tag === "waiting") {
             const execution2 = yield* updateStatus2(repository, input.executionId, "waiting", input.completedAt, resultMetadata);
@@ -14750,31 +14982,31 @@ var layer44 = Layer58.effect(Service44, Effect65.gen(function* () {
           const execution = yield* updateStatus2(repository, input.executionId, "completed", input.completedAt, resultMetadata);
           if (execution.status !== "completed")
             return execution;
-          yield* appendIdempotentTo(eventLog, completedEvent(input, resultMetadata, completedSequence)).pipe(Effect65.mapError(mapEventLogError4));
+          yield* appendIdempotentTo(eventLog, completedEvent(input, resultMetadata, completedSequence)).pipe(Effect66.mapError(mapEventLogError4));
           yield* recordExecutionFinished("completed");
           yield* recordExecutionDuration("completed", execution.updated_at - execution.created_at);
           return execution;
         })
       }));
     }),
-    cancel: Effect65.fn("ExecutionService.cancel")(function* (input) {
-      yield* Effect65.annotateCurrentSpan("relay.execution.id", input.executionId);
-      const current2 = yield* repository.get(input.executionId).pipe(Effect65.mapError(mapRepositoryError8));
+    cancel: Effect66.fn("ExecutionService.cancel")(function* (input) {
+      yield* Effect66.annotateCurrentSpan("relay.execution.id", input.executionId);
+      const current2 = yield* repository.get(input.executionId).pipe(Effect66.mapError(mapRepositoryError8));
       if (current2?.status === "cancelled")
         return toExecution(current2);
       const metadata10 = input.metadata ?? (input.reason === undefined ? {} : { reason: input.reason });
       const execution = yield* updateStatus2(repository, input.executionId, "cancelled", input.cancelledAt, metadata10);
       if (execution.status !== "cancelled")
         return execution;
-      yield* appendIdempotentTo(eventLog, cancelledEvent(input)).pipe(Effect65.mapError(mapEventLogError4));
+      yield* appendIdempotentTo(eventLog, cancelledEvent(input)).pipe(Effect66.mapError(mapEventLogError4));
       yield* recordExecutionFinished("cancelled");
       yield* recordExecutionDuration("cancelled", execution.updated_at - execution.created_at);
       return execution;
     }),
-    send: Effect65.fn("ExecutionService.send")(function* (input) {
+    send: Effect66.fn("ExecutionService.send")(function* (input) {
       const executionId = exports_ids_schema.ExecutionId.make(input.correlation_key ?? `${input.from}:${input.to}`);
       const envelopeId = exports_ids_schema.EnvelopeId.make(`${executionId}:envelope`);
-      yield* Effect65.annotateCurrentSpan({
+      yield* Effect66.annotateCurrentSpan({
         "relay.execution.id": executionId,
         "relay.envelope.id": envelopeId,
         "relay.address.from": input.from,
@@ -14788,11 +15020,11 @@ var layer44 = Layer58.effect(Service44, Effect65.gen(function* () {
         cursor: `${executionId}:envelope:${envelopeId}:accepted`,
         content: input.content,
         created_at: 0
-      }).pipe(Effect65.mapError(mapEventLogError4));
+      }).pipe(Effect66.mapError(mapEventLogError4));
       return { envelope_id: envelopeId, execution_id: executionId };
     }),
-    spawnChildRun: Effect65.fn("ExecutionService.spawnChildRun")(function* (input) {
-      yield* Effect65.annotateCurrentSpan({
+    spawnChildRun: Effect66.fn("ExecutionService.spawnChildRun")(function* (input) {
+      yield* Effect66.annotateCurrentSpan({
         "relay.execution.id": input.execution_id,
         "relay.address.id": input.address_id
       });
@@ -14802,13 +15034,13 @@ var layer44 = Layer58.effect(Service44, Effect65.gen(function* () {
           ...baseInput,
           presets: presetMap(input.presets),
           presetName: input.preset_name
-        }).pipe(Effect65.mapError(mapChildRunError));
+        }).pipe(Effect66.mapError(mapChildRunError));
       }
       const override = dynamicOverride(input);
       return yield* childRuns.spawnDynamic({
         ...baseInput,
         ...override === undefined ? {} : { override }
-      }).pipe(Effect65.mapError(mapChildRunError));
+      }).pipe(Effect66.mapError(mapChildRunError));
     }),
     stream: (input) => {
       const stream3 = eventLog.stream(input).pipe(Stream11.mapError((error5) => mapEventLogError4(error5)));
@@ -14816,29 +15048,29 @@ var layer44 = Layer58.effect(Service44, Effect65.gen(function* () {
     }
   });
 }));
-var memoryLayer39 = layer44.pipe(Layer58.provide(layer39), Layer58.provide(exports_execution_repository.memoryLayer), Layer58.provide(exports_session_repository.memoryLayer), Layer58.provide(exports_child_execution_repository.memoryLayer), Layer58.provide(memoryLayer29), Layer58.provide(ShardingConfig.layer({ runnerAddress: Option21.none() })));
-var testLayer52 = (implementation) => Layer58.succeed(Service44, Service44.of(implementation));
-var accept = Effect65.fn("ExecutionService.accept.call")(function* (input) {
-  const service = yield* Service44;
+var memoryLayer40 = layer45.pipe(Layer59.provide(layer39), Layer59.provide(exports_execution_repository.memoryLayer), Layer59.provide(exports_session_repository.memoryLayer), Layer59.provide(exports_child_execution_repository.memoryLayer), Layer59.provide(memoryLayer29), Layer59.provide(ShardingConfig.layer({ runnerAddress: Option21.none() })));
+var testLayer53 = (implementation) => Layer59.succeed(Service45, Service45.of(implementation));
+var accept = Effect66.fn("ExecutionService.accept.call")(function* (input) {
+  const service = yield* Service45;
   return yield* service.accept(input);
 });
-var run2 = Effect65.fn("ExecutionService.run.call")(function* (input) {
-  const service = yield* Service44;
+var run2 = Effect66.fn("ExecutionService.run.call")(function* (input) {
+  const service = yield* Service45;
   return yield* service.run(input);
 });
-var cancel4 = Effect65.fn("ExecutionService.cancel.call")(function* (input) {
-  const service = yield* Service44;
+var cancel4 = Effect66.fn("ExecutionService.cancel.call")(function* (input) {
+  const service = yield* Service45;
   return yield* service.cancel(input);
 });
-var send = Effect65.fn("ExecutionService.send.call")(function* (input) {
-  const service = yield* Service44;
+var send = Effect66.fn("ExecutionService.send.call")(function* (input) {
+  const service = yield* Service45;
   return yield* service.send(input);
 });
-var spawnChildRun = Effect65.fn("ExecutionService.spawnChildRun.call")(function* (input) {
-  const service = yield* Service44;
+var spawnChildRun = Effect66.fn("ExecutionService.spawnChildRun.call")(function* (input) {
+  const service = yield* Service45;
   return yield* service.spawnChildRun(input);
 });
-var stream3 = (input) => Stream11.unwrap(Service44.pipe(Effect65.map((service) => service.stream(input))));
+var stream3 = (input) => Stream11.unwrap(Service45.pipe(Effect66.map((service) => service.stream(input))));
 
 // ../runtime/src/workflow/execution-workflow.ts
 var exports_execution_workflow = {};
@@ -14876,7 +15108,7 @@ import { Effect as Effect93, Exit as Exit2, Option as Option28, Schema as Schema
 var exports_agent_loop_service = {};
 __export(exports_agent_loop_service, {
   toolFromDefinition: () => toolFromDefinition,
-  testLayer: () => testLayer58,
+  testLayer: () => testLayer59,
   run: () => run4,
   mapBoundaryError: () => mapBoundaryError,
   layer: () => layer57,
@@ -14890,44 +15122,53 @@ import { Cause as Cause5, Config as Config4, Context as Context67, Crypto as Cry
 import { AiError as AiError5, Chat as Chat3, LanguageModel as LanguageModel7, Prompt as Prompt16, Tokenizer as Tokenizer4, Toolkit as Toolkit8 } from "effect/unstable/ai";
 
 // ../runtime/src/child/spawn-child-run-tool.ts
-import { Effect as Effect66, Schema as Schema73 } from "effect";
+import { Effect as Effect67, Schema as Schema74 } from "effect";
 var toolName2 = "spawn_child_run";
 var permissionName2 = "relay.child_run.spawn";
-var Input2 = Schema73.Struct({
-  preset_name: Schema73.optionalKey(exports_shared_schema.NonEmptyString),
-  instructions: Schema73.optionalKey(Schema73.String),
-  model: Schema73.optionalKey(exports_agent_schema.ModelSelection),
-  compaction_policy: Schema73.optionalKey(exports_agent_schema.CompactionPolicy),
-  tool_names: Schema73.optionalKey(Schema73.Array(Schema73.String)),
-  permissions: Schema73.optionalKey(Schema73.Array(Schema73.String)),
-  output_schema_ref: Schema73.optionalKey(Schema73.String),
-  metadata: Schema73.optionalKey(exports_shared_schema.Metadata),
-  input: Schema73.optionalKey(Schema73.Array(exports_content_schema.Part))
+var Input2 = Schema74.Struct({
+  preset_name: Schema74.optionalKey(exports_shared_schema.NonEmptyString),
+  instructions: Schema74.optionalKey(Schema74.String),
+  model: Schema74.optionalKey(exports_agent_schema.ModelSelection),
+  compaction_policy: Schema74.optionalKey(exports_agent_schema.CompactionPolicy),
+  tool_names: Schema74.optionalKey(Schema74.Array(Schema74.String)),
+  permissions: Schema74.optionalKey(Schema74.Array(Schema74.String)),
+  output_schema_ref: Schema74.optionalKey(Schema74.String),
+  metadata: Schema74.optionalKey(exports_shared_schema.Metadata),
+  input: Schema74.optionalKey(Schema74.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Input" });
-var Output2 = Schema73.Struct({
+var Output2 = Schema74.Struct({
   child_execution_id: exports_ids_schema.ChildExecutionId,
-  status: Schema73.Literals(["completed", "failed", "cancelled"]),
-  output: Schema73.Array(exports_content_schema.Part)
+  status: Schema74.Literals(["completed", "failed", "cancelled"]),
+  output: Schema74.Array(exports_content_schema.Part)
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Output" });
-var TransferInput = Schema73.Struct({
-  input: Schema73.optionalKey(Schema73.Array(exports_content_schema.Part))
+var TransferInput = Schema74.Struct({
+  input: Schema74.optionalKey(Schema74.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.TransferInput" });
-var ModelInput = Schema73.Struct({
-  preset_name: Schema73.optionalKey(Schema73.NullOr(Schema73.String)),
-  instructions: Schema73.optionalKey(Schema73.String),
-  model: Schema73.optionalKey(Schema73.NullOr(Schema73.Struct({
-    provider: Schema73.String,
-    model: Schema73.String,
-    registration_key: Schema73.optionalKey(Schema73.String)
+var ModelInput = Schema74.Struct({
+  preset_name: Schema74.optionalKey(Schema74.NullOr(Schema74.String)),
+  instructions: Schema74.optionalKey(Schema74.String),
+  model: Schema74.optionalKey(Schema74.NullOr(Schema74.Struct({
+    provider: Schema74.String,
+    model: Schema74.String,
+    registration_key: Schema74.optionalKey(Schema74.String)
   }))),
-  compaction_policy: Schema73.optionalKey(exports_agent_schema.CompactionPolicy),
-  tool_names: Schema73.optionalKey(Schema73.Array(Schema73.String)),
-  permissions: Schema73.optionalKey(Schema73.Array(Schema73.String)),
-  output_schema_ref: Schema73.optionalKey(Schema73.NullOr(Schema73.String)),
-  input: Schema73.optionalKey(Schema73.Array(Schema73.Struct({ type: Schema73.Literal("text"), text: Schema73.String })))
+  compaction_policy: Schema74.optionalKey(Schema74.Struct({
+    context_window: Schema74.Number,
+    reserve_tokens: Schema74.Number,
+    keep_recent_tokens: Schema74.Number,
+    summary_model: Schema74.optionalKey(Schema74.Struct({
+      provider: Schema74.String,
+      model: Schema74.String,
+      registration_key: Schema74.optionalKey(Schema74.String)
+    }))
+  })),
+  tool_names: Schema74.optionalKey(Schema74.Array(Schema74.String)),
+  permissions: Schema74.optionalKey(Schema74.Array(Schema74.String)),
+  output_schema_ref: Schema74.optionalKey(Schema74.NullOr(Schema74.String)),
+  input: Schema74.optionalKey(Schema74.Array(Schema74.Struct({ type: Schema74.Literal("text"), text: Schema74.String })))
 });
-var ModelTransferInput = Schema73.Struct({
-  input: Schema73.optionalKey(Schema73.Array(Schema73.Struct({ type: Schema73.Literal("text"), text: Schema73.String })))
+var ModelTransferInput = Schema74.Struct({
+  input: Schema74.optionalKey(Schema74.Array(Schema74.Struct({ type: Schema74.Literal("text"), text: Schema74.String })))
 });
 var normalizeModelInput = (input) => {
   const { preset_name: presetName, model, output_schema_ref: outputSchemaRef, ...rest } = input;
@@ -14961,7 +15202,7 @@ var hasDynamicOverride = (input) => input.instructions !== undefined || input.mo
 var childExecutionId2 = (context) => exports_ids_schema.ChildExecutionId.make(`${context.executionId}:child:${context.call.id}`);
 var childAddressId = (id2) => exports_ids_schema.AddressId.make(`address:child:${id2}`);
 var childWaitId = (id2) => exports_ids_schema.WaitId.make(`wait:child:${id2}`);
-var nextEventSequence2 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect66.map((max) => max === undefined ? 0 : max + 1), Effect66.mapError((error5) => new ToolRuntimeError({ message: error5.message })));
+var nextEventSequence2 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect67.map((max) => max === undefined ? 0 : max + 1), Effect67.mapError((error5) => new ToolRuntimeError({ message: error5.message })));
 var mapChildRunError2 = (activeToolName, error5) => new ToolExecutionFailed({ tool_name: activeToolName, message: error5._tag });
 var mapWaitError = (error5) => new ToolRuntimeError({ message: error5._tag === "WaitNotFound" ? error5.wait_id : error5.message });
 var spawnInput = (config, input, context, id2) => ({
@@ -14983,10 +15224,10 @@ var spawnInput = (config, input, context, id2) => ({
   event_sequence: context.eventSequence + 1,
   created_at: context.createdAt + 1
 });
-var ensureStaticOrDynamic = (input) => input.preset_name !== undefined && hasDynamicOverride(input) ? Effect66.fail(new ToolExecutionFailed({
+var ensureStaticOrDynamic = (input) => input.preset_name !== undefined && hasDynamicOverride(input) ? Effect67.fail(new ToolExecutionFailed({
   tool_name: toolName2,
   message: "preset_name cannot be combined with dynamic child-run overrides"
-})) : Effect66.void;
+})) : Effect67.void;
 var childOverride2 = (input) => {
   if (!hasDynamicOverride(input))
     return;
@@ -15013,7 +15254,7 @@ var presetMap2 = (agent) => new Map(Object.entries(agent.child_run_presets ?? {}
     ...preset.metadata === undefined ? {} : { metadata: preset.metadata }
   }
 ]));
-var createJoinWait = Effect66.fn("SpawnChildRunTool.createJoinWait")(function* (config, input, id2, waitId, createdAt) {
+var createJoinWait = Effect67.fn("SpawnChildRunTool.createJoinWait")(function* (config, input, id2, waitId, createdAt) {
   const eventSequence = yield* nextEventSequence2(config.eventLog, input.execution_id);
   yield* config.waits.createDetached({
     waitId,
@@ -15026,9 +15267,9 @@ var createJoinWait = Effect66.fn("SpawnChildRunTool.createJoinWait")(function* (
     },
     eventSequence,
     createdAt
-  }).pipe(Effect66.mapError(mapWaitError));
+  }).pipe(Effect67.mapError(mapWaitError));
 });
-var dispatchChild = Effect66.fn("SpawnChildRunTool.dispatchChild")(function* (config, input, id2, definition, waitId) {
+var dispatchChild = Effect67.fn("SpawnChildRunTool.dispatchChild")(function* (config, input, id2, definition, waitId) {
   yield* config.dispatch({
     executionId: exports_ids_schema.ExecutionId.make(id2),
     rootAddressId: input.address_id,
@@ -15046,38 +15287,38 @@ var dispatchChild = Effect66.fn("SpawnChildRunTool.dispatchChild")(function* (co
       child_execution_id: id2,
       parent_wait_id: waitId
     }
-  }).pipe(Effect66.mapError((error5) => new ToolRuntimeError({ message: String(error5) })));
+  }).pipe(Effect67.mapError((error5) => new ToolRuntimeError({ message: String(error5) })));
 });
 var childStatus = (wait) => {
   const status = wait.metadata.child_status;
   if (status === "completed" || status === "failed" || status === "cancelled")
-    return Effect66.succeed(status);
-  return Effect66.fail(new ToolRuntimeError({ message: "Child join wait resolved without child_status" }));
+    return Effect67.succeed(status);
+  return Effect67.fail(new ToolRuntimeError({ message: "Child join wait resolved without child_status" }));
 };
-var terminalEvent2 = Effect66.fn("SpawnChildRunTool.terminalEvent")(function* (eventLog, executionId, id2) {
-  const events = yield* eventLog.replay({ executionId, limit: 1e4 }).pipe(Effect66.mapError((error5) => new ToolRuntimeError({ message: error5._tag })));
+var terminalEvent2 = Effect67.fn("SpawnChildRunTool.terminalEvent")(function* (eventLog, executionId, id2) {
+  const events = yield* eventLog.replay({ executionId, limit: 1e4 }).pipe(Effect67.mapError((error5) => new ToolRuntimeError({ message: error5._tag })));
   return events.find((event) => event.type === "child_run.event" && event.child_execution_id === id2);
 });
-var resultFromTerminal = Effect66.fn("SpawnChildRunTool.resultFromTerminal")(function* (config, id2, wait) {
+var resultFromTerminal = Effect67.fn("SpawnChildRunTool.resultFromTerminal")(function* (config, id2, wait) {
   const status = yield* childStatus(wait);
   const event = yield* terminalEvent2(config.eventLog, wait.executionId, id2);
   const output = event?.content ?? [];
   return { child_execution_id: id2, status, output };
 });
-var run3 = Effect66.fn("SpawnChildRunTool.run")(function* (config, activeToolName, input, context, enforceStaticOrDynamic) {
+var run3 = Effect67.fn("SpawnChildRunTool.run")(function* (config, activeToolName, input, context, enforceStaticOrDynamic) {
   if (enforceStaticOrDynamic)
     yield* ensureStaticOrDynamic(input);
   const id2 = childExecutionId2(context);
   const waitId = childWaitId(id2);
-  const existingWait = yield* config.waits.get(waitId).pipe(Effect66.mapError(mapWaitError));
+  const existingWait = yield* config.waits.get(waitId).pipe(Effect67.mapError(mapWaitError));
   if (existingWait?.state === "open") {
-    return yield* Effect66.fail(new ToolExecutionWaitRequested({ tool_name: activeToolName, wait_id: waitId }));
+    return yield* Effect67.fail(new ToolExecutionWaitRequested({ tool_name: activeToolName, wait_id: waitId }));
   }
   if (existingWait !== undefined)
     return yield* resultFromTerminal(config, id2, existingWait);
   const spawn = spawnInput(config, input, context, id2);
-  const resolved = yield* resolveForDispatch(spawn).pipe(Effect66.mapError((error5) => mapChildRunError2(activeToolName, error5)));
-  const definition = yield* childDefinition(config.agent, resolved).pipe(Effect66.mapError((error5) => mapChildRunError2(activeToolName, error5)));
+  const resolved = yield* resolveForDispatch(spawn).pipe(Effect67.mapError((error5) => mapChildRunError2(activeToolName, error5)));
+  const definition = yield* childDefinition(config.agent, resolved).pipe(Effect67.mapError((error5) => mapChildRunError2(activeToolName, error5)));
   if (input.preset_name !== undefined) {
     yield* config.childRuns.spawnStatic({
       childExecutionId: id2,
@@ -15088,7 +15329,7 @@ var run3 = Effect66.fn("SpawnChildRunTool.run")(function* (config, activeToolNam
       presetName: input.preset_name,
       eventSequence: context.eventSequence + 1,
       createdAt: context.createdAt + 1
-    }).pipe(Effect66.mapError((error5) => mapChildRunError2(activeToolName, error5)));
+    }).pipe(Effect67.mapError((error5) => mapChildRunError2(activeToolName, error5)));
   } else {
     const override = childOverride2(input);
     yield* config.childRuns.spawnDynamic({
@@ -15099,11 +15340,11 @@ var run3 = Effect66.fn("SpawnChildRunTool.run")(function* (config, activeToolNam
       ...override === undefined ? {} : { override },
       eventSequence: context.eventSequence + 1,
       createdAt: context.createdAt + 1
-    }).pipe(Effect66.mapError((error5) => mapChildRunError2(activeToolName, error5)));
+    }).pipe(Effect67.mapError((error5) => mapChildRunError2(activeToolName, error5)));
   }
   yield* createJoinWait(config, spawn, id2, waitId, context.createdAt + 2);
   yield* dispatchChild(config, spawn, id2, definition, waitId);
-  return yield* Effect66.fail(new ToolExecutionWaitRequested({ tool_name: activeToolName, wait_id: waitId }));
+  return yield* Effect67.fail(new ToolExecutionWaitRequested({ tool_name: activeToolName, wait_id: waitId }));
 });
 var registeredTool2 = (config) => tool(toolName2, {
   description: "Spawn a durable child run and wait for its terminal output.",
@@ -15112,7 +15353,7 @@ var registeredTool2 = (config) => tool(toolName2, {
   permissions: [{ name: permissionName2, value: true }],
   requiredPermissions: [permissionName2],
   metadata: { relay_core_tool: true },
-  run: (input, context) => Schema73.decodeUnknownEffect(Input2)(normalizeModelInput(input)).pipe(Effect66.flatMap((decoded) => run3(config, toolName2, decoded, context, true)))
+  run: (input, context) => Schema74.decodeUnknownEffect(Input2)(normalizeModelInput(input)).pipe(Effect67.flatMap((decoded) => run3(config, toolName2, decoded, context, true)))
 });
 var transferToolName2 = (name) => `transfer_to_${name.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "")}`;
 var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target) => {
@@ -15124,141 +15365,13 @@ var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target
     permissions: [{ name: permissionName2, value: true }],
     requiredPermissions: [permissionName2],
     metadata: { relay_core_tool: true, handoff_target: target.name, preset_name: target.preset_name },
-    run: (input, context) => Schema73.decodeUnknownEffect(TransferInput)(input).pipe(Effect66.flatMap((decoded) => run3(config, name, { preset_name: target.preset_name, input: decoded.input ?? [] }, context, false)))
+    run: (input, context) => Schema74.decodeUnknownEffect(TransferInput)(input).pipe(Effect67.flatMap((decoded) => run3(config, name, { preset_name: target.preset_name, input: decoded.input ?? [] }, context, false)))
   });
 });
 
 // ../runtime/src/memory/memory-service.ts
 import { Clock as Clock8, Context as Context59, Effect as Effect68, Layer as Layer60, Schema as Schema75 } from "effect";
 import { EmbeddingModel as EmbeddingModel3, Prompt as Prompt13 } from "effect/unstable/ai";
-
-// ../runtime/src/model/embedding-model-service.ts
-import { Context as Context58, Effect as Effect67, Layer as Layer59, Ref as Ref18, Schema as Schema74 } from "effect";
-import { EmbeddingModel as EmbeddingModel2, Model as Model3 } from "effect/unstable/ai";
-
-class EmbeddingModelNotRegistered extends Schema74.TaggedErrorClass()("EmbeddingModelNotRegistered", {
-  provider: Schema74.String,
-  model: Schema74.String,
-  registration_key: Schema74.optionalKey(Schema74.String)
-}) {
-}
-
-class Service45 extends Context58.Service()("@relayfx/runtime/EmbeddingModelService") {
-}
-var toRegistration = (input) => ({
-  provider: input.provider,
-  model: input.model,
-  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
-  layer: input.layer,
-  ...input.metadata === undefined ? {} : { metadata: input.metadata }
-});
-var selectionError = (selection) => new EmbeddingModelNotRegistered({
-  provider: selection.provider,
-  model: selection.model,
-  ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
-});
-var defaultSelectionError = () => new EmbeddingModelNotRegistered({ provider: "default", model: "default" });
-var matchesSelection2 = (selection, registration) => registration.provider === selection.provider && registration.model === selection.model && (selection.registrationKey === undefined || registration.registrationKey === selection.registrationKey);
-var resolve5 = (registrations4, selection) => {
-  const matches2 = registrations4.filter((registration) => matchesSelection2(selection, registration));
-  if (selection.registrationKey !== undefined)
-    return matches2[0];
-  if (matches2.length === 1)
-    return matches2[0];
-  return matches2.find((registration) => registration.registrationKey === undefined);
-};
-var resolveDefault = (registrations4, options) => {
-  if (options?.defaultSelection !== undefined) {
-    return resolve5(registrations4, options.defaultSelection);
-  }
-  return registrations4.length === 1 ? registrations4[0] : undefined;
-};
-var registrationFromLayer3 = (input) => Model3.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect67.map((layer45) => toRegistration({
-  provider: input.provider,
-  model: input.model,
-  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
-  layer: layer45,
-  ...input.metadata === undefined ? {} : { metadata: input.metadata }
-})));
-var layer45 = (initialRegistrations = [], options) => Layer59.effect(Service45, Effect67.gen(function* () {
-  const registry = yield* Ref18.make([...initialRegistrations]);
-  const register9 = Effect67.fn("EmbeddingModelService.register")(function* (input) {
-    const registration = toRegistration(input);
-    yield* Ref18.update(registry, (current2) => [
-      ...current2.filter((item) => !(item.provider === registration.provider && item.model === registration.model && item.registrationKey === registration.registrationKey)),
-      registration
-    ]);
-  });
-  const registrations4 = Ref18.get(registry);
-  const provide3 = (selection, effect) => Effect67.gen(function* () {
-    const current2 = yield* Ref18.get(registry);
-    const registration = resolve5(current2, selection);
-    if (registration === undefined)
-      return yield* Effect67.fail(selectionError(selection));
-    return yield* effect.pipe(Effect67.provide(registration.layer));
-  });
-  const provideDefault = (effect) => Effect67.gen(function* () {
-    const current2 = yield* Ref18.get(registry);
-    const registration = resolveDefault(current2, options);
-    if (registration === undefined)
-      return yield* Effect67.fail(defaultSelectionError());
-    return yield* effect.pipe(Effect67.provide(registration.layer));
-  });
-  const provideForAgent2 = (agent, effect) => {
-    return provideDefault(effect);
-  };
-  return Service45.of({ register: register9, registrations: registrations4, provide: provide3, provideDefault, provideForAgent: provideForAgent2 });
-}));
-var layerFromRegistrationEffects3 = (registrations4, options) => Layer59.unwrap(Effect67.all(registrations4).pipe(Effect67.map((items) => layer45(items, options))));
-var memoryLayer40 = layer45;
-var words = (input) => input.toLowerCase().match(/[a-z0-9]+/g) ?? [];
-var hashWord = (word) => {
-  let hash = 2166136261;
-  for (let index = 0;index < word.length; index += 1) {
-    hash ^= word.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-};
-var deterministicVector = (input, dimensions) => {
-  const vector = Array.from({ length: dimensions }, () => 0);
-  for (const word of words(input)) {
-    const hash = hashWord(word);
-    const index = hash % dimensions;
-    vector[index] = (vector[index] ?? 0) + 1;
-  }
-  return vector;
-};
-var deterministicLayer = (options = {}) => {
-  const dimensions = options.dimensions ?? 64;
-  return Layer59.mergeAll(Layer59.effect(EmbeddingModel2.EmbeddingModel, EmbeddingModel2.make({
-    embedMany: ({ inputs }) => Effect67.succeed({
-      results: inputs.map((input) => deterministicVector(input, dimensions)),
-      usage: { inputTokens: inputs.reduce((total, input) => total + words(input).length, 0) }
-    })
-  })), Layer59.succeed(EmbeddingModel2.Dimensions, dimensions));
-};
-var deterministicRegistration = (options = {}) => registrationFromLayer3({
-  provider: options.provider ?? "test",
-  model: options.model ?? "deterministic-embedding",
-  layer: deterministicLayer(options)
-});
-var deterministicTestLayer = (options = {}) => layerFromRegistrationEffects3([deterministicRegistration(options)], {
-  defaultSelection: {
-    provider: options.provider ?? "test",
-    model: options.model ?? "deterministic-embedding"
-  }
-});
-var register9 = Effect67.fn("EmbeddingModelService.register.call")(function* (input) {
-  const service = yield* Service45;
-  return yield* service.register(input);
-});
-var registrations4 = Effect67.fn("EmbeddingModelService.registrations.call")(function* () {
-  const service = yield* Service45;
-  return yield* service.registrations;
-});
-
-// ../runtime/src/memory/memory-service.ts
 class Service46 extends Context59.Service()("@relayfx/runtime/MemoryService") {
 }
 var defaultTopK = 5;
@@ -15334,7 +15447,7 @@ var embed = (models, text2, options) => {
 };
 var make7 = (options = {}) => Effect68.gen(function* () {
   const repository = yield* exports_memory_repository.Service;
-  const models = yield* Service45;
+  const models = yield* Service38;
   const recall = Effect68.fn("MemoryService.recall")(function* (input) {
     const text2 = latestUserText(input.prompt);
     if (text2 === undefined)
@@ -15408,7 +15521,7 @@ var forget2 = Effect68.fn("MemoryService.forget.call")(function* (input) {
 // ../runtime/src/state/execution-state-service.ts
 var exports_execution_state_service = {};
 __export(exports_execution_state_service, {
-  testLayer: () => testLayer53,
+  testLayer: () => testLayer54,
   memoryLayer: () => memoryLayer41,
   layer: () => layer47,
   key: () => key3,
@@ -15441,7 +15554,7 @@ var stateError = (cause) => new ExecutionStateError({ message: String(cause) });
 var invalid = (stateKey, cause) => new StateValueInvalid({ key: stateKey, message: String(cause) });
 var layer47 = Layer61.effect(Service47, Effect69.gen(function* () {
   const repository = yield* exports_execution_state_repository.Service;
-  const blobs = yield* Service42;
+  const blobs = yield* Service43;
   const eventInlineMaxBytes = yield* Config3.number("RELAY_STATE_EVENT_INLINE_MAX_BYTES").pipe(Config3.withDefault(65536), Effect69.orDie);
   const get15 = Effect69.fn("ExecutionStateService.get")(function* (executionId, stateKey) {
     const row = yield* repository.get(executionId, stateKey.name).pipe(Effect69.mapError(stateError));
@@ -15479,7 +15592,7 @@ var layer47 = Layer61.effect(Service47, Effect69.gen(function* () {
 }));
 var memoryRepositoryDependencies = Layer61.mergeAll(exports_execution_repository.memoryLayer, exports_execution_event_repository.memoryLayer);
 var memoryLayer41 = layer47.pipe(Layer61.provide(exports_execution_state_repository.memoryLayer.pipe(Layer61.provide(memoryRepositoryDependencies))));
-var testLayer53 = (implementation) => Layer61.succeed(Service47, Service47.of(implementation));
+var testLayer54 = (implementation) => Layer61.succeed(Service47, Service47.of(implementation));
 
 // ../runtime/src/state/state-tools.ts
 import { Effect as Effect70, Schema as Schema77 } from "effect";
@@ -15820,15 +15933,15 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service49, Effect73.gen(f
       if (wait?.state === "open") {
         const waitId = wait.id;
         const sequence = yield* nextSequence(eventLog, input.executionId).pipe(Effect73.mapError((error5) => new InboxDeliveryError({ execution_id: input.executionId, message: error5._tag })));
-        const transition2 = yield* waits.wake({ waitId, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect73.mapError((error5) => new InboxDeliveryError({
+        const transition3 = yield* waits.wake({ waitId, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect73.mapError((error5) => new InboxDeliveryError({
           execution_id: input.executionId,
           message: error5._tag === "WaitNotFound" ? error5.wait_id : error5.message
         })));
-        if (transition2.transitioned && signalDependencies !== undefined) {
+        if (transition3.transitioned && signalDependencies !== undefined) {
           yield* signalWorkflowWait({
             makeExecutionClient: signalDependencies.makeExecutionClient,
-            executionId: transition2.wait.executionId,
-            waitId: transition2.wait.id,
+            executionId: transition3.wait.executionId,
+            waitId: transition3.wait.id,
             state: "resolved",
             signaledAt: input.createdAt
           }).pipe(Effect73.provideService(exports_execution_repository.Service, signalDependencies.executionRepository), Effect73.mapError((error5) => new InboxDeliveryError({ execution_id: input.executionId, message: String(error5) })));
@@ -15866,14 +15979,14 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service49, Effect73.gen(f
         }
       }).pipe(Effect73.mapError((error5) => new InboxDeliveryError({ execution_id: wait.executionId, message: error5.message })));
       const sequence = yield* nextSequence(eventLog, wait.executionId).pipe(Effect73.mapError((error5) => new InboxDeliveryError({ execution_id: wait.executionId, message: error5._tag })));
-      const transition2 = yield* waits.wake({ waitId, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect73.mapError(() => new InboxReplyTokenInvalid({ reply_token: input.replyToken })));
-      if (!transition2.transitioned)
+      const transition3 = yield* waits.wake({ waitId, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect73.mapError(() => new InboxReplyTokenInvalid({ reply_token: input.replyToken })));
+      if (!transition3.transitioned)
         return yield* new InboxReplyTokenInvalid({ reply_token: input.replyToken });
       if (signalDependencies !== undefined) {
         yield* signalWorkflowWait({
           makeExecutionClient: signalDependencies.makeExecutionClient,
-          executionId: transition2.wait.executionId,
-          waitId: transition2.wait.id,
+          executionId: transition3.wait.executionId,
+          waitId: transition3.wait.id,
           state: "resolved",
           signaledAt: input.createdAt
         }).pipe(Effect73.provideService(exports_execution_repository.Service, signalDependencies.executionRepository), Effect73.mapError((error5) => new InboxDeliveryError({ execution_id: wait.executionId, message: String(error5) })));
@@ -15890,7 +16003,7 @@ var memoryLayer42 = layer48.pipe(Layer63.provide(exports_inbox_repository.memory
 var exports_topic_service = {};
 __export(exports_topic_service, {
   unsubscribe: () => unsubscribe,
-  testLayer: () => testLayer54,
+  testLayer: () => testLayer55,
   subscribe: () => subscribe,
   publish: () => publish,
   memoryLayer: () => memoryLayer43,
@@ -15974,7 +16087,7 @@ var layer49 = Layer64.effect(Service50, Effect74.gen(function* () {
   return Service50.of({ subscribe, unsubscribe, publish, list: list16 });
 }));
 var memoryLayer43 = layer49.pipe(Layer64.provide(exports_topic_repository.memoryLayer));
-var testLayer54 = (implementation) => Layer64.succeed(Service50, Service50.of(implementation));
+var testLayer55 = (implementation) => Layer64.succeed(Service50, Service50.of(implementation));
 var subscribe = (input) => Effect74.flatMap(Service50, (service) => service.subscribe(input));
 var unsubscribe = (input) => Effect74.flatMap(Service50, (service) => service.unsubscribe(input));
 var publish = (input) => Effect74.flatMap(Service50, (service) => service.publish(input));
@@ -16075,8 +16188,8 @@ var registeredTool4 = (config) => tool(toolName4, {
       }).pipe(Effect76.mapError((error5) => new ToolRuntimeError({ message: error5.message })));
     if ((yield* config.inbox.undrainedCount(context.executionId).pipe(Effect76.mapError((error5) => new ToolRuntimeError({ message: error5.message })))) > 0) {
       const sequence = yield* config.eventLog.maxSequence(context.executionId).pipe(Effect76.map((value) => (value ?? -1) + 1), Effect76.mapError((error5) => new ToolRuntimeError({ message: error5._tag })));
-      const transition2 = yield* config.waits.wake({ waitId, resolvedAt: context.createdAt, eventSequence: sequence }).pipe(Effect76.mapError((error5) => new ToolRuntimeError({ message: error5._tag })));
-      if (transition2.transitioned) {
+      const transition3 = yield* config.waits.wake({ waitId, resolvedAt: context.createdAt, eventSequence: sequence }).pipe(Effect76.mapError((error5) => new ToolRuntimeError({ message: error5._tag })));
+      if (transition3.transitioned) {
         const drained = yield* drain3();
         return { status: "messages", messages: drained.map(project2) };
       }
@@ -16132,7 +16245,7 @@ var registeredTool5 = (config) => tool(toolName5, {
 // ../runtime/src/envelope/envelope-service.ts
 var exports_envelope_service = {};
 __export(exports_envelope_service, {
-  testLayer: () => testLayer55,
+  testLayer: () => testLayer56,
   send: () => send2,
   memoryLayer: () => memoryLayer44,
   layer: () => layer50,
@@ -16337,7 +16450,7 @@ var layer50 = Layer65.effect(Service51, Effect78.gen(function* () {
   });
 }));
 var memoryLayer44 = (routes = []) => layer50.pipe(Layer65.provide(memoryLayer28(routes)), Layer65.provide(exports_envelope_repository.memoryLayer), Layer65.provide(memoryLayer29));
-var testLayer55 = (implementation) => Layer65.succeed(Service51, Service51.of(implementation));
+var testLayer56 = (implementation) => Layer65.succeed(Service51, Service51.of(implementation));
 var send2 = Effect78.fn("EnvelopeService.send.call")(function* (input) {
   const service = yield* Service51;
   return yield* service.send(input);
@@ -16346,7 +16459,7 @@ var send2 = Effect78.fn("EnvelopeService.send.call")(function* (input) {
 // ../runtime/src/agent/prompt-assembler-service.ts
 var exports_prompt_assembler_service = {};
 __export(exports_prompt_assembler_service, {
-  testLayer: () => testLayer57,
+  testLayer: () => testLayer58,
   layer: () => layer51,
   defaultLayerWithStores: () => defaultLayerWithStores,
   defaultLayer: () => defaultLayer,
@@ -16361,8 +16474,8 @@ import { Prompt as Prompt14 } from "effect/unstable/ai";
 // ../runtime/src/content/artifact-store-service.ts
 var exports_artifact_store_service = {};
 __export(exports_artifact_store_service, {
-  testLayer: () => testLayer56,
-  resolve: () => resolve6,
+  testLayer: () => testLayer57,
+  resolve: () => resolve7,
   register: () => register10,
   passthroughLayer: () => passthroughLayer2,
   memoryLayer: () => memoryLayer45,
@@ -16405,8 +16518,8 @@ var memoryServiceLayer = Layer66.effect(Service52, Effect79.gen(function* () {
   return Service52.of({ resolve: memory.resolve });
 }));
 var memoryLayer45 = memoryServiceLayer.pipe(Layer66.provideMerge(Layer66.effect(Memory2, makeMemory2)));
-var testLayer56 = (implementation) => Layer66.succeed(Service52, Service52.of(implementation));
-var resolve6 = Effect79.fn("ArtifactStore.resolve.call")(function* (part) {
+var testLayer57 = (implementation) => Layer66.succeed(Service52, Service52.of(implementation));
+var resolve7 = Effect79.fn("ArtifactStore.resolve.call")(function* (part) {
   const service = yield* Service52;
   return yield* service.resolve(part);
 });
@@ -16502,13 +16615,13 @@ var makeDefaultInterface = (blobs, artifacts) => ({
   assemble: (input) => defaultPrompt(blobs, artifacts, input.input).pipe(Effect80.map((prompt) => ({ system: defaultSystem(input.agent, input.tools), prompt })))
 });
 var defaultLayerWithStores = Layer67.effect(Service53, Effect80.gen(function* () {
-  const blobs = yield* Service42;
+  const blobs = yield* Service43;
   const artifacts = yield* Service52;
   return Service53.of(makeDefaultInterface(blobs, artifacts));
 }));
 var defaultLayer = defaultLayerWithStores.pipe(Layer67.provide(Layer67.mergeAll(passthroughLayer, passthroughLayer2)));
 var layer51 = (implementation) => Layer67.succeed(Service53, Service53.of(implementation));
-var testLayer57 = (implementation) => Layer67.succeed(Service53, Service53.of(implementation));
+var testLayer58 = (implementation) => Layer67.succeed(Service53, Service53.of(implementation));
 var assemble = Effect80.fn("PromptAssembler.assemble.call")(function* (input) {
   const service = yield* Service53;
   return yield* service.assemble(input);
@@ -16541,7 +16654,7 @@ var strategy2 = (config) => {
         const existing = yield* config.repository.get({ executionId: config.executionId, checkpointId: id2 }).pipe(Effect81.mapError(mapRepositoryError10));
         if (existing !== undefined)
           return existing.summary;
-        const summary = yield* base2.summarize(plan2, request);
+        const summary = yield* config.options?.summaryModel === undefined ? base2.summarize(plan2, request) : config.options.summaryModel.pipe(Effect81.flatMap((model) => base2.summarize(plan2, request).pipe(Effect81.provide(model))));
         const createdAt = yield* Clock12.currentTimeMillis;
         const input = {
           executionId: config.executionId,
@@ -16926,7 +17039,7 @@ var store = (blobStore, toolCallId, content) => {
 var make11 = (blobStore) => ({
   put: (toolCallId, content) => store(blobStore, toolCallId, content)
 });
-var layer56 = Layer72.effect(exports_tool_output.ToolOutputStore, Service42.pipe(Effect85.map((blobStore) => exports_tool_output.ToolOutputStore.of(make11(blobStore)))));
+var layer56 = Layer72.effect(exports_tool_output.ToolOutputStore, Service43.pipe(Effect85.map((blobStore) => exports_tool_output.ToolOutputStore.of(make11(blobStore)))));
 
 // ../runtime/src/agent/sequence-allocator.ts
 import { Effect as Effect86, Ref as Ref20 } from "effect";
@@ -17327,22 +17440,22 @@ var compactionOptions = (agent) => agent.compaction_policy === undefined ? undef
 };
 var layer57 = Layer73.effect(Service54, Effect87.gen(function* () {
   const eventLog = yield* Service30;
-  const languageModels = yield* Service38;
+  const languageModels = yield* Service39;
   const tools = yield* Service32;
   const childRuns = yield* Effect87.serviceOption(Service37);
   const chats = yield* exports_agent_chat_repository.Service;
-  const policy = yield* Service39;
+  const policy = yield* Service40;
   const assembler = yield* Service53;
-  const schemas = yield* Service41;
+  const schemas = yield* Service42;
   const durableMemory = yield* Effect87.serviceOption(Service46);
-  const blobStore = yield* Effect87.serviceOption(Service42);
+  const blobStore = yield* Effect87.serviceOption(Service43);
   const compactionRepository = yield* Effect87.serviceOption(exports_compaction_repository.Service);
   const contextEpochs = yield* Effect87.serviceOption(exports_context_epoch_repository.Service);
   const sessionRepository = yield* Effect87.serviceOption(exports_session_repository.Service);
   const permissionRules = yield* Effect87.serviceOption(exports_permission_rule_repository.Service);
   const steeringRepository = yield* Effect87.serviceOption(exports_steering_repository.Service);
   const waits = yield* Effect87.serviceOption(Service31);
-  const presence = yield* Effect87.serviceOption(Service40);
+  const presence = yield* Effect87.serviceOption(Service41);
   const inbox = yield* Effect87.serviceOption(Service49);
   const topics = yield* Effect87.serviceOption(Service50);
   const envelopes = yield* Effect87.serviceOption(Service51);
@@ -17387,7 +17500,16 @@ var layer57 = Layer73.effect(Service54, Effect87.gen(function* () {
       yield* appendEvent(eventLog, inputPreparedEvent(input, definitions2), input.eventSequence + 1);
       const toolOutputMaxBytes = yield* effectiveToolOutputMaxBytes(input);
       const compactionPolicy = input.agent.compaction_policy;
-      const activeCompactionOptions = compactionOptions(input.agent);
+      const configuredCompactionOptions = compactionOptions(input.agent);
+      const activeCompactionOptions = configuredCompactionOptions === undefined ? undefined : {
+        ...configuredCompactionOptions,
+        ...compactionPolicy?.summary_model === undefined ? {} : {
+          summaryModel: resolve4(compactionPolicy.summary_model).pipe(Effect87.provideService(Service39, languageModels), Effect87.map((registration) => registration.layer), Effect87.mapError((error5) => new exports_compaction.CompactionError({
+            message: `LanguageModelNotRegistered: ${error5.provider}/${error5.model}`,
+            cause: error5
+          })))
+        }
+      };
       const runTokenizer = yield* Effect87.serviceOption(Tokenizer4.Tokenizer);
       const activeTokenizer = Option25.isSome(runTokenizer) ? runTokenizer : tokenizer;
       const allocator = yield* make12(input.eventSequence + 1);
@@ -17622,7 +17744,7 @@ var layer57 = Layer73.effect(Service54, Effect87.gen(function* () {
     })
   });
 }));
-var testLayer58 = (implementation) => Layer73.succeed(Service54, Service54.of(implementation));
+var testLayer59 = (implementation) => Layer73.succeed(Service54, Service54.of(implementation));
 var run4 = Effect87.fn("AgentLoop.run.call")(function* (input) {
   const service = yield* Service54;
   return yield* service.run(input);
@@ -18848,12 +18970,14 @@ var signalWait = Effect93.fn("ExecutionWorkflow.signalWait")(function* (input) {
 var exports_child_fan_out_runtime = {};
 __export(exports_child_fan_out_runtime, {
   testHandlersLayer: () => testHandlersLayer,
+  layerFromRuntime: () => layerFromRuntime,
   layer: () => layer62,
+  handlersLayer: () => handlersLayer,
   Service: () => Service61,
   HandlerService: () => HandlerService,
   ChildFanOutRuntimeError: () => ChildFanOutRuntimeError
 });
-import { Clock as Clock15, Context as Context74, Effect as Effect95, Layer as Layer81, Schema as Schema95 } from "effect";
+import { Clock as Clock15, Context as Context74, Effect as Effect95, FiberMap, Layer as Layer81, Schema as Schema95 } from "effect";
 
 // ../runtime/src/child/child-fan-out-transition-service.ts
 var exports_child_fan_out_transition_service = {};
@@ -18937,11 +19061,11 @@ class ChildFanOutRuntimeError extends Schema95.TaggedErrorClass()("ChildFanOutRu
 class Service61 extends Context74.Service()("@relayfx/runtime/ChildFanOutRuntime") {
 }
 var runtimeError = (error5) => new ChildFanOutRuntimeError({ message: String(error5) });
-var layer62 = Layer81.effect(Service61, Effect95.gen(function* () {
+var layerFromRuntime = Layer81.effect(Service61, Effect95.gen(function* () {
   const repository = yield* exports_child_fan_out_repository.Service;
   const transitions = yield* Service60;
   const handlers = yield* HandlerService;
-  const scope = yield* Effect95.scope;
+  const hosts = yield* FiberMap.make();
   const run5 = Effect95.fn("ChildFanOutRuntime.run")(function* (fanOutId) {
     while (true) {
       const fanOut2 = yield* repository.get(fanOutId);
@@ -18971,7 +19095,7 @@ var layer62 = Layer81.effect(Service61, Effect95.gen(function* () {
       })), { concurrency: fanOut2.max_concurrency, discard: true });
     }
   });
-  const launch = (fanOutId) => run5(fanOutId).pipe(Effect95.ignore, Effect95.forkIn(scope), Effect95.asVoid);
+  const launch = (fanOutId) => FiberMap.run(hosts, fanOutId, run5(fanOutId).pipe(Effect95.ignore), { onlyIfMissing: true }).pipe(Effect95.asVoid);
   const recover = Effect95.fn("ChildFanOutRuntime.recover")(function* () {
     const fanOuts = yield* repository.listNonTerminal();
     yield* Effect95.forEach(fanOuts, (fanOut2) => launch(fanOut2.fan_out_id), { discard: true });
@@ -18996,7 +19120,9 @@ var layer62 = Layer81.effect(Service61, Effect95.gen(function* () {
   yield* recover().pipe(Effect95.mapError(runtimeError));
   return service;
 }).pipe(Effect95.mapError(runtimeError)));
-var testHandlersLayer = (handlers) => Layer81.succeed(HandlerService, handlers);
+var layer62 = layerFromRuntime;
+var handlersLayer = (handlers) => Layer81.succeed(HandlerService, handlers);
+var testHandlersLayer = handlersLayer;
 
 // ../runtime/src/cluster/execution-entity.ts
 var exports_execution_entity = {};
@@ -19050,7 +19176,7 @@ var client2 = entity.client;
 var exports_scheduler_service = {};
 __export(exports_scheduler_service, {
   workerIdConfig: () => workerIdConfig,
-  testLayer: () => testLayer59,
+  testLayer: () => testLayer60,
   startIdempotencyKey: () => startIdempotencyKey,
   runOnce: () => runOnce2,
   pollIntervalMillisConfig: () => pollIntervalMillisConfig,
@@ -19216,7 +19342,7 @@ var layer64 = Layer82.effect(Service62, Effect96.gen(function* () {
   return service;
 }));
 var memoryLayer47 = Layer82.effect(Service62, make15);
-var testLayer59 = (implementation) => Layer82.succeed(Service62, Service62.of(implementation));
+var testLayer60 = (implementation) => Layer82.succeed(Service62, Service62.of(implementation));
 var runOnce2 = Effect96.fn("SchedulerService.runOnce.call")(function* () {
   const service = yield* Service62;
   return yield* service.runOnce;
@@ -19228,7 +19354,7 @@ __export(exports_runner_runtime_service, {
   testLayerWithServices: () => testLayerWithServices,
   testLayerWithLanguageModelService: () => testLayerWithLanguageModelService,
   testLayerWithDatabaseCheck: () => testLayerWithDatabaseCheck,
-  testLayer: () => testLayer64,
+  testLayer: () => testLayer65,
   testClientLayerWithDatabaseCheck: () => testClientLayerWithDatabaseCheck,
   testClientLayer: () => testClientLayer,
   shardingConfigFromEnv: () => shardingConfigFromEnv,
@@ -19274,7 +19400,7 @@ import { LanguageModel as LanguageModel8 } from "effect/unstable/ai";
 // ../runtime/src/execution/execution-watch-service.ts
 var exports_execution_watch_service = {};
 __export(exports_execution_watch_service, {
-  testLayer: () => testLayer60,
+  testLayer: () => testLayer61,
   memoryLayer: () => memoryLayer48,
   layerFromServices: () => layerFromServices,
   Service: () => Service63,
@@ -19330,12 +19456,12 @@ var layerFromServices = Layer83.effect(Service63, Effect97.gen(function* () {
   });
 }));
 var memoryLayer48 = layerFromServices;
-var testLayer60 = (implementation) => Layer83.succeed(Service63, Service63.of(implementation));
+var testLayer61 = (implementation) => Layer83.succeed(Service63, Service63.of(implementation));
 
 // ../runtime/src/entity/entity-registry-service.ts
 var exports_entity_registry_service = {};
 __export(exports_entity_registry_service, {
-  testLayer: () => testLayer61,
+  testLayer: () => testLayer62,
   layer: () => layer65,
   Service: () => Service64,
   EntityRegistryError: () => EntityRegistryError,
@@ -19385,12 +19511,12 @@ var layer65 = Layer84.effect(Service64, Effect98.gen(function* () {
     listKinds: () => repository.listKinds().pipe(Effect98.mapError(repositoryError4))
   });
 }));
-var testLayer61 = (implementation) => Layer84.succeed(Service64, Service64.of(implementation));
+var testLayer62 = (implementation) => Layer84.succeed(Service64, Service64.of(implementation));
 
 // ../runtime/src/entity/entity-instance-service.ts
 var exports_entity_instance_service = {};
 __export(exports_entity_instance_service, {
-  testLayer: () => testLayer62,
+  testLayer: () => testLayer63,
   layer: () => layer66,
   entitySessionId: () => entitySessionId,
   entityExecutionId: () => entityExecutionId,
@@ -19515,12 +19641,12 @@ var layer66 = Layer85.effect(Service65, Effect99.gen(function* () {
     list: (input) => repository.list(input).pipe(Effect99.mapError(serviceError2))
   });
 }));
-var testLayer62 = (implementation) => Layer85.succeed(Service65, Service65.of(implementation));
+var testLayer63 = (implementation) => Layer85.succeed(Service65, Service65.of(implementation));
 
 // ../runtime/src/execution/session-stream-service.ts
 var exports_session_stream_service = {};
 __export(exports_session_stream_service, {
-  testLayer: () => testLayer63,
+  testLayer: () => testLayer64,
   memoryLayer: () => memoryLayer49,
   layerFromServices: () => layerFromServices2,
   SessionStreamError: () => SessionStreamError,
@@ -19560,7 +19686,7 @@ var layerFromServices2 = Layer86.effect(Service66, Effect100.gen(function* () {
   });
 }));
 var memoryLayer49 = layerFromServices2;
-var testLayer63 = (implementation) => Layer86.succeed(Service66, Service66.of(implementation));
+var testLayer64 = (implementation) => Layer86.succeed(Service66, Service66.of(implementation));
 
 // ../runtime/src/runner/runner-runtime-service.ts
 var DatabaseMode = Schema102.Literals(["sql", "pg", "mysql", "sqlite", "memory"]).annotate({
@@ -19687,7 +19813,8 @@ var assertClusterConfig = Effect101.fn("RunnerRuntime.assertClusterConfig")(func
     return yield* new ClusterConfigMismatch({ field: "availableShardGroups", expected: want, actual });
   }
 });
-var sqlRepositoryBaseLayer = Layer87.mergeAll(exports_address_book_repository.layer, exports_agent_chat_repository.layer, exports_agent_definition_repository.layer, exports_workflow_definition_repository.layer, exports_child_execution_repository.layer, exports_child_fan_out_repository.layer, exports_cluster_registry_repository.layer, exports_compaction_repository.layer, exports_context_epoch_repository.layer, exports_execution_repository.layer, exports_envelope_repository.layer, exports_entity_repository.layer, exports_execution_event_repository.layerWithBus, exports_inbox_repository.layer, exports_memory_repository.layer, exports_topic_repository.layer, exports_permission_rule_repository.layer, exports_presence_repository.layer.pipe(Layer87.provide(exports_notification_bus.layerFromDialect)), exports_schedule_repository.layer, exports_session_repository.layer, exports_skill_definition_repository.layer, exports_steering_repository.layer, exports_tool_call_repository.layer, exports_workspace_lease_repository.layer);
+var sqlNotificationLayer = exports_notification_bus.layerFromDialect;
+var sqlRepositoryBaseLayer = Layer87.mergeAll(exports_address_book_repository.layer, exports_agent_chat_repository.layer, exports_agent_definition_repository.layer, exports_workflow_definition_repository.layer, exports_child_execution_repository.layer, exports_child_fan_out_repository.layer, exports_cluster_registry_repository.layer, exports_compaction_repository.layer, exports_context_epoch_repository.layer, exports_execution_repository.layerWithoutBus, exports_envelope_repository.layer, exports_entity_repository.layer, exports_execution_event_repository.layer, exports_inbox_repository.layer, exports_memory_repository.layer, exports_topic_repository.layer, exports_permission_rule_repository.layer, exports_presence_repository.layer, exports_schedule_repository.layer, exports_session_repository.layer, exports_skill_definition_repository.layer, exports_steering_repository.layer, exports_tool_call_repository.layer, exports_workspace_lease_repository.layer).pipe(Layer87.provideMerge(sqlNotificationLayer));
 var sqlRepositoryLayer = Layer87.mergeAll(sqlRepositoryBaseLayer, exports_execution_state_repository.layer.pipe(Layer87.provide(sqlRepositoryBaseLayer)));
 var memoryRepositoryBaseLayer = Layer87.mergeAll(exports_address_book_repository.memoryLayer, exports_agent_chat_repository.memoryLayer, exports_agent_definition_repository.memoryLayer, exports_workflow_definition_repository.memoryLayer, exports_child_execution_repository.memoryLayer, exports_child_fan_out_repository.memoryLayer, exports_cluster_registry_repository.memoryLayer, exports_compaction_repository.memoryLayer, exports_context_epoch_repository.memoryLayer, exports_execution_repository.memoryLayer, exports_envelope_repository.memoryLayer, exports_entity_repository.memoryLayer, exports_execution_event_repository.memoryLayer, exports_inbox_repository.memoryLayer, exports_memory_repository.memoryLayer, exports_topic_repository.memoryLayer, exports_permission_rule_repository.memoryLayer, exports_presence_repository.memoryLayer, exports_schedule_repository.memoryLayer, exports_session_repository.memoryLayer, exports_skill_definition_repository.memoryLayer, exports_steering_repository.memoryLayer, exports_tool_call_repository.memoryLayer, exports_workspace_lease_repository.memoryLayer);
 var memoryRepositoryLayer = Layer87.mergeAll(memoryRepositoryBaseLayer, exports_execution_state_repository.memoryLayer.pipe(Layer87.provide(memoryRepositoryBaseLayer)));
@@ -19695,7 +19822,7 @@ var testCryptoLayer = Layer87.succeed(Crypto4.Crypto, Crypto4.make({
   randomBytes: (size) => new Uint8Array(size),
   digest: (algorithm, data) => Effect101.promise(() => globalThis.crypto.subtle.digest(algorithm, data).then((buffer) => new Uint8Array(buffer)))
 }));
-var executionServiceLayer = layer44.pipe(Layer87.provideMerge(layer39));
+var executionServiceLayer = layer45.pipe(Layer87.provideMerge(layer39));
 var addressResolutionLayerWith = (toolRuntimeLayer) => layer31.pipe(Layer87.provideMerge(layerFromRepository), Layer87.provideMerge(layer30.pipe(Layer87.provideMerge(toolRuntimeLayer))));
 var parentNotifierLayer = Layer87.effect(Service55, Effect101.gen(function* () {
   const makeExecutionClient = yield* client2;
@@ -19710,7 +19837,7 @@ var parentNotifierLayer = Layer87.effect(Service55, Effect101.gen(function* () {
     }).pipe(Effect101.provideService(exports_execution_repository.Service, executionRepository))
   });
 }));
-var agentLoopLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer) => layer57.pipe(Layer87.provideMerge(toolRuntimeLayer), Layer87.provideMerge(layer39), Layer87.provideMerge(layer41()), Layer87.provideMerge(promptAssemblerLayer), Layer87.provideMerge(schemaRegistryLayer));
+var agentLoopLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer) => layer57.pipe(Layer87.provideMerge(toolRuntimeLayer), Layer87.provideMerge(layer39), Layer87.provideMerge(layer42()), Layer87.provideMerge(promptAssemblerLayer), Layer87.provideMerge(schemaRegistryLayer));
 var runtimeServicesLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => {
   const inboxLayer = Layer87.unwrap(Effect101.gen(function* () {
     const makeExecutionClient = yield* client2;
@@ -19722,7 +19849,7 @@ var runtimeServicesLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRe
   const agentLayer = agentLoopLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer).pipe(Layer87.provideMerge(inboxLayer), Layer87.provideMerge(envelopeLayer), Layer87.provideMerge(topicLayer));
   const entityRegistryLayer = layer65.pipe(Layer87.provideMerge(layer30));
   const entityInstanceLayer = layer66.pipe(Layer87.provideMerge(entityRegistryLayer), Layer87.provideMerge(layerFromRepository), Layer87.provideMerge(layerFromRepository2));
-  return Layer87.mergeAll(addressResolutionLayerWith(toolRuntimeLayer), layer43, executionServiceLayer, layerFromServices, layerFromServices2, layerFromRepository3, agentLayer, layer59, parentNotifierLayer, inboxLayer, envelopeLayer, topicLayer, entityRegistryLayer, entityInstanceLayer, toolTransitionCoordinatorLayer, layer58).pipe(Layer87.provideMerge(layer47), Layer87.provideMerge(layer28), Layer87.provideMerge(layerFromRepository2));
+  return Layer87.mergeAll(addressResolutionLayerWith(toolRuntimeLayer), layer44, executionServiceLayer, layerFromServices, layerFromServices2, layerFromRepository3, agentLayer, layer59, parentNotifierLayer, inboxLayer, envelopeLayer, topicLayer, entityRegistryLayer, entityInstanceLayer, toolTransitionCoordinatorLayer, layer58).pipe(Layer87.provideMerge(layer47), Layer87.provideMerge(layer28), Layer87.provideMerge(layerFromRepository2));
 };
 var workflowLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => layer60.pipe(Layer87.provideMerge(runtimeServicesLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer)));
 var workflowAndEntityLayerWith = (toolRuntimeLayer, schedulerLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => Layer87.mergeAll(layer63, schedulerLayer).pipe(Layer87.provideMerge(workflowLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer)));
@@ -19805,8 +19932,8 @@ var deterministicTestModelLayer = Layer87.effect(LanguageModel8.LanguageModel, L
   generateText: () => Effect101.succeed([{ type: "text", text: "deterministic test response" }]),
   streamText: () => Stream15.make({ type: "text-delta", id: "text", delta: "deterministic test response" })
 }));
-var testLanguageModelLayer = layerFromRegistrationEffects2([
-  registrationFromLayer2({
+var testLanguageModelLayer = layerFromRegistrationEffects3([
+  registrationFromLayer3({
     provider: "test",
     model: "deterministic",
     layer: deterministicTestModelLayer
@@ -19818,8 +19945,8 @@ var layerWith = (options) => {
   const blobStoreLayer = options.blobStoreLayer ?? passthroughLayer;
   const artifactStoreLayer = options.artifactStoreLayer ?? passthroughLayer2;
   const promptAssemblerLayer = options.promptAssemblerLayer ?? defaultPromptAssemblerLayer(blobStoreLayer, artifactStoreLayer);
-  const schemaRegistryLayer = options.schemaRegistryLayer ?? layer42();
-  const embeddingModelLayer = options.embeddingModelLayer ?? memoryLayer40();
+  const schemaRegistryLayer = options.schemaRegistryLayer ?? layer43();
+  const embeddingModelLayer = options.embeddingModelLayer ?? memoryLayer35();
   const memoryLayer50 = layer46().pipe(Layer87.provideMerge(embeddingModelLayer));
   const clusterContextLayer = Layer87.mergeAll(options.languageModelLayer, memoryLayer50, blobStoreLayer, artifactStoreLayer, promptAssemblerLayer, schemaRegistryLayer);
   const clusterLayer = options.clusterLayer.pipe(Layer87.provide(clusterContextLayer));
@@ -19829,8 +19956,8 @@ var layerWithClient = (options) => {
   const blobStoreLayer = options.blobStoreLayer ?? passthroughLayer;
   const artifactStoreLayer = options.artifactStoreLayer ?? passthroughLayer2;
   const promptAssemblerLayer = options.promptAssemblerLayer ?? defaultPromptAssemblerLayer(blobStoreLayer, artifactStoreLayer);
-  const schemaRegistryLayer = options.schemaRegistryLayer ?? layer42();
-  const embeddingModelLayer = options.embeddingModelLayer ?? memoryLayer40();
+  const schemaRegistryLayer = options.schemaRegistryLayer ?? layer43();
+  const embeddingModelLayer = options.embeddingModelLayer ?? memoryLayer35();
   const memoryLayer50 = layer46().pipe(Layer87.provideMerge(embeddingModelLayer));
   return Layer87.mergeAll(options.checkLayer, runtimeServicesLayerWith(options.toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, options.toolTransitionCoordinatorLayer)).pipe(Layer87.provideMerge(options.languageModelLayer), Layer87.provide(memoryLayer50), Layer87.provideMerge(options.clusterLayer), Layer87.provideMerge(options.repositoryLayer), Layer87.provideMerge(blobStoreLayer), Layer87.provideMerge(artifactStoreLayer));
 };
@@ -19890,8 +20017,8 @@ var layer67 = layerWith({
   checkLayer: sqlCheckLayer,
   clusterLayer: sqlClusterLayer,
   repositoryLayer: sqlRepositoryLayer,
-  languageModelLayer: memoryLayer35(),
-  embeddingModelLayer: memoryLayer40(),
+  languageModelLayer: memoryLayer36(),
+  embeddingModelLayer: memoryLayer35(),
   toolRuntimeLayer: layer29(),
   schedulerLayer: layer64
 });
@@ -19906,7 +20033,7 @@ var testLayerWithServices = (options) => layerWith({
   schedulerLayer: memoryLayer47
 }).pipe(Layer87.provideMerge(testCryptoLayer));
 var testLayerWithLanguageModelService = (languageModelLayer) => testLayerWithServices({ languageModelLayer, toolRuntimeLayer: layer29() });
-var testLayer64 = testLayerWithServices({
+var testLayer65 = testLayerWithServices({
   languageModelLayer: testLanguageModelLayer,
   toolRuntimeLayer: layer29()
 });
@@ -19949,7 +20076,9 @@ __export(exports_definition_runtime, {
   validate: () => validate,
   testHandlersLayer: () => testHandlersLayer2,
   run: () => run5,
+  layerFromRuntime: () => layerFromRuntime2,
   layer: () => layer68,
+  handlersLayer: () => handlersLayer2,
   fanOutIdFor: () => fanOutIdFor,
   WorkflowJoining: () => WorkflowJoining,
   WorkflowCancelled: () => WorkflowCancelled,
@@ -19960,7 +20089,7 @@ __export(exports_definition_runtime, {
   PinnedDefinitionMismatch: () => PinnedDefinitionMismatch,
   HandlerService: () => HandlerService2
 });
-import { Cause as Cause6, Clock as Clock17, Context as Context81, Effect as Effect102, Exit as Exit3, Layer as Layer88, Option as Option31, Schema as Schema103 } from "effect";
+import { Cause as Cause6, Clock as Clock17, Context as Context81, Effect as Effect102, Exit as Exit3, FiberMap as FiberMap2, Layer as Layer88, Option as Option31, Schema as Schema103 } from "effect";
 
 class UnsupportedOperation extends Schema103.TaggedErrorClass()("UnsupportedWorkflowOperation", { operation_id: exports_ids_schema.WorkflowOperationId, kind: Schema103.String }) {
 }
@@ -20258,7 +20387,7 @@ var run5 = Effect102.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
         });
         break;
     }
-    const completedAt2 = yield* Clock17.currentTimeMillis;
+    const completedAt = yield* Clock17.currentTimeMillis;
     const current2 = yield* repository.getOperation(executionId, id2);
     yield* repository.putOperation({
       execution_id: executionId,
@@ -20268,15 +20397,15 @@ var run5 = Effect102.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
       ...current2?.decision === undefined ? {} : { decision: current2.decision },
       ...current2?.fan_out_id === undefined ? {} : { fan_out_id: current2.fan_out_id },
       started_at: startedAt,
-      completed_at: completedAt2,
-      updated_at: completedAt2
+      completed_at: completedAt,
+      updated_at: completedAt
     });
     yield* repository.appendLifecycle({
       execution_id: executionId,
       operation_id: id2,
       type: "operation.completed",
       ...output2 === undefined ? {} : { data: output2 },
-      created_at: completedAt2
+      created_at: completedAt
     });
     return output2;
   });
@@ -20286,11 +20415,7 @@ var run5 = Effect102.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
     if (Option31.isSome(failure3) && failure3.value instanceof WorkflowJoining)
       return yield* result;
     const currentRun = yield* repository.inspect(executionId);
-    const now = yield* Clock17.currentTimeMillis;
     if (currentRun?.status === "cancelled") {
-      const events = yield* repository.listLifecycle(executionId);
-      if (!events.some((event) => event.type === "workflow.cancelled"))
-        yield* repository.appendLifecycle({ execution_id: executionId, type: "workflow.cancelled", created_at: now });
       return yield* result;
     }
     const states = yield* repository.listOperations(executionId);
@@ -20306,45 +20431,35 @@ var run5 = Effect102.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
         created_at: yield* Clock17.currentTimeMillis
       });
       yield* execute(state.compensation_operation_id);
-      const completedAt2 = yield* Clock17.currentTimeMillis;
+      const completedAt = yield* Clock17.currentTimeMillis;
       yield* repository.putOperation({
         ...state,
         status: "compensated",
-        completed_at: completedAt2,
-        updated_at: completedAt2
+        completed_at: completedAt,
+        updated_at: completedAt
       });
       yield* repository.appendLifecycle({
         execution_id: executionId,
         operation_id: state.operation_id,
         type: "compensation.completed",
-        created_at: completedAt2
+        created_at: completedAt
       });
     }
     yield* repository.finish(executionId, "failed");
-    yield* repository.appendLifecycle({
-      execution_id: executionId,
-      type: "workflow.failed",
-      created_at: yield* Clock17.currentTimeMillis
-    });
     return yield* result;
   }
   const output = result.value;
-  const completedAt = yield* Clock17.currentTimeMillis;
-  yield* repository.finish(executionId, "completed");
-  yield* repository.appendLifecycle({
-    execution_id: executionId,
-    type: "workflow.completed",
-    ...output === undefined ? {} : { data: output },
-    created_at: completedAt
-  });
+  yield* repository.finish(executionId, "completed", output);
   return output;
 });
-var testHandlersLayer2 = (handlers) => Layer88.succeed(HandlerService2, handlers);
-var layer68 = Layer88.effect(Service68, Effect102.gen(function* () {
+var handlersLayer2 = (handlers) => Layer88.succeed(HandlerService2, handlers);
+var testHandlersLayer2 = handlersLayer2;
+var layerFromRuntime2 = Layer88.effect(Service68, Effect102.gen(function* () {
   const repository = yield* exports_workflow_definition_repository.Service;
   const handlers = yield* HandlerService2;
+  const hosts = yield* FiberMap2.make();
   const execute = (executionId) => run5(executionId).pipe(Effect102.provideService(HandlerService2, handlers), Effect102.provideService(exports_workflow_definition_repository.Service, repository));
-  const launch = Effect102.fn("WorkflowDefinitionRuntime.launch")((executionId) => execute(executionId).pipe(Effect102.ignore, Effect102.forkDetach, Effect102.asVoid));
+  const launch = Effect102.fn("WorkflowDefinitionRuntime.launch")((executionId) => FiberMap2.run(hosts, executionId, execute(executionId).pipe(Effect102.ignore), { onlyIfMissing: true }).pipe(Effect102.asVoid));
   const recover = Effect102.fn("WorkflowDefinitionRuntime.recover")(function* () {
     const records = yield* repository.listNonterminal();
     yield* Effect102.forEach(records, (record2) => launch(record2.execution_id), { discard: true });
@@ -20360,11 +20475,15 @@ var layer68 = Layer88.effect(Service68, Effect102.gen(function* () {
     recover,
     inspect: repository.inspect,
     replay: repository.listLifecycle,
-    cancel: repository.cancel
+    cancel: Effect102.fn("WorkflowDefinitionRuntime.cancel")(function* (executionId) {
+      const cancelled = yield* repository.cancel(executionId);
+      return cancelled.record;
+    })
   });
   yield* recover();
   return service;
 }));
+var layer68 = layerFromRuntime2;
 
 // ../runtime/src/workflow/activity-version-registry.ts
 var exports_activity_version_registry = {};
@@ -20680,4 +20799,4 @@ var recoverAll = Effect104.fn("ChildFanOutAdmissionService.recoverAll.call")(fun
   const service = yield* Service69;
   return yield* service.recoverAll(inputFor);
 });
-export { __export, exports_ids_schema, exports_shared_schema, exports_address_schema, exports_tool_schema, exports_agent_schema, exports_content_schema, exports_execution_schema, exports_child_orchestration_schema, exports_envelope_schema, exports_inbox_schema, exports_entity_schema, exports_presence_schema, exports_schedule_schema, exports_skill_schema, exports_state_schema, exports_wait_schema, exports_workflow_schema, Dialect, dialect, fromDbTimestamp, fromNullableDbTimestamp, timestampParam, encodeJson, decodeJson, decodeBool, exports_child_execution_repository, exports_child_fan_out_repository, exports_cluster_registry_repository, exports_envelope_repository, exports_notification_bus, exports_execution_event_repository, exports_execution_repository, exports_inbox_repository, exports_schedule_repository, exports_session_repository, exports_skill_definition_repository, exports_steering_repository, exports_tool_call_repository, exports_workflow_definition_repository, exports_address_book_service, exports_event_log_service, exports_wait_service, exports_tool_runtime_service, exports_agent_registry_service, exports_address_resolution_service, exports_agent_event, exports_tool_context, exports_tool_executor, exports_approvals, exports_session, exports_tool_output, exports_compaction, exports_instructions, exports_memory, exports_model_middleware, exports_model_registry, exports_model_resilience, exports_permissions, exports_skill_source, exports_steering, exports_turn_policy, exports_agent, exports_agent_tool, exports_guardrail, exports_handoff, AiError3 as AiError, Chat2 as Chat, EmbeddingModel, IdGenerator, LanguageModel6 as LanguageModel, Model2 as Model, Prompt12 as Prompt, Response8 as Response, ResponseIdTracker, Telemetry2 as Telemetry, Tokenizer3 as Tokenizer, Tool8 as Tool, Toolkit7 as Toolkit, exports_child_run_service, exports_language_model_service, exports_model_call_policy, exports_presence_service, exports_presence_tool, exports_schema_registry_service, exports_blob_store_service, exports_execution_state_service, exports_skill_registry_service, exports_execution_service, exports_tool_transition_coordinator, exports_execution_workflow, exports_wait_signal, exports_topic_service, exports_envelope_service, exports_artifact_store_service, exports_prompt_assembler_service, exports_agent_loop_service, exports_child_fan_out_transition_service, exports_child_fan_out_runtime, exports_execution_entity, exports_entity_registry_service, exports_entity_instance_service, exports_execution_watch_service, exports_session_stream_service, exports_scheduler_service, exports_runner_runtime_service, exports_definition_runtime, exports_activity_version_registry };
+export { __export, exports_ids_schema, exports_shared_schema, exports_address_schema, exports_tool_schema, exports_agent_schema, exports_content_schema, exports_execution_schema, exports_child_orchestration_schema, exports_envelope_schema, exports_inbox_schema, exports_entity_schema, exports_presence_schema, exports_schedule_schema, exports_skill_schema, exports_state_schema, exports_wait_schema, exports_workflow_schema, Dialect, dialect, fromDbTimestamp, fromNullableDbTimestamp, timestampParam, encodeJson, decodeJson, decodeBool, exports_child_execution_repository, exports_child_fan_out_repository, exports_cluster_registry_repository, exports_envelope_repository, exports_notification_bus, exports_execution_event_repository, exports_execution_repository, exports_inbox_repository, exports_schedule_repository, exports_session_repository, exports_skill_definition_repository, exports_steering_repository, exports_tool_call_repository, exports_workflow_definition_repository, exports_address_book_service, exports_event_log_service, exports_wait_service, exports_tool_runtime_service, exports_agent_registry_service, exports_address_resolution_service, exports_agent_event, exports_tool_context, exports_tool_executor, exports_approvals, exports_session, exports_tool_output, exports_compaction, exports_instructions, exports_memory, exports_model_middleware, exports_model_registry, exports_model_resilience, exports_permissions, exports_skill_source, exports_steering, exports_turn_policy, exports_agent, exports_agent_tool, exports_guardrail, exports_handoff, AiError3 as AiError, Chat2 as Chat, EmbeddingModel, IdGenerator, LanguageModel6 as LanguageModel, Model2 as Model, Prompt12 as Prompt, Response8 as Response, ResponseIdTracker, Telemetry2 as Telemetry, Tokenizer3 as Tokenizer, Tool8 as Tool, Toolkit7 as Toolkit, exports_child_run_service, exports_embedding_model_service, exports_language_model_service, exports_model_call_policy, exports_presence_service, exports_presence_tool, exports_schema_registry_service, exports_blob_store_service, exports_execution_state_service, exports_skill_registry_service, exports_execution_service, exports_tool_transition_coordinator, exports_execution_workflow, exports_wait_signal, exports_topic_service, exports_envelope_service, exports_artifact_store_service, exports_prompt_assembler_service, exports_agent_loop_service, exports_child_fan_out_transition_service, exports_child_fan_out_runtime, exports_execution_entity, exports_entity_registry_service, exports_entity_instance_service, exports_execution_watch_service, exports_session_stream_service, exports_scheduler_service, exports_runner_runtime_service, exports_definition_runtime, exports_activity_version_registry };