@relayfx/sdk 0.3.7 → 0.4.1

package/dist/{index-t5bbk8cp.js → index-x32kbvxv.js}

@@ -3,7 +3,7 @@ import {
   __export
 } from "./index-nb39b5ae.js";
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/turn-policy.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/turn-policy.js
 var exports_turn_policy = {};
 __export(exports_turn_policy, {
   untilToolCall: () => untilToolCall,
@@ -74,7 +74,7 @@ var both = dual(2, (first, second) => ({
 }));
 var defaultPolicy = forever;
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/agent-event.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-event.js
 var exports_agent_event = {};
 __export(exports_agent_event, {
   addUsage: () => addUsage,
@@ -193,28 +193,223 @@ class ResumeMismatch extends Schema2.TaggedErrorClass()("@batonfx/core/ResumeMis
 }) {
 }
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/tool-context.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/memory.js
+var exports_memory = {};
+__export(exports_memory, {
+  testLayer: () => testLayer,
+  replaceRecalledMessage: () => replaceRecalledMessage,
+  recalledMessageIdentity: () => recalledMessageIdentity,
+  projectTranscript: () => projectTranscript,
+  noopLayer: () => noopLayer,
+  messageFromRecall: () => messageFromRecall,
+  merge: () => merge,
+  layerNoop: () => layerNoop,
+  itemFromPromptPart: () => itemFromPromptPart,
+  isMessageFromRecall: () => isMessageFromRecall,
+  MemoryError: () => MemoryError,
+  Memory: () => Memory
+});
+import { Context, Effect as Effect2, Layer as Layer2, Option, Schema as Schema3 } from "effect";
+import { dual as dual2 } from "effect/Function";
+import { Prompt as Prompt3 } from "effect/unstable/ai";
+var provenanceOption = "@batonfx/core/memory";
+var recallLineage = new WeakMap;
+var itemFromPromptPart = Option.liftPredicate((part) => part.type === "text" || part.type === "file");
+var isMessageFromRecall = (message) => {
+  const provenance = message.options[provenanceOption];
+  return typeof provenance === "object" && provenance !== null && !Array.isArray(provenance) && "origin" in provenance && provenance.origin === "memoryRecall";
+};
+var messageFromRecall = (content) => {
+  const message = Prompt3.makeMessage("user", {
+    content,
+    options: { [provenanceOption]: { origin: "memoryRecall" } }
+  });
+  recallLineage.set(message, message);
+  return message;
+};
+var replaceRecalledMessage = dual2(2, (message, content) => {
+  const options = isMessageFromRecall(message) ? { ...message.options, [provenanceOption]: { origin: "memoryRecall" } } : { ...message.options };
+  const replacement = Prompt3.makeMessage("user", { content, options });
+  if (isMessageFromRecall(message))
+    recallLineage.set(replacement, recallLineage.get(message) ?? message);
+  return replacement;
+});
+var recalledMessageIdentity = (message) => recallLineage.get(message) ?? message;
+var projectTranscript = (transcript) => {
+  const content = transcript.content.filter((message) => !isMessageFromRecall(message));
+  return content.length === transcript.content.length ? transcript : Prompt3.fromMessages(content);
+};
+
+class MemoryError extends Schema3.TaggedErrorClass()("@batonfx/core/MemoryError", {
+  message: Schema3.String
+}) {
+}
+
+class Memory extends Context.Service()("@batonfx/core/memory") {
+}
+var noop = {
+  recall: () => Effect2.succeed([]),
+  remember: () => Effect2.void,
+  forget: () => Effect2.void
+};
+var merge = dual2(2, (first, second) => ({
+  recall: (input) => Effect2.all([first.recall(input), second.recall(input)]).pipe(Effect2.map(([firstItems, secondItems]) => [...firstItems, ...secondItems])),
+  remember: (input) => Effect2.all([first.remember(input), second.remember(input)], { discard: true }),
+  forget: (input) => Effect2.all([first.forget(input), second.forget(input)], { discard: true })
+}));
+var layerNoop = Layer2.succeed(Memory, Memory.of(noop));
+var noopLayer = layerNoop;
+var testLayer = (implementation) => Layer2.succeed(Memory, Memory.of(implementation));
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/model-registry.js
+var exports_model_registry = {};
+__export(exports_model_registry, {
+  testLayer: () => testLayer2,
+  stream: () => stream,
+  registrations: () => registrations,
+  registrationFromLayer: () => registrationFromLayer,
+  register: () => register,
+  provide: () => provide,
+  operate: () => operate,
+  memoryLayer: () => memoryLayer,
+  layerMemory: () => layerMemory,
+  layerFromRegistrationEffects: () => layerFromRegistrationEffects,
+  layer: () => layer,
+  combine: () => combine,
+  classifyFailure: () => classifyFailure,
+  Service: () => Service,
+  LanguageModelNotRegistered: () => LanguageModelNotRegistered
+});
+import { Chunk, Context as Context2, Effect as Effect3, Function as Function2, Layer as Layer3, Option as Option2, Ref, Schema as Schema4, Semaphore, Stream } from "effect";
+import { LanguageModel as LanguageModel2, Model } from "effect/unstable/ai";
+var FailureClassifierTypeId = Symbol.for("@batonfx/core/model-registry/FailureClassifier");
+var classifyFailure = Function2.dual(2, (model, error) => model[FailureClassifierTypeId]?.(error) ?? "other");
+var attachFailureClassifier = (registration, context) => {
+  if (registration.classifyFailure === undefined)
+    return context;
+  const model = Context2.get(context, LanguageModel2.LanguageModel);
+  const classified = {
+    ...model,
+    [FailureClassifierTypeId]: registration.classifyFailure
+  };
+  return Context2.add(context, LanguageModel2.LanguageModel, classified);
+};
+
+class LanguageModelNotRegistered extends Schema4.TaggedErrorClass()("LanguageModelNotRegistered", {
+  provider: Schema4.String,
+  model: Schema4.String,
+  registration_key: Schema4.optionalKey(Schema4.String)
+}) {
+}
+
+class Service extends Context2.Service()("@batonfx/core/model-registry/Service") {
+}
+var registrationVariantKey = (value) => value.registrationKey ?? null;
+var selectionVariantKey = (selection) => selection.registrationKey ?? null;
+var registryIdentity = (registration) => JSON.stringify([registration.provider, registration.model, registrationVariantKey(registration)]);
+var matchesSelection = (selection) => (registration) => registration.provider === selection.provider && registration.model === selection.model && registrationVariantKey(registration) === selectionVariantKey(selection);
+var upsertRegistration = (registry, registration) => {
+  const key = registryIdentity(registration);
+  const exists = Option2.isSome(Chunk.findFirst(registry, (item) => registryIdentity(item) === key));
+  if (!exists)
+    return Chunk.append(registry, registration);
+  return Chunk.map(registry, (item) => registryIdentity(item) === key ? registration : item);
+};
+var findRegistration = (registry, selection) => Chunk.findFirst(registry, matchesSelection(selection)).pipe(Option2.getOrUndefined);
+var registrationFromLayer = (input) => Model.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect3.map((layer) => ({
+  provider: input.provider,
+  model: input.model,
+  layer,
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  ...input.metadata === undefined ? {} : { metadata: input.metadata },
+  ...input.classifyFailure === undefined ? {} : { classifyFailure: input.classifyFailure }
+})));
+var layer = Function2.dual((args) => args.length === 0 || args.length > 1 || Array.isArray(args[0]), (initialRegistrations = [], options) => Layer3.effect(Service, Effect3.gen(function* () {
+  const registry = yield* Ref.make(initialRegistrations.reduce(upsertRegistration, Chunk.empty()));
+  const semaphore = options?.maxConcurrentModelCalls === undefined ? undefined : yield* Semaphore.make(options.maxConcurrentModelCalls);
+  const register = Effect3.fn("ModelRegistry.register")(function* (input) {
+    yield* Ref.update(registry, (items) => upsertRegistration(items, input.registration));
+  });
+  const registrations = Ref.get(registry).pipe(Effect3.map(Chunk.toReadonlyArray));
+  const operate = Effect3.fn("ModelRegistry.operate")(function* (selection, effect) {
+    const items = yield* Ref.get(registry);
+    const registration = findRegistration(items, selection);
+    if (registration === undefined) {
+      return yield* LanguageModelNotRegistered.make({
+        provider: selection.provider,
+        model: selection.model,
+        ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
+      });
+    }
+    const provided = Effect3.scoped(Layer3.build(registration.layer).pipe(Effect3.flatMap((context) => effect.pipe(Effect3.provide(attachFailureClassifier(registration, context))))));
+    return yield* semaphore === undefined ? provided : semaphore.withPermits(1)(provided);
+  });
+  const stream = (selection, operation) => Stream.unwrap(Effect3.gen(function* () {
+    const items = yield* Ref.get(registry);
+    const registration = findRegistration(items, selection);
+    if (registration === undefined) {
+      return yield* LanguageModelNotRegistered.make({
+        provider: selection.provider,
+        model: selection.model,
+        ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
+      });
+    }
+    if (semaphore !== undefined) {
+      yield* Effect3.acquireRelease(semaphore.take(1), () => semaphore.release(1), { interruptible: true });
+    }
+    const context = attachFailureClassifier(registration, yield* Layer3.build(registration.layer));
+    return operation.pipe(Stream.provideContext(context));
+  }));
+  return Service.of({
+    register,
+    registrations,
+    operate,
+    stream,
+    provide: operate
+  });
+})));
+var layerFromRegistrationEffects = Function2.dual((args) => args.length !== 1 || Array.isArray(args[0]), (registrations, options) => Layer3.unwrap(Effect3.all(registrations).pipe(Effect3.map((items) => layer(items, options)))));
+var combine = Function2.dual((args) => args.length !== 1 || Array.isArray(args[0]), (registries, options) => Layer3.unwrap(Effect3.forEach(registries, (registry) => Layer3.build(registry).pipe(Effect3.flatMap((context) => Context2.get(context, Service).registrations))).pipe(Effect3.map((groups) => layer(groups.flat(), options)))));
+var layerMemory = layer;
+var memoryLayer = layerMemory;
+var testLayer2 = (implementation) => Layer3.succeed(Service, Service.of(implementation));
+var register = Effect3.fn("ModelRegistry.register.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.register(input);
+});
+var registrations = Effect3.fn("ModelRegistry.registrations.call")(function* () {
+  const service = yield* Service;
+  return yield* service.registrations;
+});
+var operate = Function2.dual(2, (selection, effect) => Effect3.gen(function* () {
+  const service = yield* Service;
+  return yield* service.operate(selection, effect);
+}));
+var stream = Function2.dual(2, (selection, operation) => Stream.unwrap(Service.pipe(Effect3.map((service) => service.stream(selection, operation)))));
+var provide = operate;
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-context.js
 var exports_tool_context = {};
 __export(exports_tool_context, {
-  testLayer: () => testLayer,
+  testLayer: () => testLayer3,
   layerDefault: () => layerDefault,
   ToolContext: () => ToolContext
 });
-import { Context, Effect as Effect2, Layer as Layer2 } from "effect";
+import { Context as Context3, Effect as Effect4, Layer as Layer4 } from "effect";
 
-class ToolContext extends Context.Service()("@batonfx/core/tool-context/ToolContext") {
+class ToolContext extends Context3.Service()("@batonfx/core/tool-context/ToolContext") {
 }
-var layerDefault = Layer2.sync(ToolContext, () => ToolContext.of({
+var layerDefault = Layer4.sync(ToolContext, () => ToolContext.of({
   signal: new AbortController().signal,
-  emit: () => Effect2.void,
+  emit: () => Effect4.void,
   sessionId: "local"
 }));
-var testLayer = (implementation) => Layer2.succeed(ToolContext, ToolContext.of(implementation));
+var testLayer3 = (implementation) => Layer4.succeed(ToolContext, ToolContext.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/tool-executor.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-executor.js
 var exports_tool_executor = {};
 __export(exports_tool_executor, {
-  testLayer: () => testLayer2,
+  testLayer: () => testLayer4,
   sandbox: () => sandbox,
   router: () => router,
   routeToolkit: () => routeToolkit,
@@ -229,34 +424,16 @@ __export(exports_tool_executor, {
   FrameworkStage: () => FrameworkStage,
   FrameworkFailure: () => FrameworkFailure
 });
-import { Context as Context2, Effect as Effect3, Layer as Layer3, Option, Schedule, Schema as Schema3, Sink, Stream } from "effect";
-import { AiError, Response as Response3, Tool as Tool2, Toolkit } from "effect/unstable/ai";
-var FrameworkStage = Schema3.Literals([
-  "decode-input",
-  "handler",
-  "encode-success",
-  "encode-domain-failure",
-  "missing-handler",
-  "route",
-  "placement",
-  "authorization"
-]);
+import { Context as Context4, Effect as Effect7, Layer as Layer5, Option as Option3, Schema as Schema6, Sink, Stream as Stream2 } from "effect";
+import { AiError as AiError2, Response as Response3, Tool as Tool4, Toolkit } from "effect/unstable/ai";
 
-class FrameworkFailure extends Schema3.TaggedErrorClass()("@batonfx/core/FrameworkFailure", {
-  stage: FrameworkStage,
-  tool: Schema3.String,
-  message: Schema3.String
-}) {
-}
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-placement.js
+import { Effect as Effect6, Schedule } from "effect";
+import { Tool as Tool3 } from "effect/unstable/ai";
 
-class RemoteRetryError extends Schema3.TaggedErrorClass()("@batonfx/core/RemoteRetryError", {
-  reason: Schema3.Literals(["invalid-max-retries", "missing-operation-key", "changed-operation-key"]),
-  message: Schema3.String
-}) {
-}
-
-class ToolExecutor extends Context2.Service()("@batonfx/core/tool-executor/ToolExecutor") {
-}
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-result-codec.js
+import { Effect as Effect5, Schema as Schema5 } from "effect";
+import { AiError, Tool as Tool2 } from "effect/unstable/ai";
 var resultMessage = (result) => {
   if (typeof result === "string")
     return result;
@@ -273,20 +450,20 @@ var schemaMessage = (error) => error instanceof Error ? error.message : typeof e
 var frameworkFailure = (stage, tool, error) => FrameworkFailure.make({ stage, tool, message: schemaMessage(error) });
 var encodeSuccess = (tool, result) => {
   const schema = tool.successSchema;
-  return Schema3.encodeUnknownEffect(schema)(result).pipe(Effect3.map((encodedResult) => ({ _tag: "Success", result, encodedResult })), Effect3.mapError((error) => frameworkFailure("encode-success", tool.name, error)));
+  return Schema5.encodeUnknownEffect(schema)(result).pipe(Effect5.map((encodedResult) => ({ _tag: "Success", result, encodedResult })), Effect5.mapError((error) => frameworkFailure("encode-success", tool.name, error)));
 };
 var encodeDomainFailure = (tool, failure) => {
   const schema = tool.failureSchema;
-  return Schema3.encodeUnknownEffect(schema)(failure).pipe(Effect3.map((encodedFailure) => ({ _tag: "DomainFailure", failure, encodedFailure })), Effect3.mapError((error) => frameworkFailure("encode-domain-failure", tool.name, error)));
+  return Schema5.encodeUnknownEffect(schema)(failure).pipe(Effect5.map((encodedFailure) => ({ _tag: "DomainFailure", failure, encodedFailure })), Effect5.mapError((error) => frameworkFailure("encode-domain-failure", tool.name, error)));
 };
-var encodeDomainCandidate = (tool, failure) => !Schema3.is(tool.failureSchema)(failure) ? Effect3.fail(frameworkFailure("handler", tool.name, failure)) : encodeDomainFailure(tool, failure);
+var encodeDomainCandidate = (tool, failure) => !Schema5.is(tool.failureSchema)(failure) ? Effect5.fail(frameworkFailure("handler", tool.name, failure)) : encodeDomainFailure(tool, failure);
 var decodeInput = (tool, input) => {
   const schema = tool.parametersSchema;
-  return Schema3.decodeUnknownEffect(schema)(input).pipe(Effect3.asVoid, Effect3.mapError((error) => frameworkFailure("decode-input", tool.name, error)));
+  return Schema5.decodeUnknownEffect(schema)(input).pipe(Effect5.asVoid, Effect5.mapError((error) => frameworkFailure("decode-input", tool.name, error)));
 };
 var decodeSuccess = (tool, result) => {
   const schema = tool.successSchema;
-  return Schema3.decodeUnknownEffect(schema)(result).pipe(Effect3.mapError((error) => frameworkFailure("encode-success", tool.name, error)), Effect3.flatMap((decoded) => encodeSuccess(tool, decoded)));
+  return Schema5.decodeUnknownEffect(schema)(result).pipe(Effect5.mapError((error) => frameworkFailure("encode-success", tool.name, error)), Effect5.flatMap((decoded) => encodeSuccess(tool, decoded)));
 };
 var aiFrameworkFailure = (tool, error) => {
   switch (error.reason._tag) {
@@ -299,52 +476,94 @@ var aiFrameworkFailure = (tool, error) => {
     case "ToolResultEncodingError": {
       if (tool.failureMode === "error")
         return frameworkFailure("encode-success", tool.name, error);
-      const isSuccess = Schema3.isSchema(tool.successSchema) && Schema3.is(tool.successSchema)(error.reason.toolResult);
-      const isDomainFailure = Schema3.isSchema(tool.failureSchema) && Schema3.is(tool.failureSchema)(error.reason.toolResult);
+      const isSuccess = Schema5.isSchema(tool.successSchema) && Schema5.is(tool.successSchema)(error.reason.toolResult);
+      const isDomainFailure = Schema5.isSchema(tool.failureSchema) && Schema5.is(tool.failureSchema)(error.reason.toolResult);
       return frameworkFailure(isSuccess === isDomainFailure ? "handler" : isDomainFailure ? "encode-domain-failure" : "encode-success", tool.name, error);
     }
     default:
       return frameworkFailure("handler", tool.name, error);
   }
 };
-var placementOutcome = (placement, tool, response) => {
+var toolResultCodec = {
+  aiFrameworkFailure,
+  decodeInput,
+  decodeSuccess,
+  encodeDomainCandidate,
+  encodeDomainFailure,
+  encodeSuccess,
+  frameworkFailure,
+  resultMessage,
+  schemaMessage
+};
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-placement.js
+var placementOutcomeFromResponse = (placement, tool, response) => {
   if (typeof response !== "object" || response === null || !("_tag" in response)) {
-    return Effect3.fail(frameworkFailure("placement", tool.name, "Placement returned an invalid response"));
+    return Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Placement returned an invalid response"));
   }
   switch (response._tag) {
     case "DomainFailure":
-      return "failure" in response ? encodeDomainFailure(tool, response.failure) : Effect3.fail(frameworkFailure("placement", tool.name, "DomainFailure response is missing failure"));
+      return "failure" in response ? toolResultCodec.encodeDomainFailure(tool, response.failure) : Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "DomainFailure response is missing failure"));
     case "Suspend":
-      return "token" in response && typeof response.token === "string" ? Effect3.succeed({ _tag: "Suspend", token: response.token }) : Effect3.fail(frameworkFailure("placement", tool.name, "Suspend response is missing a string token"));
+      return "token" in response && typeof response.token === "string" ? Effect6.succeed({ _tag: "Suspend", token: response.token }) : Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Suspend response is missing a string token"));
     case "Success":
-      return "result" in response ? decodeSuccess(tool, response.result).pipe(Effect3.mapError((error) => FrameworkFailure.make({ ...error, message: `${placement} result: ${error.message}` }))) : Effect3.fail(frameworkFailure("placement", tool.name, "Success response is missing result"));
+      return "result" in response ? toolResultCodec.decodeSuccess(tool, response.result).pipe(Effect6.mapError((error) => FrameworkFailure.make({ ...error, message: `${placement} result: ${error.message}` }))) : Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Success response is missing result"));
     default:
-      return Effect3.fail(frameworkFailure("placement", tool.name, "Placement returned an unknown response tag"));
+      return Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Placement returned an unknown response tag"));
   }
 };
+var placementOutcome = { fromResponse: placementOutcomeFromResponse };
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-executor.js
+var FrameworkStage = Schema6.Literals([
+  "decode-input",
+  "handler",
+  "encode-success",
+  "encode-domain-failure",
+  "missing-handler",
+  "route",
+  "placement",
+  "authorization"
+]);
+
+class FrameworkFailure extends Schema6.TaggedErrorClass()("@batonfx/core/FrameworkFailure", {
+  stage: FrameworkStage,
+  tool: Schema6.String,
+  message: Schema6.String
+}) {
+}
+
+class RemoteRetryError extends Schema6.TaggedErrorClass()("@batonfx/core/RemoteRetryError", {
+  reason: Schema6.Literals(["invalid-max-retries", "missing-operation-key", "changed-operation-key"]),
+  message: Schema6.String
+}) {
+}
+
+class ToolExecutor extends Context4.Service()("@batonfx/core/tool-executor/ToolExecutor") {
+}
 var findTool = (tools, name) => tools[name];
 var executeWithToolkit = (toolkit, request) => {
   const tool = findTool(toolkit.tools, request.call.name);
   if (tool === undefined) {
-    return Effect3.fail(frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
+    return Effect7.fail(toolResultCodec.frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
   }
   const handleFailure = (error) => {
-    if (Schema3.is(FrameworkFailure)(error))
-      return Effect3.fail(error);
-    if (AiError.isAiError(error))
-      return Effect3.fail(aiFrameworkFailure(tool, error));
-    return encodeDomainCandidate(tool, error);
+    if (Schema6.is(FrameworkFailure)(error))
+      return Effect7.fail(error);
+    if (AiError2.isAiError(error))
+      return Effect7.fail(toolResultCodec.aiFrameworkFailure(tool, error));
+    return toolResultCodec.encodeDomainCandidate(tool, error);
   };
-  return toolkit.handle(request.call.name, request.call.params).pipe(Effect3.flatMap((results) => results.pipe(Stream.filter((item) => item.preliminary === false), Stream.run(Sink.last()))), Effect3.flatMap((option) => {
-    if (Option.isNone(option)) {
-      return Effect3.fail(frameworkFailure("handler", tool.name, "Tool handler did not produce a final result"));
+  return toolkit.handle(request.call.name, request.call.params).pipe(Effect7.flatMap((results) => results.pipe(Stream2.filter((item) => item.preliminary === false), Stream2.run(Sink.last()))), Effect7.flatMap((option) => {
+    if (Option3.isNone(option)) {
+      return Effect7.fail(toolResultCodec.frameworkFailure("handler", tool.name, "Tool handler did not produce a final result"));
     }
     const result = option.value;
     if (!result.isFailure) {
-      return Effect3.succeed({ _tag: "Success", result: result.result, encodedResult: result.encodedResult });
+      return Effect7.succeed({ _tag: "Success", result: result.result, encodedResult: result.encodedResult });
     }
-    return AiError.isAiError(result.result) ? Effect3.fail(aiFrameworkFailure(tool, result.result)) : encodeDomainFailure(tool, result.result);
-  }), Effect3.catchIf(() => true, handleFailure, handleFailure));
+    return AiError2.isAiError(result.result) ? Effect7.fail(toolResultCodec.aiFrameworkFailure(tool, result.result)) : toolResultCodec.encodeDomainFailure(tool, result.result);
+  }), Effect7.catchIf(() => true, handleFailure, handleFailure));
 };
 function executeToolkit(toolkitOrRequest, request) {
   if (request === undefined) {
@@ -355,10 +574,10 @@ function executeToolkit(toolkitOrRequest, request) {
     return pipeable;
   }
   const toolkit = toolkitOrRequest;
-  return ("handle" in toolkit ? Effect3.succeed(toolkit) : toolkit).pipe(Effect3.flatMap((handled) => executeWithToolkit(handled, request)));
+  return ("handle" in toolkit ? Effect7.succeed(toolkit) : toolkit).pipe(Effect7.flatMap((handled) => executeWithToolkit(handled, request)));
 }
 function fromToolkit(toolkit) {
-  return Layer3.effect(ToolExecutor, ("handle" in toolkit ? Effect3.succeed(toolkit) : toolkit).pipe(Effect3.map((handled) => ToolExecutor.of({
+  return Layer5.effect(ToolExecutor, ("handle" in toolkit ? Effect7.succeed(toolkit) : toolkit).pipe(Effect7.map((handled) => ToolExecutor.of({
     execute: (request) => executeWithToolkit(handled, request)
   }))));
 }
@@ -377,37 +596,37 @@ var placementRoute = (placement, options) => {
     execute: (request) => {
       const tool = findTool(options.toolkit.tools, request.call.name);
       if (tool === undefined) {
-        return Effect3.fail(frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
+        return Effect7.fail(toolResultCodec.frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
       }
-      return decodeInput(tool, request.call.params).pipe(Effect3.flatMap(() => {
+      return toolResultCodec.decodeInput(tool, request.call.params).pipe(Effect7.flatMap(() => {
         const effect = options.execute({ ...request, placement, tool });
         return effect;
-      }), Effect3.mapError((error) => Schema3.is(FrameworkFailure)(error) || Schema3.is(RemoteRetryError)(error) ? error : frameworkFailure("placement", request.call.name, error)), Effect3.flatMap((response) => placementOutcome(placement, tool, response)));
+      }), Effect7.mapError((error) => Schema6.is(FrameworkFailure)(error) || Schema6.is(RemoteRetryError)(error) ? error : toolResultCodec.frameworkFailure("placement", request.call.name, error)), Effect7.flatMap((response) => placementOutcome.fromResponse(placement, tool, response)));
     }
   });
 };
 var remoteRetryError = (reason, message) => RemoteRetryError.make({ reason, message });
-var validateOperationKey = (operationKey) => typeof operationKey !== "string" || operationKey.trim().length === 0 ? Effect3.fail(remoteRetryError("missing-operation-key", "Remote retry operation key must be non-empty")) : Effect3.succeed(operationKey);
-var retryRemote = (options, request) => Effect3.suspend(() => {
+var validateOperationKey = (operationKey) => typeof operationKey !== "string" || operationKey.trim().length === 0 ? Effect7.fail(remoteRetryError("missing-operation-key", "Remote retry operation key must be non-empty")) : Effect7.succeed(operationKey);
+var retryRemote = (options, request) => Effect7.suspend(() => {
   if (!Number.isFinite(options.maxRetries) || !Number.isInteger(options.maxRetries) || options.maxRetries < 0) {
-    return Effect3.fail(remoteRetryError("invalid-max-retries", "Remote retry maxRetries must be a non-negative finite integer"));
+    return Effect7.fail(remoteRetryError("invalid-max-retries", "Remote retry maxRetries must be a non-negative finite integer"));
   }
   const operationKey = typeof options.operationKey === "function" ? options.operationKey(request) : undefined;
-  return validateOperationKey(operationKey).pipe(Effect3.flatMap((stableKey) => {
+  return validateOperationKey(operationKey).pipe(Effect7.flatMap((stableKey) => {
     let attempt = 0;
-    const executeAttempt = Effect3.suspend(() => {
+    const executeAttempt = Effect7.suspend(() => {
       const currentKey = attempt === 0 ? stableKey : options.operationKey(request);
       attempt += 1;
-      return validateOperationKey(currentKey).pipe(Effect3.match({
+      return validateOperationKey(currentKey).pipe(Effect7.match({
         onFailure: (error) => error,
         onSuccess: (validatedKey) => validatedKey
-      }), Effect3.flatMap((validatedKey) => typeof validatedKey !== "string" ? Effect3.succeed(validatedKey) : validatedKey === stableKey ? options.execute({ ...request, operationKey: stableKey }) : Effect3.succeed(remoteRetryError("changed-operation-key", "Remote retry operation key changed between attempts"))));
+      }), Effect7.flatMap((validatedKey) => typeof validatedKey !== "string" ? Effect7.succeed(validatedKey) : validatedKey === stableKey ? options.execute({ ...request, operationKey: stableKey }) : Effect7.succeed(remoteRetryError("changed-operation-key", "Remote retry operation key changed between attempts"))));
     });
-    return Effect3.retry(executeAttempt, {
+    return Effect7.retry(executeAttempt, {
       schedule: options.schedule,
       times: options.maxRetries,
-      while: (error) => !Schema3.is(AgentError)(error) && !Schema3.is(FrameworkFailure)(error) && !Schema3.is(RemoteRetryError)(error)
-    }).pipe(Effect3.flatMap((result) => Schema3.is(RemoteRetryError)(result) ? Effect3.fail(result) : Effect3.succeed(result)));
+      while: (error) => !Schema6.is(AgentError)(error) && !Schema6.is(FrameworkFailure)(error) && !Schema6.is(RemoteRetryError)(error)
+    }).pipe(Effect7.flatMap((result) => Schema6.is(RemoteRetryError)(result) ? Effect7.fail(result) : Effect7.succeed(result)));
   }));
 });
 var client = (options) => placementRoute("client", options);
@@ -423,128 +642,60 @@ function routeToolkit(toolkit) {
     tools: Object.keys(handled.tools),
     execute: (request) => executeWithToolkit(handled, request)
   });
-  return "handle" in toolkit ? makeRoute(toolkit) : toolkit.pipe(Effect3.map(makeRoute));
+  return "handle" in toolkit ? makeRoute(toolkit) : toolkit.pipe(Effect7.map(makeRoute));
 }
-var routeInputEffect = (input) => Effect3.isEffect(input) ? input : Effect3.succeed(input);
+var routeInputEffect = (input) => Effect7.isEffect(input) ? input : Effect7.succeed(input);
 function router(routes) {
-  return Layer3.effect(ToolExecutor, Effect3.all(Array.from(routes, routeInputEffect)).pipe(Effect3.map((resolved) => ToolExecutor.of({
+  return Layer5.effect(ToolExecutor, Effect7.all(Array.from(routes, routeInputEffect)).pipe(Effect7.map((resolved) => ToolExecutor.of({
     execute: (request) => {
       const matched = resolved.find((candidate) => candidate.matches(request));
-      return matched === undefined ? Effect3.fail(frameworkFailure("route", request.call.name, `Tool ${request.call.name} has no matching route`)) : matched.execute(request);
+      return matched === undefined ? Effect7.fail(toolResultCodec.frameworkFailure("route", request.call.name, `Tool ${request.call.name} has no matching route`)) : matched.execute(request);
     }
   }))));
 }
-var testLayer2 = (implementation) => Layer3.succeed(ToolExecutor, ToolExecutor.of(implementation));
+var testLayer4 = (implementation) => Layer5.succeed(ToolExecutor, ToolExecutor.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/approvals.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/approvals.js
 var exports_approvals = {};
 __export(exports_approvals, {
-  testLayer: () => testLayer3,
+  testLayer: () => testLayer5,
   denyAll: () => denyAll,
   autoApprove: () => autoApprove,
   Approvals: () => Approvals
 });
-import { Context as Context3, Effect as Effect4, Layer as Layer4 } from "effect";
-class Approvals extends Context3.Service()("@batonfx/core/approvals") {
+import { Context as Context5, Effect as Effect8, Layer as Layer6 } from "effect";
+class Approvals extends Context5.Service()("@batonfx/core/approvals") {
 }
-var autoApprove = Layer4.succeed(Approvals, Approvals.of({ check: () => Effect4.succeed({ _tag: "Approved" }) }));
-var denyAll = Layer4.succeed(Approvals, Approvals.of({ check: () => Effect4.succeed({ _tag: "Denied" }) }));
-var testLayer3 = (implementation) => Layer4.succeed(Approvals, Approvals.of(implementation));
+var autoApprove = Layer6.succeed(Approvals, Approvals.of({ check: () => Effect8.succeed({ _tag: "Approved" }) }));
+var denyAll = Layer6.succeed(Approvals, Approvals.of({ check: () => Effect8.succeed({ _tag: "Denied" }) }));
+var testLayer5 = (implementation) => Layer6.succeed(Approvals, Approvals.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/memory.js
-var exports_memory = {};
-__export(exports_memory, {
-  testLayer: () => testLayer4,
-  replaceRecalledMessage: () => replaceRecalledMessage,
-  recalledMessageIdentity: () => recalledMessageIdentity,
-  projectTranscript: () => projectTranscript,
-  noopLayer: () => noopLayer,
-  messageFromRecall: () => messageFromRecall,
-  merge: () => merge,
-  layerNoop: () => layerNoop,
-  itemFromPromptPart: () => itemFromPromptPart,
-  isMessageFromRecall: () => isMessageFromRecall,
-  MemoryError: () => MemoryError,
-  Memory: () => Memory
-});
-import { Context as Context4, Effect as Effect5, Layer as Layer5, Option as Option2, Schema as Schema4 } from "effect";
-import { dual as dual2 } from "effect/Function";
-import { Prompt as Prompt3 } from "effect/unstable/ai";
-var provenanceOption = "@batonfx/core/memory";
-var recallLineage = new WeakMap;
-var itemFromPromptPart = Option2.liftPredicate((part) => part.type === "text" || part.type === "file");
-var isMessageFromRecall = (message) => {
-  const provenance = message.options[provenanceOption];
-  return typeof provenance === "object" && provenance !== null && !Array.isArray(provenance) && "origin" in provenance && provenance.origin === "memoryRecall";
-};
-var messageFromRecall = (content) => {
-  const message = Prompt3.makeMessage("user", {
-    content,
-    options: { [provenanceOption]: { origin: "memoryRecall" } }
-  });
-  recallLineage.set(message, message);
-  return message;
-};
-var replaceRecalledMessage = dual2(2, (message, content) => {
-  const options = isMessageFromRecall(message) ? { ...message.options, [provenanceOption]: { origin: "memoryRecall" } } : { ...message.options };
-  const replacement = Prompt3.makeMessage("user", { content, options });
-  if (isMessageFromRecall(message))
-    recallLineage.set(replacement, recallLineage.get(message) ?? message);
-  return replacement;
-});
-var recalledMessageIdentity = (message) => recallLineage.get(message) ?? message;
-var projectTranscript = (transcript) => {
-  const content = transcript.content.filter((message) => !isMessageFromRecall(message));
-  return content.length === transcript.content.length ? transcript : Prompt3.fromMessages(content);
-};
-
-class MemoryError extends Schema4.TaggedErrorClass()("@batonfx/core/MemoryError", {
-  message: Schema4.String
-}) {
-}
-
-class Memory extends Context4.Service()("@batonfx/core/memory") {
-}
-var noop = {
-  recall: () => Effect5.succeed([]),
-  remember: () => Effect5.void,
-  forget: () => Effect5.void
-};
-var merge = dual2(2, (first, second) => ({
-  recall: (input) => Effect5.all([first.recall(input), second.recall(input)]).pipe(Effect5.map(([firstItems, secondItems]) => [...firstItems, ...secondItems])),
-  remember: (input) => Effect5.all([first.remember(input), second.remember(input)], { discard: true }),
-  forget: (input) => Effect5.all([first.forget(input), second.forget(input)], { discard: true })
-}));
-var layerNoop = Layer5.succeed(Memory, Memory.of(noop));
-var noopLayer = layerNoop;
-var testLayer4 = (implementation) => Layer5.succeed(Memory, Memory.of(implementation));
-
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/session.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/session.js
 var exports_session = {};
 __export(exports_session, {
-  testLayer: () => testLayer5,
-  memoryLayer: () => memoryLayer,
-  layerMemory: () => layerMemory,
+  testLayer: () => testLayer6,
+  memoryLayer: () => memoryLayer2,
+  layerMemory: () => layerMemory2,
   buildMemoryContext: () => buildMemoryContext,
   buildContext: () => buildContext,
   SessionStoreError: () => SessionStoreError,
   SessionStore: () => SessionStore,
   SessionConflict: () => SessionConflict
 });
-import { Context as Context5, Effect as Effect6, HashMap, Layer as Layer6, Option as Option3, Ref, Schema as Schema5 } from "effect";
+import { Context as Context6, Effect as Effect9, HashMap, Layer as Layer7, Option as Option4, Ref as Ref2, Schema as Schema7 } from "effect";
 import { Prompt as Prompt4 } from "effect/unstable/ai";
-class SessionStoreError extends Schema5.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
-  message: Schema5.String
+class SessionStoreError extends Schema7.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
+  message: Schema7.String
 }) {
 }
 
-class SessionConflict extends Schema5.TaggedErrorClass()("@batonfx/core/SessionConflict", {
-  reason: Schema5.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path"]),
-  message: Schema5.String
+class SessionConflict extends Schema7.TaggedErrorClass()("@batonfx/core/SessionConflict", {
+  reason: Schema7.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path"]),
+  message: Schema7.String
 }) {
 }
 
-class SessionStore extends Context5.Service()("@batonfx/core/session/SessionStore") {
+class SessionStore extends Context6.Service()("@batonfx/core/session/SessionStore") {
 }
 var initialState = {
   entries: HashMap.empty(),
@@ -557,8 +708,8 @@ var failure = (message) => ({
   _tag: "Failure",
   error: SessionStoreError.make({ message })
 });
-var effectFromResult = (result) => result._tag === "Failure" ? Effect6.fail(result.error) : Effect6.succeed(result.value);
-var effectFromAppendResult = (result) => result._tag === "@batonfx/core/SessionConflict" ? Effect6.fail(result) : effectFromResult(result);
+var effectFromResult = (result) => result._tag === "Failure" ? Effect9.fail(result.error) : Effect9.succeed(result.value);
+var effectFromAppendResult = (result) => result._tag === "@batonfx/core/SessionConflict" ? Effect9.fail(result) : effectFromResult(result);
 var entryFromInput = (input, id, parentId) => {
   const base = {
     id,
@@ -593,7 +744,7 @@ var pathFromState = (state, leaf) => {
     if (entries.length > state.order.length)
       return failure(`Session path for leaf ${leaf} contains a cycle`);
     const entry = HashMap.get(state.entries, cursor);
-    if (Option3.isNone(entry))
+    if (Option4.isNone(entry))
       return failure(`Session entry ${cursor} does not exist`);
     const value = entry.value;
     entries.push(value);
@@ -639,11 +790,11 @@ var appendState = (state, input, options) => {
     }
   ];
 };
-var promptEquivalence = Schema5.toEquivalence(Prompt4.Prompt);
+var promptEquivalence = Schema7.toEquivalence(Prompt4.Prompt);
 var checkpointMatches = (entry, prepared) => entry.parentId === prepared.parentId && entry.summary === prepared.summary && promptEquivalence(entry.projectedHistory, prepared.projectedHistory);
 var appendCheckpointState = (state, prepared) => {
   const existing = HashMap.get(state.entries, prepared.id);
-  if (Option3.isSome(existing)) {
+  if (Option4.isSome(existing)) {
     const entry = existing.value;
     if (entry._tag !== "Compaction" || entry.version !== 2 || !checkpointMatches(entry, prepared)) {
       return [
@@ -700,7 +851,7 @@ var appendCheckpointState = (state, prepared) => {
   ];
 };
 var setLeafState = (state, id) => {
-  if (id !== null && Option3.isNone(HashMap.get(state.entries, id)))
+  if (id !== null && Option4.isNone(HashMap.get(state.entries, id)))
     return [failure(`Session entry ${id} does not exist`), state];
   return [success(undefined), { ...state, leaf: id }];
 };
@@ -784,46 +935,46 @@ var buildMemoryContext = (path) => {
   });
   return projectTranscript(Prompt4.fromMessages(messages));
 };
-var layerMemory = Layer6.effect(SessionStore, Ref.make(initialState).pipe(Effect6.map((state) => SessionStore.of({
-  reserveEntryId: Ref.modify(state, (current) => [
+var layerMemory2 = Layer7.effect(SessionStore, Ref2.make(initialState).pipe(Effect9.map((state) => SessionStore.of({
+  reserveEntryId: Ref2.modify(state, (current) => [
     String(current.counter),
     { ...current, counter: current.counter + 1 }
   ]),
-  append: (entry, options) => Ref.modify(state, (current) => appendState(current, entry, options)).pipe(Effect6.flatMap(effectFromAppendResult)),
-  appendCheckpoint: (checkpoint) => Ref.modify(state, (current) => appendCheckpointState(current, checkpoint)).pipe(Effect6.flatMap((result) => result._tag === "@batonfx/core/SessionConflict" ? Effect6.fail(result) : Effect6.succeed(result))),
-  path: (leaf) => Ref.get(state).pipe(Effect6.flatMap((current) => leaf === undefined && current.leaf === null ? Effect6.succeed([]) : effectFromResult(pathFromState(current, leaf ?? current.leaf ?? "")))),
-  setLeaf: (id) => Ref.modify(state, (current) => setLeafState(current, id)).pipe(Effect6.flatMap(effectFromResult)),
-  leaf: Ref.get(state).pipe(Effect6.map((current) => current.leaf))
+  append: (entry, options) => Ref2.modify(state, (current) => appendState(current, entry, options)).pipe(Effect9.flatMap(effectFromAppendResult)),
+  appendCheckpoint: (checkpoint) => Ref2.modify(state, (current) => appendCheckpointState(current, checkpoint)).pipe(Effect9.flatMap((result) => result._tag === "@batonfx/core/SessionConflict" ? Effect9.fail(result) : Effect9.succeed(result))),
+  path: (leaf) => Ref2.get(state).pipe(Effect9.flatMap((current) => leaf === undefined && current.leaf === null ? Effect9.succeed([]) : effectFromResult(pathFromState(current, leaf ?? current.leaf ?? "")))),
+  setLeaf: (id) => Ref2.modify(state, (current) => setLeafState(current, id)).pipe(Effect9.flatMap(effectFromResult)),
+  leaf: Ref2.get(state).pipe(Effect9.map((current) => current.leaf))
 }))));
-var memoryLayer = layerMemory;
-var testLayer5 = (implementation) => Layer6.succeed(SessionStore, SessionStore.of(implementation));
+var memoryLayer2 = layerMemory2;
+var testLayer6 = (implementation) => Layer7.succeed(SessionStore, SessionStore.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/tool-output.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-output.js
 var exports_tool_output = {};
 __export(exports_tool_output, {
-  testLayer: () => testLayer6,
+  testLayer: () => testLayer7,
   layerNoop: () => layerNoop2,
-  layerMemory: () => layerMemory2,
+  layerMemory: () => layerMemory3,
   bound: () => bound,
   ToolOutputStore: () => ToolOutputStore,
   ToolOutputError: () => ToolOutputError
 });
-import { Cause, Context as Context6, Effect as Effect7, Function as Function2, HashMap as HashMap2, Layer as Layer7, Option as Option4, Ref as Ref2, Schema as Schema6 } from "effect";
-class ToolOutputStore extends Context6.Service()("@batonfx/core/tool-output/ToolOutputStore") {
+import { Cause, Context as Context7, Effect as Effect10, Function as Function3, HashMap as HashMap2, Layer as Layer8, Option as Option5, Ref as Ref3, Schema as Schema8 } from "effect";
+class ToolOutputStore extends Context7.Service()("@batonfx/core/tool-output/ToolOutputStore") {
 }
 
-class ToolOutputError extends Schema6.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
-  message: Schema6.String
+class ToolOutputError extends Schema8.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
+  message: Schema8.String
 }) {
 }
-var layerNoop2 = Layer7.succeed(ToolOutputStore, ToolOutputStore.of({ put: () => Effect7.succeed(Option4.none()) }));
-var layerMemory2 = Layer7.effect(ToolOutputStore, Ref2.make({ next: 0, records: HashMap2.empty() }).pipe(Effect7.map((state) => ToolOutputStore.of({
-  put: (toolCallId, content) => Ref2.modify(state, ({ next, records }) => {
+var layerNoop2 = Layer8.succeed(ToolOutputStore, ToolOutputStore.of({ put: () => Effect10.succeed(Option5.none()) }));
+var layerMemory3 = Layer8.effect(ToolOutputStore, Ref3.make({ next: 0, records: HashMap2.empty() }).pipe(Effect10.map((state) => ToolOutputStore.of({
+  put: (toolCallId, content) => Ref3.modify(state, ({ next, records }) => {
     const id = `mem:tool-output-${next + 1}`;
-    return [Option4.some(id), { next: next + 1, records: HashMap2.set(records, id, { toolCallId, content }) }];
+    return [Option5.some(id), { next: next + 1, records: HashMap2.set(records, id, { toolCallId, content }) }];
   })
 }))));
-var testLayer6 = (implementation) => Layer7.succeed(ToolOutputStore, ToolOutputStore.of(implementation));
+var testLayer7 = (implementation) => Layer8.succeed(ToolOutputStore, ToolOutputStore.of(implementation));
 var encoder = new TextEncoder;
 var decoder = new TextDecoder;
 var serialized = (value) => {
@@ -848,11 +999,11 @@ var bounded = (inline, outputPaths) => {
   return { _tag: "Success", result: output, encodedResult: output, outputPaths };
 };
 var boundedFromOriginal = (encoded, bytes, maxBytes, outputPaths) => bounded({ truncated: true, bytes, maxBytes, preview: preview(encoded, maxBytes) }, outputPaths);
-var optionalStore = (store, toolCallId, result) => store.put(toolCallId, { result: result.result, encodedResult: result.encodedResult }).pipe(Effect7.catchCause((cause) => {
+var optionalStore = (store, toolCallId, result) => store.put(toolCallId, { result: result.result, encodedResult: result.encodedResult }).pipe(Effect10.catchCause((cause) => {
   const unrecoverable = cause.reasons.filter((reason) => Cause.isDieReason(reason) || Cause.isInterruptReason(reason));
-  return unrecoverable.length === 0 ? Effect7.succeed(Option4.none()) : Effect7.failCause(Cause.fromReasons(unrecoverable));
+  return unrecoverable.length === 0 ? Effect10.succeed(Option5.none()) : Effect10.failCause(Cause.fromReasons(unrecoverable));
 }));
-var bound = Function2.dual(2, (result, options) => Effect7.gen(function* () {
+var bound = Function3.dual(2, (result, options) => Effect10.gen(function* () {
   if (isToolOutput(result.encodedResult)) {
     const output = result.encodedResult;
     const outputPaths = output.outputPaths ?? [];
@@ -865,25 +1016,25 @@ var bound = Function2.dual(2, (result, options) => Effect7.gen(function* () {
   const bytes = encoder.encode(encoded).byteLength;
   if (bytes <= options.maxBytes)
     return { ...result, outputPaths: [] };
-  const maybeStore = yield* Effect7.serviceOption(ToolOutputStore);
-  if (Option4.isNone(maybeStore))
+  const maybeStore = yield* Effect10.serviceOption(ToolOutputStore);
+  if (Option5.isNone(maybeStore))
     return boundedFromOriginal(encoded, bytes, options.maxBytes, []);
   const path = yield* optionalStore(maybeStore.value, options.toolCallId, result);
-  if (Option4.isNone(path))
+  if (Option5.isNone(path))
     return boundedFromOriginal(encoded, bytes, options.maxBytes, []);
   return boundedFromOriginal(encoded, bytes, options.maxBytes, [path.value]);
 }));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/compaction.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/compaction.js
 var exports_compaction = {};
 __export(exports_compaction, {
   truncate: () => truncate,
   toolOutputBound: () => toolOutputBound,
-  testLayer: () => testLayer7,
+  testLayer: () => testLayer8,
   structuredSummary: () => structuredSummary,
   strategy: () => strategy,
   make: () => make2,
-  layer: () => layer,
+  layer: () => layer2,
   keepRecent: () => keepRecent,
   defaultStrategy: () => defaultStrategy,
   SUMMARY_TEMPLATE: () => SUMMARY_TEMPLATE,
@@ -893,8 +1044,8 @@ __export(exports_compaction, {
   Compaction: () => Compaction,
   AgentSummary: () => AgentSummary
 });
-import { Context as Context7, Effect as Effect8, Function as Function3, Layer as Layer8, Option as Option5, Schema as Schema7 } from "effect";
-import { LanguageModel as LanguageModel2, Prompt as Prompt5, Tokenizer, Toolkit as Toolkit2 } from "effect/unstable/ai";
+import { Context as Context8, Effect as Effect11, Function as Function4, Layer as Layer9, Option as Option6, Schema as Schema9 } from "effect";
+import { LanguageModel as LanguageModel3, Prompt as Prompt5, Tokenizer, Toolkit as Toolkit2 } from "effect/unstable/ai";
 var DEFAULT_RESERVE_TOKENS = 16384;
 var DEFAULT_KEEP_RECENT_TOKENS = 20000;
 var SUMMARY_TEMPLATE = `Summarize the conversation so another agent can continue seamlessly.
@@ -912,21 +1063,21 @@ Use Markdown with these sections:
 ## Critical Context
 
 Do not mention that context was compacted.`;
-var AgentSummary = Schema7.Struct({
-  goal: Schema7.String,
-  facts: Schema7.Array(Schema7.String),
-  decisions: Schema7.Array(Schema7.String),
-  openQuestions: Schema7.Array(Schema7.String),
-  toolFindings: Schema7.Array(Schema7.String)
+var AgentSummary = Schema9.Struct({
+  goal: Schema9.String,
+  facts: Schema9.Array(Schema9.String),
+  decisions: Schema9.Array(Schema9.String),
+  openQuestions: Schema9.Array(Schema9.String),
+  toolFindings: Schema9.Array(Schema9.String)
 });
 
-class CompactionError extends Schema7.TaggedErrorClass()("@batonfx/core/CompactionError", {
-  message: Schema7.String,
-  cause: Schema7.optionalKey(Schema7.Defect())
+class CompactionError extends Schema9.TaggedErrorClass()("@batonfx/core/CompactionError", {
+  message: Schema9.String,
+  cause: Schema9.optionalKey(Schema9.Defect())
 }) {
 }
 
-class Compaction extends Context7.Service()("@batonfx/core/compaction") {
+class Compaction extends Context8.Service()("@batonfx/core/compaction") {
 }
 var serialized2 = (value) => {
   const json = JSON.stringify(value);
@@ -962,7 +1113,7 @@ var isPromptToolResult = (part) => part.type === "tool-result";
 var messageHasToolCall = (message) => typeof message.content !== "string" && message.content.some((part) => part.type === "tool-call");
 var isToolMessage = (entry) => entry?._tag === "Message" && entry.message.role === "tool";
 var isAssistantToolCallEntry = (entry) => entry?._tag === "Message" && entry.message.role === "assistant" && messageHasToolCall(entry.message);
-var compactToolPart = (part, maxBytes) => Effect8.gen(function* () {
+var compactToolPart = (part, maxBytes) => Effect11.gen(function* () {
   if (part.isFailure)
     return [part, false];
   const success2 = { _tag: "Success", result: part.result, encodedResult: part.result };
@@ -979,7 +1130,7 @@ var compactToolPart = (part, maxBytes) => Effect8.gen(function* () {
     true
   ];
 });
-var microcompactPrompt = (prompt, maxBytes) => Effect8.gen(function* () {
+var microcompactPrompt = (prompt, maxBytes) => Effect11.gen(function* () {
   let changed = false;
   const messages = [];
   for (const message of prompt.content) {
@@ -1041,23 +1192,23 @@ var defaultStrategy = (options = {}) => ({
   cut: (entries, keepRecentTokens) => {
     const index = safeCutIndex(entries, keepRecentTokens);
     if (index <= 0 || index >= entries.length)
-      return Option5.none();
+      return Option6.none();
     const recent = entries.slice(index);
     const first = recent[0];
-    return first === undefined ? Option5.none() : Option5.some({ firstKeptEntryId: first.id, head: entries.slice(0, index), recent });
+    return first === undefined ? Option6.none() : Option6.some({ firstKeptEntryId: first.id, head: entries.slice(0, index), recent });
   },
   summarize: (plan, request) => {
-    const effect = Effect8.gen(function* () {
+    const effect = Effect11.gen(function* () {
       const head = buildContext(plan.head);
       const [compactedHead] = request.toolOutputMaxBytes === undefined ? [head, false] : yield* microcompactPrompt(head, request.toolOutputMaxBytes);
       const prompt = summaryPrompt(options.summaryPrompt ?? SUMMARY_TEMPLATE, compactedHead);
-      const model = yield* LanguageModel2.LanguageModel;
-      return yield* model.generateText({ prompt, toolkit: Toolkit2.empty, toolChoice: "none" }).pipe(Effect8.map((response) => response.text), Effect8.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
+      const model = yield* LanguageModel3.LanguageModel;
+      return yield* model.generateText({ prompt, toolkit: Toolkit2.empty, toolChoice: "none" }).pipe(Effect11.map((response) => response.text), Effect11.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
     });
-    return options.summaryModel === undefined ? effect : Effect8.scoped(Layer8.build(options.summaryModel).pipe(Effect8.flatMap((context) => effect.pipe(Effect8.provide(context)))));
+    return options.summaryModel === undefined ? effect : Effect11.scoped(Layer9.build(options.summaryModel).pipe(Effect11.flatMap((context) => effect.pipe(Effect11.provide(context)))));
   }
 });
-var strategy = Function3.dual((args) => args.length !== 1 || Array.isArray(args[0]), (parts, base = defaultStrategy()) => parts.reduce((current, part) => ({
+var strategy = Function4.dual((args) => args.length !== 1 || Array.isArray(args[0]), (parts, base = defaultStrategy()) => parts.reduce((current, part) => ({
   shouldCompact: part.shouldCompact ?? current.shouldCompact,
   cut: part.cut ?? current.cut,
   summarize: part.summarize ?? current.summarize,
@@ -1072,27 +1223,27 @@ var keepRecent = (options) => ({
 });
 var structuredSummary = (options = {}) => ({
   summarize: (plan, request) => {
-    const effect = Effect8.gen(function* () {
+    const effect = Effect11.gen(function* () {
       const head = buildContext(plan.head);
       const [compactedHead] = request.toolOutputMaxBytes === undefined ? [head, false] : yield* microcompactPrompt(head, request.toolOutputMaxBytes);
       const prompt = summaryPrompt(options.summaryPrompt ?? SUMMARY_TEMPLATE, compactedHead);
-      const model = yield* LanguageModel2.LanguageModel;
+      const model = yield* LanguageModel3.LanguageModel;
       return yield* model.generateObject({
         prompt,
         schema: AgentSummary,
         objectName: options.objectName ?? "AgentSummary",
         toolChoice: "none"
-      }).pipe(Effect8.map((response) => renderAgentSummary(response.value)), Effect8.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
+      }).pipe(Effect11.map((response) => renderAgentSummary(response.value)), Effect11.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
     });
-    return options.summaryModel === undefined ? effect : Effect8.scoped(Layer8.build(options.summaryModel).pipe(Effect8.flatMap((context) => effect.pipe(Effect8.provide(context)))));
+    return options.summaryModel === undefined ? effect : Effect11.scoped(Layer9.build(options.summaryModel).pipe(Effect11.flatMap((context) => effect.pipe(Effect11.provide(context)))));
   }
 });
-var make2 = Function3.dual((args) => args.length !== 1 || ("shouldCompact" in args[0]), (compactionStrategy, options = {}) => ({
-  maybeCompact: (input) => Effect8.gen(function* () {
+var make2 = Function4.dual((args) => args.length !== 1 || ("shouldCompact" in args[0]), (compactionStrategy, options = {}) => ({
+  maybeCompact: (input) => Effect11.gen(function* () {
     const usage = normalizeUsage(input.usage, options);
     const shouldCompact = input.overflow || compactionStrategy.shouldCompact(usage);
     if (!shouldCompact)
-      return Option5.none();
+      return Option6.none();
     let history = input.history;
     let prompt = input.prompt;
     let changed = false;
@@ -1104,11 +1255,11 @@ var make2 = Function3.dual((args) => args.length !== 1 || ("shouldCompact" in ar
       prompt = compactedPrompt;
       changed = historyChanged || promptChanged;
       if (changed && fits(history, prompt, usage))
-        return Option5.some(makeMicrocompact(history, prompt));
+        return Option6.some(makeMicrocompact(history, prompt));
     }
     const plan = compactionStrategy.cut(input.path ?? [], compactionStrategy.keepRecentTokens ?? options.keepRecentTokens ?? DEFAULT_KEEP_RECENT_TOKENS);
-    if (Option5.isNone(plan))
-      return changed ? Option5.some(makeMicrocompact(history, prompt)) : Option5.none();
+    if (Option6.isNone(plan))
+      return changed ? Option6.some(makeMicrocompact(history, prompt)) : Option6.none();
     const summary = yield* compactionStrategy.summarize(plan.value, {
       ...input,
       history,
@@ -1118,7 +1269,7 @@ var make2 = Function3.dual((args) => args.length !== 1 || ("shouldCompact" in ar
     });
     const recent = buildContext(plan.value.recent);
     const [compactedRecent] = toolOutputMaxBytes === undefined ? [recent, false] : yield* microcompactPrompt(recent, toolOutputMaxBytes);
-    return Option5.some({
+    return Option6.some({
       _tag: "Summarize",
       history: compactedHistory(summary, plan.value.head, compactedRecent),
       prompt,
@@ -1127,42 +1278,42 @@ var make2 = Function3.dual((args) => args.length !== 1 || ("shouldCompact" in ar
     });
   })
 }));
-var layer = Function3.dual((args) => args.length !== 1 || !("shouldCompact" in args[0]), (options = {}, providedStrategy = options.strategy ?? defaultStrategy(options)) => Layer8.succeed(Compaction, Compaction.of(make2(providedStrategy, options))));
+var layer2 = Function4.dual((args) => args.length !== 1 || !("shouldCompact" in args[0]), (options = {}, providedStrategy = options.strategy ?? defaultStrategy(options)) => Layer9.succeed(Compaction, Compaction.of(make2(providedStrategy, options))));
 var truncate = (maxTokens) => ({
-  maybeCompact: (input) => Effect8.gen(function* () {
+  maybeCompact: (input) => Effect11.gen(function* () {
     const usage = input.usage;
     if (!input.overflow && !(Number.isFinite(usage.contextWindow) && usage.contextTokens > usage.contextWindow - usage.reserveTokens)) {
-      return Option5.none();
+      return Option6.none();
     }
-    const tokenizer = yield* Effect8.serviceOption(Tokenizer.Tokenizer);
-    if (Option5.isNone(tokenizer))
-      return Option5.none();
-    const prompt = yield* tokenizer.value.truncate(Prompt5.concat(input.history, input.prompt), maxTokens).pipe(Effect8.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
-    return Option5.some(makeMicrocompact(Prompt5.empty, prompt));
+    const tokenizer = yield* Effect11.serviceOption(Tokenizer.Tokenizer);
+    if (Option6.isNone(tokenizer))
+      return Option6.none();
+    const prompt = yield* tokenizer.value.truncate(Prompt5.concat(input.history, input.prompt), maxTokens).pipe(Effect11.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
+    return Option6.some(makeMicrocompact(Prompt5.empty, prompt));
   })
 });
-var testLayer7 = (implementation) => Layer8.succeed(Compaction, Compaction.of(implementation));
+var testLayer8 = (implementation) => Layer9.succeed(Compaction, Compaction.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/instructions.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/instructions.js
 var exports_instructions = {};
 __export(exports_instructions, {
-  testLayer: () => testLayer8,
+  testLayer: () => testLayer9,
   staticSource: () => staticSource,
   renderUpdate: () => renderUpdate,
   openEpoch: () => openEpoch,
-  layer: () => layer2,
+  layer: () => layer3,
   Instructions: () => Instructions
 });
-import { Context as Context8, Effect as Effect9, Layer as Layer9, Option as Option6 } from "effect";
+import { Context as Context9, Effect as Effect12, Layer as Layer10, Option as Option7 } from "effect";
 import { dual as dual3 } from "effect/Function";
-class Instructions extends Context8.Service()("@batonfx/core/instructions") {
+class Instructions extends Context9.Service()("@batonfx/core/instructions") {
 }
 var staticSource = dual3(2, (id, text) => ({
   id,
   cache: "baseline",
-  render: () => Effect9.succeed(text.length === 0 ? Option6.none() : Option6.some(text))
+  render: () => Effect12.succeed(text.length === 0 ? Option7.none() : Option7.some(text))
 }));
-var openEpoch = dual3(2, (instructions, context) => Effect9.gen(function* () {
+var openEpoch = dual3(2, (instructions, context) => Effect12.gen(function* () {
   const baseline = [];
   const dynamic = [];
   for (const source of instructions.sources) {
@@ -1170,7 +1321,7 @@ var openEpoch = dual3(2, (instructions, context) => Effect9.gen(function* () {
       dynamic.push(source);
     } else {
       const rendered = yield* source.render(context);
-      if (Option6.isSome(rendered))
+      if (Option7.isSome(rendered))
         baseline.push(rendered.value);
     }
   }
@@ -1178,164 +1329,37 @@ var openEpoch = dual3(2, (instructions, context) => Effect9.gen(function* () {
 
 `), dynamic };
 }));
-var renderUpdate = dual3(2, (epoch, context) => Effect9.gen(function* () {
+var renderUpdate = dual3(2, (epoch, context) => Effect12.gen(function* () {
   const fragments = [];
   for (const source of epoch.dynamic) {
     const rendered = yield* source.render(context);
-    if (Option6.isSome(rendered))
+    if (Option7.isSome(rendered))
       fragments.push(rendered.value);
   }
-  return fragments.length === 0 ? Option6.none() : Option6.some(fragments.join(`
+  return fragments.length === 0 ? Option7.none() : Option7.some(fragments.join(`
 
 `));
 }));
-var layer2 = (sources) => Layer9.succeed(Instructions, Instructions.of({ sources: [...sources] }));
-var testLayer8 = (implementation) => Layer9.succeed(Instructions, Instructions.of(implementation));
+var layer3 = (sources) => Layer10.succeed(Instructions, Instructions.of({ sources: [...sources] }));
+var testLayer9 = (implementation) => Layer10.succeed(Instructions, Instructions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/model-middleware.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/model-middleware.js
 var exports_model_middleware = {};
 __export(exports_model_middleware, {
-  layerIdentity: () => layerIdentity,
-  layer: () => layer3,
-  identityLayer: () => identityLayer,
-  ModelMiddleware: () => ModelMiddleware
-});
-import { Context as Context9, Effect as Effect10, Layer as Layer10, Option as Option7 } from "effect";
-import { Prompt as Prompt6, Response as Response4 } from "effect/unstable/ai";
-class ModelMiddleware extends Context9.Service()("@batonfx/core/model-middleware/ModelMiddleware") {
-}
-var layerIdentity = Layer10.succeed(ModelMiddleware, []);
-var identityLayer = layerIdentity;
-var layer3 = (middleware) => Layer10.succeed(ModelMiddleware, middleware);
-
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/model-registry.js
-var exports_model_registry = {};
-__export(exports_model_registry, {
-  testLayer: () => testLayer9,
-  stream: () => stream,
-  registrations: () => registrations,
-  registrationFromLayer: () => registrationFromLayer,
-  register: () => register,
-  provide: () => provide,
-  operate: () => operate,
-  memoryLayer: () => memoryLayer2,
-  layerMemory: () => layerMemory3,
-  layerFromRegistrationEffects: () => layerFromRegistrationEffects,
-  layer: () => layer4,
-  combine: () => combine,
-  classifyFailure: () => classifyFailure,
-  Service: () => Service,
-  LanguageModelNotRegistered: () => LanguageModelNotRegistered
-});
-import { Chunk, Context as Context10, Effect as Effect11, Function as Function4, Layer as Layer11, Option as Option8, Ref as Ref3, Schema as Schema8, Semaphore, Stream as Stream2 } from "effect";
-import { LanguageModel as LanguageModel3, Model } from "effect/unstable/ai";
-var FailureClassifierTypeId = Symbol.for("@batonfx/core/model-registry/FailureClassifier");
-var classifyFailure = Function4.dual(2, (model, error) => model[FailureClassifierTypeId]?.(error) ?? "other");
-var attachFailureClassifier = (registration, context) => {
-  if (registration.classifyFailure === undefined)
-    return context;
-  const model = Context10.get(context, LanguageModel3.LanguageModel);
-  const classified = {
-    ...model,
-    [FailureClassifierTypeId]: registration.classifyFailure
-  };
-  return Context10.add(context, LanguageModel3.LanguageModel, classified);
-};
-
-class LanguageModelNotRegistered extends Schema8.TaggedErrorClass()("LanguageModelNotRegistered", {
-  provider: Schema8.String,
-  model: Schema8.String,
-  registration_key: Schema8.optionalKey(Schema8.String)
-}) {
-}
-
-class Service extends Context10.Service()("@batonfx/core/model-registry/Service") {
-}
-var registrationVariantKey = (value) => value.registrationKey ?? null;
-var selectionVariantKey = (selection) => selection.registrationKey ?? null;
-var registryIdentity = (registration) => JSON.stringify([registration.provider, registration.model, registrationVariantKey(registration)]);
-var matchesSelection = (selection) => (registration) => registration.provider === selection.provider && registration.model === selection.model && registrationVariantKey(registration) === selectionVariantKey(selection);
-var upsertRegistration = (registry, registration) => {
-  const key = registryIdentity(registration);
-  const exists = Option8.isSome(Chunk.findFirst(registry, (item) => registryIdentity(item) === key));
-  if (!exists)
-    return Chunk.append(registry, registration);
-  return Chunk.map(registry, (item) => registryIdentity(item) === key ? registration : item);
-};
-var findRegistration = (registry, selection) => Chunk.findFirst(registry, matchesSelection(selection)).pipe(Option8.getOrUndefined);
-var registrationFromLayer = (input) => Model.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect11.map((layer4) => ({
-  provider: input.provider,
-  model: input.model,
-  layer: layer4,
-  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
-  ...input.metadata === undefined ? {} : { metadata: input.metadata },
-  ...input.classifyFailure === undefined ? {} : { classifyFailure: input.classifyFailure }
-})));
-var layer4 = Function4.dual((args) => args.length === 0 || args.length > 1 || Array.isArray(args[0]), (initialRegistrations = [], options) => Layer11.effect(Service, Effect11.gen(function* () {
-  const registry = yield* Ref3.make(initialRegistrations.reduce(upsertRegistration, Chunk.empty()));
-  const semaphore = options?.maxConcurrentModelCalls === undefined ? undefined : yield* Semaphore.make(options.maxConcurrentModelCalls);
-  const register = Effect11.fn("ModelRegistry.register")(function* (input) {
-    yield* Ref3.update(registry, (items) => upsertRegistration(items, input.registration));
-  });
-  const registrations = Ref3.get(registry).pipe(Effect11.map(Chunk.toReadonlyArray));
-  const operate = Effect11.fn("ModelRegistry.operate")(function* (selection, effect) {
-    const items = yield* Ref3.get(registry);
-    const registration = findRegistration(items, selection);
-    if (registration === undefined) {
-      return yield* LanguageModelNotRegistered.make({
-        provider: selection.provider,
-        model: selection.model,
-        ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
-      });
-    }
-    const provided = Effect11.scoped(Layer11.build(registration.layer).pipe(Effect11.flatMap((context) => effect.pipe(Effect11.provide(attachFailureClassifier(registration, context))))));
-    return yield* semaphore === undefined ? provided : semaphore.withPermits(1)(provided);
-  });
-  const stream = (selection, operation) => Stream2.unwrap(Effect11.gen(function* () {
-    const items = yield* Ref3.get(registry);
-    const registration = findRegistration(items, selection);
-    if (registration === undefined) {
-      return yield* LanguageModelNotRegistered.make({
-        provider: selection.provider,
-        model: selection.model,
-        ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
-      });
-    }
-    if (semaphore !== undefined) {
-      yield* Effect11.acquireRelease(semaphore.take(1), () => semaphore.release(1), { interruptible: true });
-    }
-    const context = attachFailureClassifier(registration, yield* Layer11.build(registration.layer));
-    return operation.pipe(Stream2.provideContext(context));
-  }));
-  return Service.of({
-    register,
-    registrations,
-    operate,
-    stream,
-    provide: operate
-  });
-})));
-var layerFromRegistrationEffects = Function4.dual((args) => args.length !== 1 || Array.isArray(args[0]), (registrations, options) => Layer11.unwrap(Effect11.all(registrations).pipe(Effect11.map((items) => layer4(items, options)))));
-var combine = Function4.dual((args) => args.length !== 1 || Array.isArray(args[0]), (registries, options) => Layer11.unwrap(Effect11.forEach(registries, (registry) => Layer11.build(registry).pipe(Effect11.flatMap((context) => Context10.get(context, Service).registrations))).pipe(Effect11.map((groups) => layer4(groups.flat(), options)))));
-var layerMemory3 = layer4;
-var memoryLayer2 = layerMemory3;
-var testLayer9 = (implementation) => Layer11.succeed(Service, Service.of(implementation));
-var register = Effect11.fn("ModelRegistry.register.call")(function* (input) {
-  const service = yield* Service;
-  return yield* service.register(input);
-});
-var registrations = Effect11.fn("ModelRegistry.registrations.call")(function* () {
-  const service = yield* Service;
-  return yield* service.registrations;
+  layerIdentity: () => layerIdentity,
+  layer: () => layer4,
+  identityLayer: () => identityLayer,
+  ModelMiddleware: () => ModelMiddleware
 });
-var operate = Function4.dual(2, (selection, effect) => Effect11.gen(function* () {
-  const service = yield* Service;
-  return yield* service.operate(selection, effect);
-}));
-var stream = Function4.dual(2, (selection, operation) => Stream2.unwrap(Service.pipe(Effect11.map((service) => service.stream(selection, operation)))));
-var provide = operate;
+import { Context as Context10, Effect as Effect13, Layer as Layer11, Option as Option8 } from "effect";
+import { Prompt as Prompt6, Response as Response4 } from "effect/unstable/ai";
+class ModelMiddleware extends Context10.Service()("@batonfx/core/model-middleware/ModelMiddleware") {
+}
+var layerIdentity = Layer11.succeed(ModelMiddleware, []);
+var identityLayer = layerIdentity;
+var layer4 = (middleware) => Layer11.succeed(ModelMiddleware, middleware);
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/model-resilience.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/model-resilience.js
 var exports_model_resilience = {};
 __export(exports_model_resilience, {
   testLayer: () => testLayer10,
@@ -1346,12 +1370,12 @@ __export(exports_model_resilience, {
   apply: () => apply,
   ModelResilience: () => ModelResilience
 });
-import { Cause as Cause2, Context as Context11, Effect as Effect12, Function as Function5, Layer as Layer12, Result, Schedule as Schedule2, Schema as Schema9, Stream as Stream3 } from "effect";
-import { AiError as AiError2, LanguageModel as LanguageModel4, Response as Response5, Tool as Tool3 } from "effect/unstable/ai";
+import { Cause as Cause2, Context as Context11, Effect as Effect14, Function as Function5, Layer as Layer12, Result, Schedule as Schedule2, Schema as Schema10, Stream as Stream3 } from "effect";
+import { AiError as AiError3, LanguageModel as LanguageModel4, Response as Response5, Tool as Tool5 } from "effect/unstable/ai";
 
 class ModelResilience extends Context11.Service()("@batonfx/core/model-resilience/ModelResilience") {
 }
-var defaultClassify = (error) => AiError2.isAiError(error) && error.isRetryable ? "transient" : "terminal";
+var defaultClassify = (error) => AiError3.isAiError(error) && error.isRetryable ? "transient" : "terminal";
 var none = { classify: () => "terminal", retrySchedule: Schedule2.recurs(0) };
 var make3 = (input) => ({
   classify: input?.classify ?? defaultClassify,
@@ -1359,17 +1383,17 @@ var make3 = (input) => ({
 });
 var layer5 = (input) => Layer12.succeed(ModelResilience, ModelResilience.of(make3(input)));
 var testLayer10 = (implementation) => Layer12.succeed(ModelResilience, ModelResilience.of(implementation));
-var retryEffect = (effect, resilience) => Effect12.suspend(effect).pipe(Effect12.map((value) => Result.succeed(value)), Effect12.catchCause((cause) => {
+var retryEffect = (effect, resilience) => Effect14.suspend(effect).pipe(Effect14.map((value) => Result.succeed(value)), Effect14.catchCause((cause) => {
   const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-  return reason === undefined || !Cause2.isFailReason(reason) ? Effect12.succeed(Result.fail(cause)) : Effect12.fail(reason.error);
-}), Effect12.retry({
+  return reason === undefined || !Cause2.isFailReason(reason) ? Effect14.succeed(Result.fail(cause)) : Effect14.fail(reason.error);
+}), Effect14.retry({
   schedule: resilience.retrySchedule,
   while: (error) => resilience.classify(error) === "transient"
-}), Effect12.flatMap((result) => Result.isFailure(result) ? Effect12.failCause(result.failure) : Effect12.succeed(result.success)));
+}), Effect14.flatMap((result) => Result.isFailure(result) ? Effect14.failCause(result.failure) : Effect14.succeed(result.success)));
 var retryStreamSchedule = (resilience) => resilience.retrySchedule.pipe(Schedule2.while(({ input }) => resilience.classify(input) === "transient"));
 var retryStream = (stream2, onEmittedFailure, resilience) => Stream3.suspend(() => {
   let emitted = false;
-  return stream2().pipe(Stream3.map((value) => Result.succeed(value)), Stream3.tap(() => Effect12.sync(() => {
+  return stream2().pipe(Stream3.map((value) => Result.succeed(value)), Stream3.tap(() => Effect14.sync(() => {
     emitted = true;
   })), Stream3.catchCause((cause) => {
     const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
@@ -1388,7 +1412,7 @@ var apply = Function5.dual(2, (model, resilience) => ({
   streamText: (options) => retryStream(() => model.streamText(options), (error) => Response5.makePart("error", { error }), resilience)
 }));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/permissions.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/permissions.js
 var exports_permissions = {};
 __export(exports_permissions, {
   testLayer: () => testLayer11,
@@ -1404,11 +1428,11 @@ __export(exports_permissions, {
   Permissions: () => Permissions,
   PermissionError: () => PermissionError
 });
-import { Context as Context12, Effect as Effect13, Layer as Layer13, Option as Option9, Ref as Ref4, Schema as Schema10 } from "effect";
+import { Context as Context12, Effect as Effect15, Layer as Layer13, Option as Option9, Ref as Ref4, Schema as Schema11 } from "effect";
 import { dual as dual4 } from "effect/Function";
 
-class PermissionError extends Schema10.TaggedErrorClass()("@batonfx/core/PermissionError", {
-  message: Schema10.String
+class PermissionError extends Schema11.TaggedErrorClass()("@batonfx/core/PermissionError", {
+  message: Schema11.String
 }) {
 }
 
@@ -1504,25 +1528,25 @@ var decisionFor = (ruleset, request) => {
   }
 };
 var fromRuleset = (ruleset) => Layer13.succeed(Permissions, Permissions.of({
-  evaluate: (request) => Effect13.succeed(decisionFor(ruleset, request)),
-  await: () => Effect13.succeed(Option9.none())
+  evaluate: (request) => Effect15.succeed(decisionFor(ruleset, request)),
+  await: () => Effect15.succeed(Option9.none())
 }));
 var allowAll = Layer13.succeed(Permissions, Permissions.of({
-  evaluate: () => Effect13.succeed({ _tag: "Allow" }),
-  await: () => Effect13.succeed(Option9.none())
+  evaluate: () => Effect15.succeed({ _tag: "Allow" }),
+  await: () => Effect15.succeed(Option9.none())
 }));
 var interactive = (options) => Layer13.succeed(Permissions, Permissions.of({
-  evaluate: (request) => Effect13.succeed(decisionFor(options.ruleset, request)),
-  await: (pending) => options.onAsk(pending).pipe(Effect13.map(Option9.some))
+  evaluate: (request) => Effect15.succeed(decisionFor(options.ruleset, request)),
+  await: (pending) => options.onAsk(pending).pipe(Effect15.map(Option9.some))
 }));
-var ruleStoreMemory = (initialRules = []) => Layer13.effect(RuleStore, Ref4.make(initialRules).pipe(Effect13.map((rules) => RuleStore.of({
+var ruleStoreMemory = (initialRules = []) => Layer13.effect(RuleStore, Ref4.make(initialRules).pipe(Effect15.map((rules) => RuleStore.of({
   remember: (rule) => Ref4.update(rules, (current) => [...current.filter((existing) => existing.pattern !== rule.pattern), rule]),
   rules: Ref4.get(rules)
 }))));
 var ruleStoreTestLayer = (implementation) => Layer13.succeed(RuleStore, RuleStore.of(implementation));
 var testLayer11 = (implementation) => Layer13.succeed(Permissions, Permissions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/skill-source.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/skill-source.js
 var exports_skill_source = {};
 __export(exports_skill_source, {
   testLayer: () => testLayer12,
@@ -1536,13 +1560,13 @@ __export(exports_skill_source, {
   SkillSource: () => SkillSource,
   DESCRIPTION_CAP: () => DESCRIPTION_CAP
 });
-import { Context as Context13, Effect as Effect14, Function as Function6, Layer as Layer14, Schema as Schema11 } from "effect";
-import { Tool as Tool4 } from "effect/unstable/ai";
+import { Context as Context13, Effect as Effect16, Function as Function6, Layer as Layer14, Schema as Schema12 } from "effect";
+import { Tool as Tool6 } from "effect/unstable/ai";
 
-class SkillSourceError extends Schema11.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
-  source: Schema11.String,
-  message: Schema11.String,
-  cause: Schema11.optionalKey(Schema11.Defect())
+class SkillSourceError extends Schema12.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
+  source: Schema12.String,
+  message: Schema12.String,
+  cause: Schema12.optionalKey(Schema12.Defect())
 }) {
 }
 var DESCRIPTION_CAP = 1024;
@@ -1554,14 +1578,14 @@ var fromSkills = (skills) => {
   const all = [...skills];
   const byName = new Map(all.map((skill) => [skill.frontmatter.name, skill]));
   return Layer14.succeed(SkillSource, SkillSource.of({
-    all: Effect14.succeed(all),
-    get: (name) => Effect14.succeed(byName.get(name))
+    all: Effect16.succeed(all),
+    get: (name) => Effect16.succeed(byName.get(name))
   }));
 };
 var empty = fromSkills([]);
 var testLayer12 = (implementation) => Layer14.succeed(SkillSource, SkillSource.of(implementation));
 var merge2 = (sources) => ({
-  all: Effect14.forEach(sources, (source) => source.all).pipe(Effect14.map((groups) => {
+  all: Effect16.forEach(sources, (source) => source.all).pipe(Effect16.map((groups) => {
     const byName = new Map;
     for (const skills of groups) {
       for (const skill of skills)
@@ -1569,7 +1593,7 @@ var merge2 = (sources) => ({
     }
     return [...byName.values()];
   })),
-  get: (name) => Effect14.gen(function* () {
+  get: (name) => Effect16.gen(function* () {
     for (const source of sources.toReversed()) {
       const found = yield* source.get(name);
       if (found !== undefined)
@@ -1578,7 +1602,7 @@ var merge2 = (sources) => ({
     return;
   })
 });
-var layer6 = (sources) => Layer14.effect(SkillSource, Effect14.forEach(sources, (source) => source).pipe(Effect14.map((built) => SkillSource.of(merge2(built)))));
+var layer6 = (sources) => Layer14.effect(SkillSource, Effect16.forEach(sources, (source) => source).pipe(Effect16.map((built) => SkillSource.of(merge2(built)))));
 var estimatedTokens = (listing) => Math.ceil(listing.length / 4);
 var usageRank = (skill, recentlyUsed) => {
   const index = recentlyUsed.indexOf(skill.frontmatter.name);
@@ -1602,7 +1626,7 @@ var selectListings = Function6.dual(3, (skills, budgetTokens, recentlyUsed) => {
   return selected;
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/steering.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/steering.js
 var exports_steering = {};
 __export(exports_steering, {
   testLayer: () => testLayer13,
@@ -1610,15 +1634,15 @@ __export(exports_steering, {
   SteeringQueueFull: () => SteeringQueueFull,
   Steering: () => Steering
 });
-import { Context as Context14, Effect as Effect15, Exit, Layer as Layer15, Queue, Schema as Schema12 } from "effect";
+import { Context as Context14, Effect as Effect17, Exit, Layer as Layer15, Queue, Schema as Schema13 } from "effect";
 import { Prompt as Prompt7 } from "effect/unstable/ai";
 
 class Steering extends Context14.Service()("@batonfx/core/steering") {
 }
 
-class SteeringQueueFull extends Schema12.TaggedErrorClass()("@batonfx/core/SteeringQueueFull", {
-  queue: Schema12.Literals(["steering", "followUp"]),
-  capacity: Schema12.Finite
+class SteeringQueueFull extends Schema13.TaggedErrorClass()("@batonfx/core/SteeringQueueFull", {
+  queue: Schema13.Literals(["steering", "followUp"]),
+  capacity: Schema13.Finite
 }) {
 }
 var resolvePolicy = (policy, mode) => ({
@@ -1637,18 +1661,18 @@ var queueStrategy = (strategy2) => {
       return "suspend";
   }
 };
-var makeQueue = (name, policy) => (policy.capacity === undefined ? Queue.unbounded() : Queue.make({ capacity: policy.capacity, strategy: queueStrategy(policy.onFull) })).pipe(Effect15.map((queue) => ({ name, queue, policy })));
-var offer = (runtime, message) => Queue.offer(runtime.queue, message).pipe(Effect15.flatMap((offered) => {
+var makeQueue = (name, policy) => (policy.capacity === undefined ? Queue.unbounded() : Queue.make({ capacity: policy.capacity, strategy: queueStrategy(policy.onFull) })).pipe(Effect17.map((queue) => ({ name, queue, policy })));
+var offer = (runtime, message) => Queue.offer(runtime.queue, message).pipe(Effect17.flatMap((offered) => {
   if (offered || runtime.policy.capacity === undefined || runtime.policy.onFull !== "fail")
-    return Effect15.void;
+    return Effect17.void;
   return SteeringQueueFull.make({ queue: runtime.name, capacity: runtime.policy.capacity });
 }));
-var drainOne = (queue) => Effect15.sync(() => {
+var drainOne = (queue) => Effect17.sync(() => {
   const taken = Queue.takeUnsafe(queue);
   return taken === undefined || !Exit.isSuccess(taken) ? [] : [taken.value];
 });
 var drain = (queue, mode) => mode === "all" ? Queue.clear(queue) : drainOne(queue);
-var layer7 = (options = {}) => Layer15.effect(Steering, Effect15.gen(function* () {
+var layer7 = (options = {}) => Layer15.effect(Steering, Effect17.gen(function* () {
   const steeringQueue = yield* makeQueue("steering", resolvePolicy(options.steering, "all"));
   const followUpQueue = yield* makeQueue("followUp", resolvePolicy(options.followUp, "one-at-a-time"));
   return Steering.of({
@@ -1660,35 +1684,33 @@ var layer7 = (options = {}) => Layer15.effect(Steering, Effect15.gen(function* (
 }));
 var testLayer13 = (implementation) => Layer15.succeed(Steering, Steering.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/agent.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent.js
 var exports_agent = {};
 __export(exports_agent, {
-  streamObject: () => streamObject,
   stream: () => stream2,
   provideModel: () => provideModel,
-  persistedObject: () => persistedObject,
-  persisted: () => persisted,
   make: () => make5,
-  generatePersistedObject: () => generatePersistedObject,
-  generatePersisted: () => generatePersisted,
-  generateObject: () => generateObject,
   generate: () => generate,
   defaultObjectPrompt: () => defaultObjectPrompt
 });
-import { Cause as Cause4, Channel, Effect as Effect18, Equal, Exit as Exit2, Fiber, HashMap as HashMap4, Layer as Layer17, Option as Option12, Queue as Queue2, Ref as Ref5, Schema as Schema14, Semaphore as Semaphore2, Stream as Stream4, Types } from "effect";
+import { Effect as Effect22, Layer as Layer17, Option as Option15, Schema as Schema19, Stream as Stream5, Types } from "effect";
 import { dual as dual7 } from "effect/Function";
-import { AiError as AiError3, Chat, LanguageModel as LanguageModel5, Prompt as Prompt9, Response as Response7, Telemetry, Tokenizer as Tokenizer2, Tool as Tool7, Toolkit as Toolkit4 } from "effect/unstable/ai";
+import { AiError as AiError5, Chat as Chat3, LanguageModel as LanguageModel6, Prompt as Prompt12, Tool as Tool11, Toolkit as Toolkit5 } from "effect/unstable/ai";
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-run.js
+import { Cause as Cause4, Channel, Effect as Effect21, Equal as Equal2, Exit as Exit2, Fiber, HashMap as HashMap5, Option as Option14, Queue as Queue2, Ref as Ref5, Schema as Schema18, Semaphore as Semaphore3, Stream as Stream4 } from "effect";
+import { AiError as AiError4, Chat as Chat2, LanguageModel as LanguageModel5, Prompt as Prompt11, Response as Response10, Telemetry, Tokenizer as Tokenizer2, Tool as Tool10, Toolkit as Toolkit4 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/tool-authorization.js
-import { Cause as Cause3, Context as Context15, Effect as Effect16, Layer as Layer16, Option as Option10, Schema as Schema13 } from "effect";
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-authorization.js
+import { Cause as Cause3, Context as Context15, Effect as Effect18, Layer as Layer16, Option as Option10, Schema as Schema14 } from "effect";
 import { dual as dual5 } from "effect/Function";
-import { Prompt as Prompt8, Response as Response6, Tool as Tool5 } from "effect/unstable/ai";
-class PermissionDenied extends Schema13.TaggedErrorClass()("@batonfx/core/PermissionDenied", {
-  message: Schema13.String
+import { Prompt as Prompt8, Response as Response6, Tool as Tool7 } from "effect/unstable/ai";
+class PermissionDenied extends Schema14.TaggedErrorClass()("@batonfx/core/PermissionDenied", {
+  message: Schema14.String
 }) {
 }
 
-class AuthorizationError extends Schema13.TaggedErrorClass()("@batonfx/core/AuthorizationError", { message: Schema13.String, cause: Schema13.optional(Schema13.Defect()) }) {
+class AuthorizationError extends Schema14.TaggedErrorClass()("@batonfx/core/AuthorizationError", { message: Schema14.String, cause: Schema14.optional(Schema14.Defect()) }) {
 }
 
 class ToolAuthorizerService extends Context15.Service()("@batonfx/core/tool-authorization/ToolAuthorizerService") {
@@ -1715,16 +1737,16 @@ var authorizationError = (error) => AuthorizationError.make({ message: error.mes
 var approvalRequired = (request) => {
   const needsApproval = request.tool?.needsApproval;
   if (needsApproval === undefined)
-    return Effect16.succeed(false);
+    return Effect18.succeed(false);
   if (typeof needsApproval === "boolean")
-    return Effect16.succeed(needsApproval);
-  return Effect16.suspend(() => {
+    return Effect18.succeed(needsApproval);
+  return Effect18.suspend(() => {
     const result = needsApproval(request.call.params, {
       toolCallId: request.call.id,
       messages: request.messages
     });
-    return Effect16.isEffect(result) ? result : Effect16.succeed(result);
-  }).pipe(Effect16.catchCause((cause) => Cause3.hasInterrupts(cause) ? Effect16.interrupt : Effect16.succeed(true)));
+    return Effect18.isEffect(result) ? result : Effect18.succeed(result);
+  }).pipe(Effect18.catchCause((cause) => Cause3.hasInterrupts(cause) ? Effect18.interrupt : Effect18.succeed(true)));
 };
 var evaluationRequest = (request) => ({
   tool: request.call.name,
@@ -1734,7 +1756,7 @@ var evaluationRequest = (request) => ({
   toolCallId: request.call.id,
   sessionId: request.execution.sessionId
 });
-var rememberedDecision = (request, ruleStore) => ruleStore?.rules === undefined ? Effect16.succeedNone : ruleStore.rules.pipe(Effect16.map((rules) => {
+var rememberedDecision = (request, ruleStore) => ruleStore?.rules === undefined ? Effect18.succeedNone : ruleStore.rules.pipe(Effect18.map((rules) => {
   if (rules.length === 0)
     return Option10.none();
   const matched = matchRule({ rules }, request.call.name, request.call.params);
@@ -1751,8 +1773,8 @@ var rememberedDecision = (request, ruleStore) => ruleStore?.rules === undefined
     case "ask":
       return Option10.some({ _tag: "Ask", token: `permission:${request.call.id}` });
   }
-}), Effect16.mapError(authorizationError));
-var resolveRequiredApproval = (request, approvals) => Effect16.gen(function* () {
+}), Effect18.mapError(authorizationError));
+var resolveRequiredApproval = (request, approvals) => Effect18.gen(function* () {
   yield* request.onApprovalRequired;
   if (approvals === undefined)
     return deny("Approvals service is required for approval-gated tools");
@@ -1766,13 +1788,13 @@ var resolveRequiredApproval = (request, approvals) => Effect16.gen(function* ()
       return suspension(request, decision2.token, "approval");
   }
 });
-var finalApproval = (request, approvals) => approvalRequired(request).pipe(Effect16.flatMap((required) => {
+var finalApproval = (request, approvals) => approvalRequired(request).pipe(Effect18.flatMap((required) => {
   if (!required)
-    return Effect16.succeed({ _tag: "Execute" });
+    return Effect18.succeed({ _tag: "Execute" });
   return resolveRequiredApproval(request, approvals);
 }));
 var make4 = (options = {}) => ({
-  authorize: (request) => Effect16.gen(function* () {
+  authorize: (request) => Effect18.gen(function* () {
     if (!request.active || request.tool === undefined) {
       return deny(`Tool ${request.call.name} is not active for turn ${request.execution.turn}`);
     }
@@ -1786,7 +1808,7 @@ var make4 = (options = {}) => ({
     if (request.authorizationStage === "permission") {
       const token = request.authorizationToken ?? `permission:${request.call.id}`;
       if (options.permissions !== undefined) {
-        const current2 = yield* options.permissions.evaluate(evaluationRequest(request)).pipe(Effect16.mapError(authorizationError));
+        const current2 = yield* options.permissions.evaluate(evaluationRequest(request)).pipe(Effect18.mapError(authorizationError));
         if (current2._tag === "Deny")
           return deny(current2.reason ?? "Permission denied");
       }
@@ -1800,13 +1822,13 @@ var make4 = (options = {}) => ({
         agentName: request.execution.agentName,
         turn: request.execution.turn,
         toolCallId: request.call.id
-      }).pipe(Effect16.mapError(authorizationError));
+      }).pipe(Effect18.mapError(authorizationError));
       if (Option10.isNone(answer2))
         return suspension(request, token, "permission");
       if (answer2.value._tag === "Denied")
         return deny(answer2.value.reason ?? "Permission denied");
       if (answer2.value._tag === "Always" && options.ruleStore !== undefined) {
-        yield* options.ruleStore.remember({ pattern: request.call.name, level: "allow" }).pipe(Effect16.mapError(authorizationError));
+        yield* options.ruleStore.remember({ pattern: request.call.name, level: "allow" }).pipe(Effect18.mapError(authorizationError));
       }
       return yield* finalApproval(request, options.approvals);
     }
@@ -1818,7 +1840,7 @@ var make4 = (options = {}) => ({
       return yield* finalApproval(request, options.approvals);
     }
     const permissions = options.permissions;
-    const current = yield* permissions.evaluate(evaluationRequest(request)).pipe(Effect16.mapError(authorizationError));
+    const current = yield* permissions.evaluate(evaluationRequest(request)).pipe(Effect18.mapError(authorizationError));
     if (current._tag === "Deny")
       return deny(current.reason ?? "Permission denied");
     if (current._tag !== "Ask" || Option10.isSome(remembered) && remembered.value._tag === "Allow") {
@@ -1833,7 +1855,7 @@ var make4 = (options = {}) => ({
       toolCallId: request.call.id
     };
     yield* request.onApprovalRequired;
-    const answer = yield* permissions.await(pending).pipe(Effect16.mapError(authorizationError));
+    const answer = yield* permissions.await(pending).pipe(Effect18.mapError(authorizationError));
     if (Option10.isNone(answer))
       return suspension(request, current.token, "permission");
     switch (answer.value._tag) {
@@ -1841,7 +1863,7 @@ var make4 = (options = {}) => ({
         return deny(answer.value.reason ?? "Permission denied");
       case "Always":
         if (options.ruleStore !== undefined) {
-          yield* options.ruleStore.remember({ pattern: request.call.name, level: "allow" }).pipe(Effect16.mapError(authorizationError));
+          yield* options.ruleStore.remember({ pattern: request.call.name, level: "allow" }).pipe(Effect18.mapError(authorizationError));
         }
         return yield* finalApproval(request, options.approvals);
       case "Approved":
@@ -1851,10 +1873,10 @@ var make4 = (options = {}) => ({
 });
 var fromPermissions = dual5((args) => args.length === 2 || args.length === 1 && ("evaluate" in args[0]), (permissions, options = {}) => make4({ ...options, permissions }));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/tool-registry.js
-import { Effect as Effect17, HashMap as HashMap3, Option as Option11 } from "effect";
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-registry.js
+import { Effect as Effect19, HashMap as HashMap3, Option as Option11 } from "effect";
 import { dual as dual6 } from "effect/Function";
-import { Tool as Tool6, Toolkit as Toolkit3 } from "effect/unstable/ai";
+import { Tool as Tool8, Toolkit as Toolkit3 } from "effect/unstable/ai";
 var makeToolkit = (entries) => {
   const toolkit = Toolkit3.make(...entries.map((candidate) => candidate.tool));
   for (const entry of entries) {
@@ -1881,14 +1903,14 @@ var assemble = (candidates) => {
   for (const candidate of candidates) {
     const conflicts = grouped.get(candidate.tool.name);
     if (conflicts !== undefined && conflicts.length > 1) {
-      return Effect17.fail(ToolNameCollision.make({
+      return Effect19.fail(ToolNameCollision.make({
         name: candidate.tool.name,
         origins: [conflicts[0].origin, ...conflicts.slice(1).map((conflict) => conflict.origin)]
       }));
     }
   }
   const entries = [...candidates];
-  return Effect17.succeed({
+  return Effect19.succeed({
     entries,
     byName: HashMap3.fromIterable(entries.map((candidate) => [candidate.tool.name, candidate])),
     toolkit: makeToolkit(entries)
@@ -1904,89 +1926,9 @@ var select = dual6(2, (registry, names) => {
   };
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/agent.js
-var AgentTypeId = Symbol.for("@batonfx/core/Agent");
-var ModelLayerTypeId = Symbol.for("@batonfx/core/Agent/ModelLayer");
-var classifyOtherFailure = () => "other";
-function make5(nameOrOptions, options = {}) {
-  if (nameOrOptions === undefined || typeof nameOrOptions !== "string" && !("name" in nameOrOptions)) {
-    const curriedOptions = nameOrOptions ?? {};
-    if ("tools" in curriedOptions && Array.isArray(curriedOptions.tools)) {
-      const tools = curriedOptions.tools;
-      return (name) => make5({
-        name,
-        tools,
-        ...curriedOptions.instructions === undefined ? {} : { instructions: curriedOptions.instructions },
-        ...curriedOptions.policy === undefined ? {} : { policy: curriedOptions.policy },
-        ...curriedOptions.model === undefined ? {} : { model: curriedOptions.model },
-        ...curriedOptions.memory === undefined ? {} : { memory: curriedOptions.memory },
-        ...curriedOptions.authorization === undefined ? {} : { authorization: curriedOptions.authorization },
-        ...curriedOptions.toolExecution === undefined ? {} : { toolExecution: curriedOptions.toolExecution },
-        ...curriedOptions.metadata === undefined ? {} : { metadata: curriedOptions.metadata }
-      });
-    }
-    return (name) => make5({
-      name,
-      ...curriedOptions.instructions === undefined ? {} : { instructions: curriedOptions.instructions },
-      ...curriedOptions.toolkit === undefined ? {} : { toolkit: curriedOptions.toolkit },
-      ...curriedOptions.policy === undefined ? {} : { policy: curriedOptions.policy },
-      ...curriedOptions.model === undefined ? {} : { model: curriedOptions.model },
-      ...curriedOptions.memory === undefined ? {} : { memory: curriedOptions.memory },
-      ...curriedOptions.authorization === undefined ? {} : { authorization: curriedOptions.authorization },
-      ...curriedOptions.toolExecution === undefined ? {} : { toolExecution: curriedOptions.toolExecution },
-      ...curriedOptions.metadata === undefined ? {} : { metadata: curriedOptions.metadata }
-    });
-  }
-  const resolved = typeof nameOrOptions === "string" ? { ...options, name: nameOrOptions } : nameOrOptions;
-  const declaredTools = "tools" in resolved && Array.isArray(resolved.tools) ? resolved.tools : undefined;
-  const toolkit = declaredTools === undefined ? resolved.toolkit ?? Toolkit4.empty : Toolkit4.make(...declaredTools);
-  if (declaredTools !== undefined) {
-    for (const tool of declaredTools) {
-      if (!Object.hasOwn(toolkit.tools, tool.name)) {
-        Object.defineProperty(toolkit.tools, tool.name, {
-          configurable: true,
-          enumerable: true,
-          value: tool,
-          writable: true
-        });
-      }
-    }
-  }
-  return {
-    [AgentTypeId]: {
-      tools: (value) => value,
-      requirements: (value) => value
-    },
-    name: resolved.name,
-    ...resolved.instructions === undefined ? {} : { instructions: resolved.instructions },
-    toolkit,
-    policy: resolved.policy ?? defaultPolicy,
-    ...resolved.model === undefined ? {} : { model: resolved.model },
-    ...resolved.memory === undefined ? {} : { memory: resolved.memory },
-    ...resolved.authorization === undefined ? {} : { authorization: resolved.authorization },
-    ...resolved.toolExecution === undefined ? {} : { toolExecution: resolved.toolExecution },
-    ...resolved.metadata === undefined ? {} : { metadata: resolved.metadata },
-    toolDeclarations: (declaredTools ?? Object.values(toolkit.tools)).map((tool) => ({
-      tool,
-      origin: { _tag: "Static", agent: resolved.name }
-    }))
-  };
-}
-var defaultProgressOverflowPolicy = { _tag: "Backpressure", capacity: 64 };
-var progressCapacitySchema = Schema14.Finite.pipe(Schema14.check(Schema14.isInt(), Schema14.isGreaterThan(0)));
-var progressOverflowPolicySchema = Schema14.Union([
-  Schema14.TaggedStruct("Backpressure", { capacity: progressCapacitySchema }),
-  Schema14.TaggedStruct("Dropping", { capacity: progressCapacitySchema }),
-  Schema14.TaggedStruct("Sliding", { capacity: progressCapacitySchema }),
-  Schema14.TaggedStruct("Fail", { capacity: progressCapacitySchema })
-]);
-var defaultObjectPrompt = "Return the final structured output for the task above.";
-var steeringDrainedEvent = (turn, queue, messages) => ({
-  _tag: "SteeringDrained",
-  turn,
-  queue,
-  count: messages.length
-});
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-persistence-lock.js
+import { Semaphore as Semaphore2 } from "effect";
+import { Chat } from "effect/unstable/ai";
 var persistenceLocks = new WeakMap;
 var reservePersistedChatLock = (persistence, chatId) => {
   const locks = persistenceLocks.get(persistence) ?? new Map;
@@ -2001,16 +1943,6 @@ var reservePersistedChatLock = (persistence, chatId) => {
   locks.set(chatId, created);
   return created;
 };
-var suspensionCheckpointOption = "@batonfx/core/suspension";
-var suspensionMetadata = Schema14.Struct({
-  token: Schema14.String,
-  reason: Schema14.Literals(["tool-wait", "approval"]),
-  authorization_stage: Schema14.optional(Schema14.Literals(["permission", "approval"])),
-  tool_call_index: Schema14.optional(Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(0))),
-  tool_call_batch_ids: Schema14.Array(Schema14.String),
-  active_tools: Schema14.optional(Schema14.Array(Schema14.String)),
-  activated_skills: Schema14.optional(Schema14.Array(Schema14.String))
-});
 var releasePersistedChatLock = (persistence, chatId, lock) => {
   lock.users -= 1;
   if (lock.users !== 0)
@@ -2022,6 +1954,95 @@ var releasePersistedChatLock = (persistence, chatId, lock) => {
   if (locks.size === 0)
     persistenceLocks.delete(persistence);
 };
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-message.js
+import { Effect as Effect20, Option as Option12, Schema as Schema16 } from "effect";
+import { Prompt as Prompt9, Response as Response7 } from "effect/unstable/ai";
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-skill-tool.js
+import { Schema as Schema15 } from "effect";
+import { Tool as Tool9 } from "effect/unstable/ai";
+var skillListingBudgetTokens = 2048;
+var activateSkillToolName = "activate_skill";
+var activateSkillParameters = Schema15.Struct({ name: Schema15.String });
+var activateSkillSuccess = Schema15.Struct({
+  name: Schema15.String,
+  body: Schema15.String,
+  allowedTools: Schema15.Array(Schema15.String)
+});
+var activateSkillFailure = Schema15.Struct({
+  reason: Schema15.Literals(["not-found", "not-model-invocable"]),
+  message: Schema15.String
+});
+var activateSkillTool = Tool9.make(activateSkillToolName, {
+  description: "Load the full body for one listed Baton skill by name before applying that skill.",
+  parameters: activateSkillParameters,
+  success: activateSkillSuccess,
+  failure: activateSkillFailure,
+  failureMode: "return"
+});
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-message.js
+var withSystem = (instructions, prompt) => Prompt9.fromMessages([Prompt9.makeMessage("system", { content: instructions }), ...prompt.content]);
+var skillListingsInstructions = (listings) => `Available skills:
+${listings}
+
+Call ${activateSkillToolName} with a listed skill name to load its full body before using it.`;
+var recalledMessages = (prompt) => prompt.content.filter(isMessageFromRecall).map(recalledMessageIdentity);
+var messageJsonStringCodec = Schema16.fromJsonString(Schema16.toCodecJson(Prompt9.Message));
+var encodeMessage = Schema16.encodeEffect(messageJsonStringCodec);
+var decodeMessage = Schema16.decodeEffect(messageJsonStringCodec);
+var detachMessage = (message) => encodeMessage(message).pipe(Effect20.flatMap(decodeMessage), Effect20.map((detached) => isMessageFromRecall(message) && message.role === "user" && detached.role === "user" ? replaceRecalledMessage(message, detached.content) : detached));
+var detachPrompt = (prompt) => Effect20.forEach(prompt.content, detachMessage).pipe(Effect20.map(Prompt9.fromMessages));
+var detachEntry = (entry) => entry._tag === "Message" || entry._tag === "Steering" ? detachMessage(entry.message).pipe(Effect20.map((message) => ({ ...entry, message }))) : Effect20.succeed(entry);
+var preservesRecalledMessages = (allowed, required, transformed) => {
+  const allowedSet = new Set(allowed);
+  const transformedMessages = recalledMessages(transformed);
+  const transformedSet = new Set(transformedMessages);
+  return transformedSet.size === transformedMessages.length && transformedMessages.every((message) => allowedSet.has(message)) && required.every((message) => transformedSet.has(message));
+};
+var applyPromptChain = (chain, prompt, context) => Effect20.gen(function* () {
+  let current = prompt;
+  for (const middleware of chain) {
+    if (middleware.transformPrompt !== undefined) {
+      const recalled = recalledMessages(current);
+      const transformed = yield* middleware.transformPrompt(current, context);
+      if (!preservesRecalledMessages(recalled, recalled, transformed)) {
+        return yield* MiddlewareViolation.make({
+          turn: context.turn,
+          detail: "Prompt middleware must preserve recalled-memory message lineage"
+        });
+      }
+      current = transformed;
+    }
+  }
+  return current;
+});
+var applyPartChain = (chain, part, context) => Effect20.gen(function* () {
+  let current = Option12.some(part);
+  for (const middleware of chain) {
+    if (Option12.isNone(current))
+      break;
+    if (middleware.transformPart !== undefined) {
+      current = yield* middleware.transformPart(current.value, context);
+    }
+  }
+  return current;
+});
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-suspension.js
+import { Equal, Option as Option13, Schema as Schema17 } from "effect";
+import { Prompt as Prompt10, Response as Response8 } from "effect/unstable/ai";
+var suspensionCheckpointOption = "@batonfx/core/suspension";
+var suspensionMetadata = Schema17.Struct({
+  token: Schema17.String,
+  reason: Schema17.Literals(["tool-wait", "approval"]),
+  authorization_stage: Schema17.optional(Schema17.Literals(["permission", "approval"])),
+  tool_call_index: Schema17.optional(Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(0))),
+  tool_call_batch_ids: Schema17.Array(Schema17.String),
+  active_tools: Schema17.optional(Schema17.Array(Schema17.String)),
+  activated_skills: Schema17.optional(Schema17.Array(Schema17.String))
+});
 var unresolvedToolCall = (messages, toolCallId) => {
   const unpaired = new Map;
   const ambiguous = new Set;
@@ -2051,10 +2072,10 @@ var unresolvedToolCall = (messages, toolCallId) => {
     }
   }
   const unresolved = [...unpaired.entries()].flatMap(([id, occurrences]) => ambiguous.has(id) ? [] : occurrences.filter(({ call }) => !call.providerExecuted));
-  const pending = toolCallId === undefined ? unresolved.find(({ call }) => Option12.isSome(Schema14.decodeUnknownOption(suspensionMetadata)(call.options[suspensionCheckpointOption]))) : unresolved.find(({ call }) => call.id === toolCallId);
+  const pending = toolCallId === undefined ? unresolved.find(({ call }) => Option13.isSome(Schema17.decodeUnknownOption(suspensionMetadata)(call.options[suspensionCheckpointOption]))) : unresolved.find(({ call }) => call.id === toolCallId);
   const pendingMessage = pending === undefined ? undefined : messages[pending.messageIndex];
   const toolCallBatch = pendingMessage?.role === "assistant" ? pendingMessage.content.flatMap((part) => part.type === "tool-call" && !part.providerExecuted ? [
-    Response7.makePart("tool-call", {
+    Response8.makePart("tool-call", {
       id: part.id,
       name: part.name,
       params: part.params,
@@ -2073,8 +2094,8 @@ var suspensionCheckpoint = (messages) => {
   const unresolved = unresolvedToolCall(messages);
   if (unresolved === undefined)
     return;
-  const metadata = Schema14.decodeUnknownOption(suspensionMetadata)(unresolved.call.options[suspensionCheckpointOption]);
-  if (Option12.isNone(metadata))
+  const metadata = Schema17.decodeUnknownOption(suspensionMetadata)(unresolved.call.options[suspensionCheckpointOption]);
+  if (Option13.isNone(metadata))
     return;
   if (!Equal.equals(metadata.value.tool_call_batch_ids, unresolved.toolCallBatch.map((call) => call.id)))
     return;
@@ -2091,44 +2112,20 @@ var suspensionCheckpoint = (messages) => {
   };
 };
 var sameSuspension = (left, right) => left.token === right.token && left.reason === right.reason && left.authorization_stage === right.authorization_stage && left.tool_call_index === right.tool_call_index && Equal.equals(left.tool_call_batch, right.tool_call_batch) && left.tool_call_id === right.tool_call_id && left.tool_name === right.tool_name && Equal.equals(left.tool_params, right.tool_params) && Equal.equals(left.active_tools, right.active_tools) && Equal.equals(left.activated_skills, right.activated_skills);
-var skillListingBudgetTokens = 2048;
-var activateSkillToolName = "activate_skill";
-var activateSkillParameters = Schema14.Struct({ name: Schema14.String });
-var activateSkillSuccess = Schema14.Struct({
-  name: Schema14.String,
-  body: Schema14.String,
-  allowedTools: Schema14.Array(Schema14.String)
-});
-var activateSkillFailure = Schema14.Struct({
-  reason: Schema14.Literals(["not-found", "not-model-invocable"]),
-  message: Schema14.String
-});
-var activateSkillTool = Tool7.make(activateSkillToolName, {
-  description: "Load the full body for one listed Baton skill by name before applying that skill.",
-  parameters: activateSkillParameters,
-  success: activateSkillSuccess,
-  failure: activateSkillFailure,
-  failureMode: "return"
+var suspended = (call, toolCallBatch, toolCallIndex, token, reason) => AgentSuspended.make({
+  token,
+  reason,
+  tool_call_index: toolCallIndex,
+  tool_call_id: call.id,
+  tool_name: call.name,
+  tool_params: call.params,
+  tool_call_batch: toolCallBatch.calls
 });
-var errorMessage = (error) => error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-var isToolNameCollision = Schema14.is(ToolNameCollision);
-var appendInstructionFragment = (base, fragment) => {
-  if (fragment === undefined || fragment.length === 0)
-    return base;
-  if (base === undefined || base.length === 0)
-    return fragment;
-  return `${base}
 
-${fragment}`;
-};
-var isTurnPolicyDecision = (input) => {
-  if (typeof input !== "object" || input === null || !("_tag" in input))
-    return false;
-  if (input._tag === "Continue")
-    return true;
-  return input._tag === "Stop" && "reason" in input && Schema14.is(StopReason)(input.reason);
-};
-var successResult = (call, outcome) => Response7.toolResultPart({
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-tool-result.js
+import { HashMap as HashMap4 } from "effect";
+import { Response as Response9 } from "effect/unstable/ai";
+var successResult = (call, outcome) => Response9.toolResultPart({
   id: call.id,
   name: call.name,
   isFailure: false,
@@ -2137,7 +2134,7 @@ var successResult = (call, outcome) => Response7.toolResultPart({
   providerExecuted: false,
   preliminary: false
 });
-var domainFailureResult = (call, outcome) => Response7.toolResultPart({
+var domainFailureResult = (call, outcome) => Response9.toolResultPart({
   id: call.id,
   name: call.name,
   isFailure: true,
@@ -2146,62 +2143,43 @@ var domainFailureResult = (call, outcome) => Response7.toolResultPart({
   providerExecuted: false,
   preliminary: false
 });
-var suspended = (call, toolCallBatch, toolCallIndex, token, reason) => AgentSuspended.make({
-  token,
-  reason,
-  tool_call_index: toolCallIndex,
-  tool_call_id: call.id,
-  tool_name: call.name,
-  tool_params: call.params,
-  tool_call_batch: toolCallBatch.calls
-});
-var withSystem = (instructions, prompt) => Prompt9.fromMessages([Prompt9.makeMessage("system", { content: instructions }), ...prompt.content]);
-var skillListingsInstructions = (listings) => `Available skills:
-${listings}
 
-Call ${activateSkillToolName} with a listed skill name to load its full body before using it.`;
-var recalledMessages = (prompt) => prompt.content.filter(isMessageFromRecall).map(recalledMessageIdentity);
-var messageJsonStringCodec = Schema14.fromJsonString(Schema14.toCodecJson(Prompt9.Message));
-var encodeMessage = Schema14.encodeEffect(messageJsonStringCodec);
-var decodeMessage = Schema14.decodeEffect(messageJsonStringCodec);
-var detachMessage = (message) => encodeMessage(message).pipe(Effect18.flatMap(decodeMessage), Effect18.map((detached) => isMessageFromRecall(message) && message.role === "user" && detached.role === "user" ? replaceRecalledMessage(message, detached.content) : detached));
-var detachPrompt = (prompt) => Effect18.forEach(prompt.content, detachMessage).pipe(Effect18.map(Prompt9.fromMessages));
-var detachEntry = (entry) => entry._tag === "Message" || entry._tag === "Steering" ? detachMessage(entry.message).pipe(Effect18.map((message) => ({ ...entry, message }))) : Effect18.succeed(entry);
-var preservesRecalledMessages = (allowed, required, transformed) => {
-  const allowedSet = new Set(allowed);
-  const transformedMessages = recalledMessages(transformed);
-  const transformedSet = new Set(transformedMessages);
-  return transformedSet.size === transformedMessages.length && transformedMessages.every((message) => allowedSet.has(message)) && required.every((message) => transformedSet.has(message));
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-run.js
+var ModelLayerTypeId = Symbol.for("@batonfx/core/Agent/ModelLayer");
+var classifyOtherFailure = () => "other";
+var defaultProgressOverflowPolicy = { _tag: "Backpressure", capacity: 64 };
+var progressCapacitySchema = Schema18.Finite.pipe(Schema18.check(Schema18.isInt(), Schema18.isGreaterThan(0)));
+var progressOverflowPolicySchema = Schema18.Union([
+  Schema18.TaggedStruct("Backpressure", { capacity: progressCapacitySchema }),
+  Schema18.TaggedStruct("Dropping", { capacity: progressCapacitySchema }),
+  Schema18.TaggedStruct("Sliding", { capacity: progressCapacitySchema }),
+  Schema18.TaggedStruct("Fail", { capacity: progressCapacitySchema })
+]);
+var errorMessage = (error) => error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+var isToolNameCollision = Schema18.is(ToolNameCollision);
+var appendInstructionFragment = (base, fragment) => {
+  if (fragment === undefined || fragment.length === 0)
+    return base;
+  if (base === undefined || base.length === 0)
+    return fragment;
+  return `${base}
+
+${fragment}`;
 };
-var applyPromptChain = (chain, prompt, context) => Effect18.gen(function* () {
-  let current = prompt;
-  for (const middleware of chain) {
-    if (middleware.transformPrompt !== undefined) {
-      const recalled = recalledMessages(current);
-      const transformed = yield* middleware.transformPrompt(current, context);
-      if (!preservesRecalledMessages(recalled, recalled, transformed)) {
-        return yield* MiddlewareViolation.make({
-          turn: context.turn,
-          detail: "Prompt middleware must preserve recalled-memory message lineage"
-        });
-      }
-      current = transformed;
-    }
-  }
-  return current;
-});
-var applyPartChain = (chain, part, context) => Effect18.gen(function* () {
-  let current = Option12.some(part);
-  for (const middleware of chain) {
-    if (Option12.isNone(current))
-      break;
-    if (middleware.transformPart !== undefined) {
-      current = yield* middleware.transformPart(current.value, context);
-    }
-  }
-  return current;
+var isTurnPolicyDecision = (input) => {
+  if (typeof input !== "object" || input === null || !("_tag" in input))
+    return false;
+  if (input._tag === "Continue")
+    return true;
+  return input._tag === "Stop" && "reason" in input && Schema18.is(StopReason)(input.reason);
+};
+var steeringDrainedEvent = (turn, queue, messages) => ({
+  _tag: "SteeringDrained",
+  turn,
+  queue,
+  count: messages.length
 });
-var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen(function* () {
+var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen(function* () {
   if (options.history !== undefined && options.persistence !== undefined) {
     return yield* AgentError.make({
       message: "RunOptions.history and RunOptions.persistence are mutually exclusive",
@@ -2210,52 +2188,52 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
   }
   const persistenceOptions = options.persistence;
   const resume = options.resume;
-  const persistenceService = yield* Effect18.serviceOption(Chat.Persistence);
-  const compactionService = yield* Effect18.serviceOption(Compaction);
-  const sessionService = yield* Effect18.serviceOption(SessionStore);
-  const persisted = persistenceOptions === undefined ? undefined : yield* Option12.match(persistenceService, {
-    onNone: () => Effect18.fail(AgentError.make({
+  const persistenceService = yield* Effect21.serviceOption(Chat2.Persistence);
+  const compactionService = yield* Effect21.serviceOption(Compaction);
+  const sessionService = yield* Effect21.serviceOption(SessionStore);
+  const persisted = persistenceOptions === undefined ? undefined : yield* Option14.match(persistenceService, {
+    onNone: () => Effect21.fail(AgentError.make({
       message: "RunOptions.persistence requires Chat.Persistence in context",
       turn: 0
     })),
-    onSome: (service) => Effect18.gen(function* () {
-      const lock = yield* Effect18.acquireRelease(Effect18.sync(() => reservePersistedChatLock(service, persistenceOptions.chatId)), (reserved) => Effect18.sync(() => releasePersistedChatLock(service, persistenceOptions.chatId, reserved)));
-      yield* Effect18.acquireRelease(lock.semaphore.take(1), () => lock.semaphore.release(1), {
+    onSome: (service) => Effect21.gen(function* () {
+      const lock = yield* Effect21.acquireRelease(Effect21.sync(() => reservePersistedChatLock(service, persistenceOptions.chatId)), (reserved) => Effect21.sync(() => releasePersistedChatLock(service, persistenceOptions.chatId, reserved)));
+      yield* Effect21.acquireRelease(lock.semaphore.take(1), () => lock.semaphore.release(1), {
         interruptible: true
       });
       const getOptions = persistenceOptions.timeToLive === undefined ? undefined : { timeToLive: persistenceOptions.timeToLive };
-      return yield* resume === undefined ? service.getOrCreate(persistenceOptions.chatId, getOptions).pipe(Effect18.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error }))) : service.get(persistenceOptions.chatId, getOptions).pipe(Effect18.mapError((error) => error._tag === "ChatNotFoundError" ? ResumeMismatch.make({
+      return yield* resume === undefined ? service.getOrCreate(persistenceOptions.chatId, getOptions).pipe(Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error }))) : service.get(persistenceOptions.chatId, getOptions).pipe(Effect21.mapError((error) => error._tag === "ChatNotFoundError" ? ResumeMismatch.make({
         reason: "checkpoint-not-found",
         received: resume.suspension
       }) : AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
     })
   });
   let recoveredHistory;
-  if (resume !== undefined && persisted !== undefined && Option12.isSome(compactionService) && Option12.isSome(sessionService)) {
-    yield* Effect18.gen(function* () {
+  if (resume !== undefined && persisted !== undefined && Option14.isSome(compactionService) && Option14.isSome(sessionService)) {
+    yield* Effect21.gen(function* () {
       const path = yield* sessionService.value.path();
       const checkpoint = path.at(-1);
       if (checkpoint?._tag !== "Compaction" || checkpoint.version !== 2)
         return;
       const history = yield* Ref5.get(persisted.history);
       const before = buildContext(path.slice(0, -1));
-      if (!Schema14.toEquivalence(Prompt9.Prompt)(before, history))
+      if (!Schema18.toEquivalence(Prompt11.Prompt)(before, history))
         return;
       recoveredHistory = buildContext(path);
-    }).pipe(Effect18.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
+    }).pipe(Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
   }
   let resumeChat;
   let validatedResume;
   if (resume !== undefined) {
-    resumeChat = persisted ?? (yield* options.history === undefined ? Chat.empty : Chat.fromPrompt(options.history));
+    resumeChat = persisted ?? (yield* options.history === undefined ? Chat2.empty : Chat2.fromPrompt(options.history));
     const received = resume.suspension;
     const resumeHistory = recoveredHistory ?? (yield* Ref5.get(resumeChat.history));
-    validatedResume = yield* Effect18.succeed(resumeHistory).pipe(Effect18.flatMap((history) => {
+    validatedResume = yield* Effect21.succeed(resumeHistory).pipe(Effect21.flatMap((history) => {
       const expected = suspensionCheckpoint(history.content);
       if (expected === undefined) {
         return ResumeMismatch.make({ reason: "checkpoint-not-found", received });
       }
-      return sameSuspension(expected.suspension, received) ? Effect18.succeed(expected) : ResumeMismatch.make({
+      return sameSuspension(expected.suspension, received) ? Effect21.succeed(expected) : ResumeMismatch.make({
         reason: "identity-mismatch",
         expected: expected.suspension,
         received
@@ -2263,7 +2241,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     }));
     if (recoveredHistory !== undefined && persisted !== undefined) {
       yield* Ref5.set(persisted.history, recoveredHistory);
-      yield* persisted.save.pipe(Effect18.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
+      yield* persisted.save.pipe(Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
     }
   }
   const staticCandidates = (agent.toolDeclarations ?? Object.values(agent.toolkit.tools).map((tool) => ({
@@ -2282,17 +2260,17 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       turn: 0
     });
   }
-  const executor = yield* Effect18.serviceOption(ToolExecutor);
-  const approvals = yield* Effect18.serviceOption(Approvals);
-  const chain = yield* Effect18.serviceOption(ModelMiddleware).pipe(Effect18.map(Option12.match({ onNone: () => [], onSome: (service) => service })));
+  const executor = yield* Effect21.serviceOption(ToolExecutor);
+  const approvals = yield* Effect21.serviceOption(Approvals);
+  const chain = yield* Effect21.serviceOption(ModelMiddleware).pipe(Effect21.map(Option14.match({ onNone: () => [], onSome: (service) => service })));
   if (options.toolOutputMaxBytes !== undefined && (!Number.isFinite(options.toolOutputMaxBytes) || options.toolOutputMaxBytes < 0)) {
     return yield* AgentError.make({
       message: "RunOptions.toolOutputMaxBytes must be a non-negative finite number",
       turn: 0
     });
   }
-  const decodedProgressPolicy = Schema14.decodeUnknownOption(progressOverflowPolicySchema)(options.toolProgress === undefined ? defaultProgressOverflowPolicy : options.toolProgress);
-  if (Option12.isNone(decodedProgressPolicy)) {
+  const decodedProgressPolicy = Schema18.decodeUnknownOption(progressOverflowPolicySchema)(options.toolProgress === undefined ? defaultProgressOverflowPolicy : options.toolProgress);
+  if (Option14.isNone(decodedProgressPolicy)) {
     return yield* AgentError.make({
       message: "RunOptions.toolProgress must select a supported policy with a positive safe-integer capacity",
       turn: 0
@@ -2312,11 +2290,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     });
   }
   const sessionId = options.sessionId ?? "local";
-  const instructionsService = yield* Effect18.serviceOption(Instructions);
-  const skillSourceService = yield* Effect18.serviceOption(SkillSource);
-  const skillRuntime = Option12.isNone(skillSourceService) ? undefined : {
+  const instructionsService = yield* Effect21.serviceOption(Instructions);
+  const skillSourceService = yield* Effect21.serviceOption(SkillSource);
+  const skillRuntime = Option14.isNone(skillSourceService) ? undefined : {
     source: skillSourceService.value,
-    skills: yield* skillSourceService.value.all.pipe(Effect18.mapError((error) => AgentError.make({ message: error.message, turn: 0, cause: error })))
+    skills: yield* skillSourceService.value.all.pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn: 0, cause: error })))
   };
   const selectedSkills = skillRuntime === undefined ? [] : selectListings(skillRuntime.skills, skillListingBudgetTokens, []);
   const skillListings = selectedSkills.map((skill) => skill.listing).join(`
@@ -2332,50 +2310,50 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       }
     ] : []
   ]);
-  const instructionsEpoch = options.system === undefined && options.history === undefined && Option12.isSome(instructionsService) ? yield* openEpoch(instructionsService.value, { agentName: agent.name, turn: 0 }) : undefined;
+  const instructionsEpoch = options.system === undefined && options.history === undefined && Option14.isSome(instructionsService) ? yield* openEpoch(instructionsService.value, { agentName: agent.name, turn: 0 }) : undefined;
   const baseSystem = options.system ?? (instructionsEpoch === undefined ? agent.instructions : instructionsEpoch.baseline.length === 0 ? agent.instructions : instructionsEpoch.baseline);
   const system = appendInstructionFragment(baseSystem, options.history === undefined && skillListings.length > 0 ? skillListingsInstructions(skillListings) : undefined);
-  const resilienceService = yield* Effect18.serviceOption(ModelResilience);
-  const modelRegistryService = yield* Effect18.serviceOption(Service);
-  const permissionsService = yield* Effect18.serviceOption(Permissions);
-  const ruleStoreService = yield* Effect18.serviceOption(RuleStore);
-  const authorizationService = yield* Effect18.serviceOption(ToolAuthorizerService);
-  const steeringService = yield* Effect18.serviceOption(Steering);
-  const memoryService = yield* Effect18.serviceOption(Memory);
-  const tokenizerService = yield* Effect18.serviceOption(Tokenizer2.Tokenizer);
-  const authorizer = agent.authorization ?? Option12.getOrElse(authorizationService, () => make4({
-    ...Option12.isNone(permissionsService) ? {} : { permissions: permissionsService.value },
-    ...Option12.isNone(approvals) ? {} : { approvals: approvals.value },
-    ...Option12.isNone(ruleStoreService) ? {} : { ruleStore: ruleStoreService.value }
+  const resilienceService = yield* Effect21.serviceOption(ModelResilience);
+  const modelRegistryService = yield* Effect21.serviceOption(Service);
+  const permissionsService = yield* Effect21.serviceOption(Permissions);
+  const ruleStoreService = yield* Effect21.serviceOption(RuleStore);
+  const authorizationService = yield* Effect21.serviceOption(ToolAuthorizerService);
+  const steeringService = yield* Effect21.serviceOption(Steering);
+  const memoryService = yield* Effect21.serviceOption(Memory);
+  const tokenizerService = yield* Effect21.serviceOption(Tokenizer2.Tokenizer);
+  const authorizer = agent.authorization ?? Option14.getOrElse(authorizationService, () => make4({
+    ...Option14.isNone(permissionsService) ? {} : { permissions: permissionsService.value },
+    ...Option14.isNone(approvals) ? {} : { approvals: approvals.value },
+    ...Option14.isNone(ruleStoreService) ? {} : { ruleStore: ruleStoreService.value }
   }));
   const memoryOptions = options.memory ?? (agent.memory === undefined ? undefined : { key: agent.memory });
   const agentModel = agent.model;
-  const agentModelRegistry = agentModel === undefined ? undefined : yield* Option12.match(modelRegistryService, {
-    onNone: () => Effect18.fail(AgentError.make({
+  const agentModelRegistry = agentModel === undefined ? undefined : yield* Option14.match(modelRegistryService, {
+    onNone: () => Effect21.fail(AgentError.make({
       message: "Agent.model requires ModelRegistry in context",
       turn: 0
     })),
-    onSome: Effect18.succeed
+    onSome: Effect21.succeed
   });
   const memoryRuntime = memoryOptions === undefined ? undefined : {
     key: memoryOptions.key,
-    service: yield* Option12.match(memoryService, {
-      onNone: () => Effect18.fail(AgentError.make({
+    service: yield* Option14.match(memoryService, {
+      onNone: () => Effect21.fail(AgentError.make({
         message: options.memory === undefined ? "Agent.memory requires Memory in context" : "RunOptions.memory requires Memory in context",
         turn: 0
       })),
-      onSome: Effect18.succeed
+      onSome: Effect21.succeed
     })
   };
   const seedSystem = persisted !== undefined && system !== undefined && (yield* Ref5.get(persisted.history)).content.length === 0 ? system : undefined;
-  const freshChat = options.history !== undefined ? Chat.fromPrompt(options.history) : system !== undefined ? Chat.fromPrompt([Prompt9.makeMessage("system", { content: system })]) : Chat.empty;
+  const freshChat = options.history !== undefined ? Chat2.fromPrompt(options.history) : system !== undefined ? Chat2.fromPrompt([Prompt11.makeMessage("system", { content: system })]) : Chat2.empty;
   const chat = resumeChat ?? persisted ?? (yield* freshChat);
-  const savePersisted = (turn) => persisted === undefined ? Effect18.void : persisted.save.pipe(Effect18.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })));
-  const appendPending = (turn, pending) => pending.length === 0 ? Ref5.get(chat.history) : Ref5.updateAndGet(chat.history, (history) => Prompt9.concat(history, Prompt9.fromResponseParts(pending))).pipe(Effect18.tap(() => savePersisted(turn)));
-  const checkpointSuspended = (turn, pending, suspension2) => Effect18.gen(function* () {
+  const savePersisted = (turn) => persisted === undefined ? Effect21.void : persisted.save.pipe(Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })));
+  const appendPending = (turn, pending) => pending.length === 0 ? Ref5.get(chat.history) : Ref5.updateAndGet(chat.history, (history) => Prompt11.concat(history, Prompt11.fromResponseParts(pending))).pipe(Effect21.tap(() => savePersisted(turn)));
+  const checkpointSuspended = (turn, pending, suspension2) => Effect21.gen(function* () {
     const withPending = yield* appendPending(turn, pending);
     const unresolved = unresolvedToolCall(withPending.content, suspension2.tool_call_id);
-    if (unresolved === undefined || unresolved.call.id !== suspension2.tool_call_id || unresolved.call.name !== suspension2.tool_name || !Equal.equals(unresolved.call.params, suspension2.tool_params)) {
+    if (unresolved === undefined || unresolved.call.id !== suspension2.tool_call_id || unresolved.call.name !== suspension2.tool_name || !Equal2.equals(unresolved.call.params, suspension2.tool_params)) {
       return yield* AgentError.make({
         message: "Suspension does not match the unresolved checkpoint call",
         turn
@@ -2393,8 +2371,8 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     const messages = withPending.content.map((message, messageIndex) => {
       if (messageIndex !== unresolved.messageIndex || message.role !== "assistant")
         return message;
-      return Prompt9.makeMessage("assistant", {
-        content: message.content.map((part, partIndex) => partIndex === unresolved.partIndex && part.type === "tool-call" ? Prompt9.makePart("tool-call", {
+      return Prompt11.makeMessage("assistant", {
+        content: message.content.map((part, partIndex) => partIndex === unresolved.partIndex && part.type === "tool-call" ? Prompt11.makePart("tool-call", {
           id: part.id,
           name: part.name,
           params: part.params,
@@ -2404,15 +2382,15 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         options: message.options
       });
     });
-    const checkpoint = Prompt9.fromMessages(messages);
+    const checkpoint = Prompt11.fromMessages(messages);
     const path = yield* syncSession(turn, withPending);
     const parentId = path.at(-1)?.id ?? null;
-    yield* applyCompactionResult(turn, { _tag: "Microcompact", history: checkpoint, prompt: Prompt9.empty }, parentId);
-    if (Option12.isNone(activeSession))
+    yield* applyCompactionResult(turn, { _tag: "Microcompact", history: checkpoint, prompt: Prompt11.empty }, parentId);
+    if (Option14.isNone(activeSession))
       yield* savePersisted(turn);
     return yield* Ref5.get(chat.history);
   });
-  const checkpointPending = (turn, pending) => appendPending(turn, pending).pipe(Effect18.tap((checkpoint) => syncSession(turn, checkpoint)));
+  const checkpointPending = (turn, pending) => appendPending(turn, pending).pipe(Effect21.tap((checkpoint) => syncSession(turn, checkpoint)));
   const failSuspended = (call, toolCallBatch, toolCallIndex, token, reason) => Stream4.fail(suspended(call, toolCallBatch, toolCallIndex, token, reason));
   const state = {
     text: "",
@@ -2425,15 +2403,15 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     registry: initialRegistry,
     activatedSkillBodies: new Map
   });
-  const restoreActivatedSkills = (history) => Effect18.gen(function* () {
+  const restoreActivatedSkills = (history) => Effect21.gen(function* () {
     for (const message of history.content) {
       if (!Array.isArray(message.content))
         continue;
       for (const part of message.content) {
         if (String(part.type) !== "tool-result" || String(part.name) !== activateSkillToolName || part.isFailure === true)
           continue;
-        const activation = Schema14.decodeUnknownOption(activateSkillSuccess)(part.result);
-        if (Option12.isNone(activation))
+        const activation = Schema18.decodeUnknownOption(activateSkillSuccess)(part.result);
+        if (Option14.isNone(activation))
           continue;
         if (skillRuntime === undefined) {
           return yield* AgentError.make({
@@ -2464,10 +2442,10 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         yield* Ref5.set(toolState, { registry, activatedSkillBodies });
       }
     }
-  }).pipe(Effect18.mapError((error) => isToolNameCollision(error) ? error : AgentError.make({ message: error.message, turn: 0, cause: error })));
+  }).pipe(Effect21.mapError((error) => isToolNameCollision(error) ? error : AgentError.make({ message: error.message, turn: 0, cause: error })));
   if (validatedResume !== undefined)
-    yield* Ref5.get(chat.history).pipe(Effect18.flatMap(restoreActivatedSkills));
-  const activeSession = Option12.isSome(compactionService) ? sessionService : Option12.none();
+    yield* Ref5.get(chat.history).pipe(Effect21.flatMap(restoreActivatedSkills));
+  const activeSession = Option14.isSome(compactionService) ? sessionService : Option14.none();
   const sessionError = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
   const compactionError = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
   const memoryError = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
@@ -2479,35 +2457,35 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       return prompt;
     const memoryMessage2 = messageFromRecall(content);
     const [first, ...rest] = prompt.content;
-    return first?.role === "system" ? Prompt9.fromMessages([first, memoryMessage2, ...rest]) : Prompt9.fromMessages([memoryMessage2, ...prompt.content]);
+    return first?.role === "system" ? Prompt11.fromMessages([first, memoryMessage2, ...rest]) : Prompt11.fromMessages([memoryMessage2, ...prompt.content]);
   };
-  const recallInitialPrompt = (prompt) => memoryRuntime === undefined ? Effect18.succeed(prompt) : memoryRuntime.service.recall({ key: memoryRuntime.key, turn: 0, prompt }).pipe(Effect18.mapError((error) => memoryError(0, error)), Effect18.map((items) => insertRecalledItems(prompt, items)));
-  const rememberTurn = (turn, transcript, terminal, path) => memoryRuntime === undefined ? Effect18.void : memoryRuntime.service.remember({
+  const recallInitialPrompt = (prompt) => memoryRuntime === undefined ? Effect21.succeed(prompt) : memoryRuntime.service.recall({ key: memoryRuntime.key, turn: 0, prompt }).pipe(Effect21.mapError((error) => memoryError(0, error)), Effect21.map((items) => insertRecalledItems(prompt, items)));
+  const rememberTurn = (turn, transcript, terminal, path) => memoryRuntime === undefined ? Effect21.void : memoryRuntime.service.remember({
     key: memoryRuntime.key,
     turn,
-    transcript: Option12.isSome(activeSession) ? buildMemoryContext(path) : projectTranscript(transcript),
+    transcript: Option14.isSome(activeSession) ? buildMemoryContext(path) : projectTranscript(transcript),
     terminal
-  }).pipe(Effect18.mapError((error) => memoryError(turn, error)));
-  const messageEquivalence = Schema14.toEquivalence(Prompt9.Message);
-  const promptEquivalence2 = Schema14.toEquivalence(Prompt9.Prompt);
+  }).pipe(Effect21.mapError((error) => memoryError(turn, error)));
+  const messageEquivalence = Schema18.toEquivalence(Prompt11.Message);
+  const promptEquivalence2 = Schema18.toEquivalence(Prompt11.Prompt);
   const sessionTranscriptCursor = (projection, transcript) => {
     if (projection.length === 0)
-      return Option12.some(0);
+      return Option14.some(0);
     const matches2 = [];
     for (let start = 0;start <= transcript.length - projection.length; start += 1) {
       if (transcript.slice(0, start).every((message) => message.role === "system") && projection.every((message, index) => messageEquivalence(message, transcript[start + index]))) {
         matches2.push(start + projection.length);
       }
     }
-    return matches2.length === 1 ? Option12.some(matches2[0]) : Option12.none();
+    return matches2.length === 1 ? Option14.some(matches2[0]) : Option14.none();
   };
-  const syncSession = (turn, transcript) => Option12.match(activeSession, {
-    onNone: () => Effect18.succeed([]),
-    onSome: (session) => Effect18.gen(function* () {
+  const syncSession = (turn, transcript) => Option14.match(activeSession, {
+    onNone: () => Effect21.succeed([]),
+    onSome: (session) => Effect21.gen(function* () {
       let path = yield* session.path();
       const projection = buildContext(path);
       const cursor = sessionTranscriptCursor(projection.content, transcript.content);
-      if (Option12.isNone(cursor)) {
+      if (Option14.isNone(cursor)) {
         const checkpoint = path.at(-1);
         const before = buildContext(path.slice(0, -1));
         if (checkpoint?._tag === "Compaction" && checkpoint.version === 2 && promptEquivalence2(before, transcript)) {
@@ -2528,13 +2506,13 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       if (expectedLeafId !== (path.at(-1)?.id ?? null))
         path = yield* session.path();
       return path;
-    }).pipe(Effect18.mapError((error) => Schema14.is(AgentError)(error) ? error : sessionError(turn, error)))
+    }).pipe(Effect21.mapError((error) => Schema18.is(AgentError)(error) ? error : sessionError(turn, error)))
   });
-  const countTokens = (turn, prompt) => Option12.match(tokenizerService, {
-    onNone: () => Effect18.succeed(Math.ceil(JSON.stringify(prompt.content).length / 4)),
-    onSome: (tokenizer) => tokenizer.tokenize(prompt).pipe(Effect18.map((tokens) => tokens.length), Effect18.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })))
+  const countTokens = (turn, prompt) => Option14.match(tokenizerService, {
+    onNone: () => Effect21.succeed(Math.ceil(JSON.stringify(prompt.content).length / 4)),
+    onSome: (tokenizer) => tokenizer.tokenize(prompt).pipe(Effect21.map((tokens) => tokens.length), Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })))
   });
-  const compactionUsage = (turn, history, prompt) => countTokens(turn, Prompt9.concat(history, prompt)).pipe(Effect18.map((contextTokens) => ({
+  const compactionUsage = (turn, history, prompt) => countTokens(turn, Prompt11.concat(history, prompt)).pipe(Effect21.map((contextTokens) => ({
     contextTokens,
     contextWindow: options.compaction?.contextWindow ?? Number.POSITIVE_INFINITY,
     reserveTokens: DEFAULT_RESERVE_TOKENS
@@ -2542,17 +2520,17 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
   const validateCompactionProjection = (turn, result) => {
     const pending = new Set;
     const optional = new Set;
-    for (const message of Prompt9.concat(result.history, result.prompt).content) {
+    for (const message of Prompt11.concat(result.history, result.prompt).content) {
       if (typeof message.content === "string") {
         if (pending.size > 0) {
-          return Effect18.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
+          return Effect21.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
         }
         optional.clear();
         continue;
       }
       const hasResult = message.content.some((part) => part.type === "tool-result");
       if (pending.size > 0 && !hasResult) {
-        return Effect18.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
+        return Effect21.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
       }
       if (!hasResult)
         optional.clear();
@@ -2560,7 +2538,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       for (const part of message.content) {
         if (part.type === "tool-call") {
           if (responseCalls.has(part.id)) {
-            return Effect18.fail(AgentError.make({ message: `Compaction projection contains duplicate tool call ${part.id}`, turn }));
+            return Effect21.fail(AgentError.make({ message: `Compaction projection contains duplicate tool call ${part.id}`, turn }));
           }
           responseCalls.add(part.id);
           if (part.providerExecuted)
@@ -2570,38 +2548,38 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         }
         if (part.type === "tool-result") {
           if (!pending.delete(part.id) && !optional.delete(part.id)) {
-            return Effect18.fail(AgentError.make({ message: `Compaction projection contains orphan tool result ${part.id}`, turn }));
+            return Effect21.fail(AgentError.make({ message: `Compaction projection contains orphan tool result ${part.id}`, turn }));
           }
         }
       }
     }
-    return pending.size === 0 ? Effect18.void : Effect18.fail(AgentError.make({ message: "Compaction projection contains an unresolved tool call", turn }));
+    return pending.size === 0 ? Effect21.void : Effect21.fail(AgentError.make({ message: "Compaction projection contains an unresolved tool call", turn }));
   };
-  const applyCompactionResult = (turn, result, parentId) => Option12.match(activeSession, {
+  const applyCompactionResult = (turn, result, parentId) => Option14.match(activeSession, {
     onNone: () => Ref5.set(chat.history, result.history),
-    onSome: (session) => Effect18.gen(function* () {
+    onSome: (session) => Effect21.gen(function* () {
       const id = yield* session.reserveEntryId;
-      yield* Effect18.uninterruptibleMask((restore) => restore(session.appendCheckpoint({
+      yield* Effect21.uninterruptibleMask((restore) => restore(session.appendCheckpoint({
         id,
         parentId,
         projectedHistory: result.history,
         ...result._tag === "Summarize" ? { summary: result.summary } : {}
-      })).pipe(Effect18.flatMap((appended) => restore(session.path(appended.leafId))), Effect18.map(buildContext), Effect18.tap((projection) => Ref5.set(chat.history, projection)), Effect18.andThen(restore(savePersisted(turn)))));
-    }).pipe(Effect18.mapError((error) => Schema14.is(AgentError)(error) ? error : sessionError(turn, error)))
+      })).pipe(Effect21.flatMap((appended) => restore(session.path(appended.leafId))), Effect21.map(buildContext), Effect21.tap((projection) => Ref5.set(chat.history, projection)), Effect21.andThen(restore(savePersisted(turn)))));
+    }).pipe(Effect21.mapError((error) => Schema18.is(AgentError)(error) ? error : sessionError(turn, error)))
   });
-  const preparePrompt = (turn, prompt, overflow) => Option12.match(compactionService, {
-    onNone: () => Effect18.succeed({ prompt, changed: false }),
-    onSome: (compaction) => Effect18.gen(function* () {
+  const preparePrompt = (turn, prompt, overflow) => Option14.match(compactionService, {
+    onNone: () => Effect21.succeed({ prompt, changed: false }),
+    onSome: (compaction) => Effect21.gen(function* () {
       const history = yield* Ref5.get(chat.history);
       const path = yield* syncSession(turn, history);
       const usage = yield* compactionUsage(turn, history, prompt);
       const historyRecalled = recalledMessages(history);
       const promptRecalled = recalledMessages(prompt);
-      const detachedHistory = yield* detachPrompt(history).pipe(Effect18.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
-      const detachedPrompt = yield* detachPrompt(prompt).pipe(Effect18.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
-      const originalHistory = yield* detachPrompt(detachedHistory).pipe(Effect18.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
-      const originalPrompt = yield* detachPrompt(detachedPrompt).pipe(Effect18.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
-      const detachedPath = yield* Effect18.forEach(path, detachEntry).pipe(Effect18.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const detachedHistory = yield* detachPrompt(history).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const detachedPrompt = yield* detachPrompt(prompt).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const originalHistory = yield* detachPrompt(detachedHistory).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const originalPrompt = yield* detachPrompt(detachedPrompt).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const detachedPath = yield* Effect21.forEach(path, detachEntry).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
       const compacted = yield* compaction.maybeCompact({
         agentName: agent.name,
         sessionId,
@@ -2612,15 +2590,15 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         usage,
         overflow,
         ...options.toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes: options.toolOutputMaxBytes }
-      }).pipe(Effect18.mapError((error) => compactionError(turn, error)));
-      if (Option12.isNone(compacted))
+      }).pipe(Effect21.mapError((error) => compactionError(turn, error)));
+      if (Option14.isNone(compacted))
         return { prompt, changed: false };
-      const changed = !Equal.equals(originalHistory.content, compacted.value.history.content) || !Equal.equals(originalPrompt.content, compacted.value.prompt.content);
+      const changed = !Equal2.equals(originalHistory.content, compacted.value.history.content) || !Equal2.equals(originalPrompt.content, compacted.value.prompt.content);
       if (!changed)
         return { prompt, changed: false };
       const allowed = [...historyRecalled, ...promptRecalled];
-      const required = Option12.isSome(activeSession) ? promptRecalled : allowed;
-      if (!preservesRecalledMessages(allowed, required, Prompt9.concat(compacted.value.history, compacted.value.prompt))) {
+      const required = Option14.isSome(activeSession) ? promptRecalled : allowed;
+      if (!preservesRecalledMessages(allowed, required, Prompt11.concat(compacted.value.history, compacted.value.prompt))) {
         return yield* MiddlewareViolation.make({
           turn,
           detail: "Compaction must preserve recalled-memory message lineage outside the lossless Session path"
@@ -2631,18 +2609,18 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       return { prompt: compacted.value.prompt, changed: true };
     })
   });
-  const boundedSuccessResult = (call, outcome) => options.toolOutputMaxBytes === undefined ? Effect18.succeed(successResult(call, outcome)) : bound(outcome, { toolCallId: call.id, maxBytes: options.toolOutputMaxBytes }).pipe(Effect18.map((bounded2) => successResult(call, bounded2)));
+  const boundedSuccessResult = (call, outcome) => options.toolOutputMaxBytes === undefined ? Effect21.succeed(successResult(call, outcome)) : bound(outcome, { toolCallId: call.id, maxBytes: options.toolOutputMaxBytes }).pipe(Effect21.map((bounded2) => successResult(call, bounded2)));
   const outcomeEvents = (turn, toolCallBatch, toolCallIndex, call, outcome, droppedProgress, registry) => {
     const metadata = droppedProgress === 0 ? {} : { metadata: { toolProgress: { dropped: droppedProgress } } };
     switch (outcome._tag) {
       case "Success":
-        return (isSkillActivationCall(call, registry) ? Effect18.succeed(successResult(call, outcome)) : boundedSuccessResult(call, outcome)).pipe(Effect18.map((result) => Stream4.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result, ...metadata }])));
+        return (isSkillActivationCall(call, registry) ? Effect21.succeed(successResult(call, outcome)) : boundedSuccessResult(call, outcome)).pipe(Effect21.map((result) => Stream4.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result, ...metadata }])));
       case "DomainFailure": {
         const result = domainFailureResult(call, outcome);
-        return Effect18.succeed(Stream4.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result, ...metadata }]));
+        return Effect21.succeed(Stream4.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result, ...metadata }]));
       }
       case "Suspend":
-        return Effect18.succeed(failSuspended(call, toolCallBatch, toolCallIndex, outcome.token, "tool-wait"));
+        return Effect21.succeed(failSuspended(call, toolCallBatch, toolCallIndex, outcome.token, "tool-wait"));
     }
   };
   const defaultExecute = (request, registry) => {
@@ -2650,11 +2628,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     if (registered?.dispatch === "Static") {
       return executeToolkit(staticToolkit, request);
     }
-    return registered === undefined ? Effect18.fail(FrameworkFailure.make({
+    return registered === undefined ? Effect21.fail(FrameworkFailure.make({
       stage: "missing-handler",
       tool: request.call.name,
       message: `Tool ${request.call.name} is not registered`
-    })) : Effect18.fail(FrameworkFailure.make({
+    })) : Effect21.fail(FrameworkFailure.make({
       stage: "missing-handler",
       tool: request.call.name,
       message: `Activated skill tool ${request.call.name} requires ToolExecutor`
@@ -2671,11 +2649,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         return Queue2.sliding(progressPolicy.capacity);
     }
   };
-  const executeApproved = (turn, call, request, registry) => Stream4.concat(Stream4.fromIterable([{ _tag: "ToolExecutionStarted", turn, call }]), Stream4.unwrap(Effect18.gen(function* () {
-    const progressQueue = yield* Effect18.acquireRelease(makeProgressQueue(), Queue2.shutdown);
+  const executeApproved = (turn, call, request, registry) => Stream4.concat(Stream4.fromIterable([{ _tag: "ToolExecutionStarted", turn, call }]), Stream4.unwrap(Effect21.gen(function* () {
+    const progressQueue = yield* Effect21.acquireRelease(makeProgressQueue(), Queue2.shutdown);
     const droppedProgress = yield* Ref5.make(0);
-    const emitSemaphore = yield* Semaphore2.make(1);
-    const signal = yield* Effect18.abortSignal;
+    const emitSemaphore = yield* Semaphore3.make(1);
+    const signal = yield* Effect21.abortSignal;
     const context = ToolContext.of({
       signal,
       sessionId,
@@ -2687,9 +2665,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
           ...progress.message === undefined ? {} : { message: progress.message },
           ...progress.data === undefined ? {} : { data: progress.data }
         };
-        return emitSemaphore.withPermit(Effect18.gen(function* () {
+        return emitSemaphore.withPermit(Effect21.gen(function* () {
           if (progressPolicy._tag === "Sliding") {
-            const dropped = yield* Effect18.sync(() => {
+            const dropped = yield* Effect21.sync(() => {
               const full = Queue2.isFullUnsafe(progressQueue);
               Queue2.offerUnsafe(progressQueue, event);
               return full;
@@ -2707,11 +2685,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         }));
       }
     });
-    const execution = isSkillActivationCall(call, registry) ? activateSkillOutcome(turn, call) : Option12.isNone(executor) ? defaultExecute(request, registry) : executor.value.execute(request).pipe(Effect18.mapError((error) => Schema14.is(RemoteRetryError)(error) ? AgentError.make({ message: error.message, turn, cause: error }) : error));
-    const fiber = yield* execution.pipe(Effect18.provideService(ToolContext, context), Effect18.ensuring(Queue2.end(progressQueue).pipe(Effect18.asVoid)), Effect18.forkScoped({ startImmediately: true }));
-    return Stream4.concat(Stream4.fromQueue(progressQueue), Stream4.fromEffect(Fiber.join(fiber)).pipe(Stream4.flatMap((outcome) => Stream4.unwrap(Ref5.get(droppedProgress).pipe(Effect18.flatMap((dropped) => outcomeEvents(turn, request.toolCallBatch, request.toolCallIndex, call, outcome, dropped, registry)))))));
+    const execution = isSkillActivationCall(call, registry) ? activateSkillOutcome(turn, call) : Option14.isNone(executor) ? defaultExecute(request, registry) : executor.value.execute(request).pipe(Effect21.mapError((error) => Schema18.is(RemoteRetryError)(error) ? AgentError.make({ message: error.message, turn, cause: error }) : error));
+    const fiber = yield* execution.pipe(Effect21.provideService(ToolContext, context), Effect21.ensuring(Queue2.end(progressQueue).pipe(Effect21.asVoid)), Effect21.forkScoped({ startImmediately: true }));
+    return Stream4.concat(Stream4.fromQueue(progressQueue), Stream4.fromEffect(Fiber.join(fiber)).pipe(Stream4.flatMap((outcome) => Stream4.unwrap(Ref5.get(droppedProgress).pipe(Effect21.flatMap((dropped) => outcomeEvents(turn, request.toolCallBatch, request.toolCallIndex, call, outcome, dropped, registry)))))));
   })));
-  const activateSkillOutcome = (turn, call) => Effect18.gen(function* () {
+  const activateSkillOutcome = (turn, call) => Effect21.gen(function* () {
     if (skillRuntime === undefined) {
       return yield* FrameworkFailure.make({
         stage: "missing-handler",
@@ -2719,8 +2697,8 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         message: "SkillSource is not available"
       });
     }
-    const params = Schema14.decodeUnknownOption(activateSkillParameters)(call.params);
-    if (Option12.isNone(params)) {
+    const params = Schema18.decodeUnknownOption(activateSkillParameters)(call.params);
+    if (Option14.isNone(params)) {
       return yield* FrameworkFailure.make({
         stage: "decode-input",
         tool: call.name,
@@ -2761,7 +2739,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       allowedTools: [...skill.frontmatter.allowedTools ?? []]
     };
     return { _tag: "Success", result: output, encodedResult: output };
-  }).pipe(Effect18.mapError((error) => isToolNameCollision(error) || Schema14.is(FrameworkFailure)(error) ? error : skillError(turn, error)));
+  }).pipe(Effect21.mapError((error) => isToolNameCollision(error) || Schema18.is(FrameworkFailure)(error) ? error : skillError(turn, error)));
   const authorizationError2 = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
   const toolCallEvents = (turn, toolCallBatch, toolCallIndex, call, messages, registry, authorizationStage, authorizationToken) => {
     const request = { call, toolCallBatch, turn, toolCallIndex, agentName: agent.name, sessionId };
@@ -2773,7 +2751,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         message: `Tool ${call.name} is not active for turn ${turn}`
       }));
     const activeTools = registry.entries.map((entry) => entry.tool.name);
-    return Stream4.unwrap(Effect18.gen(function* () {
+    return Stream4.unwrap(Effect21.gen(function* () {
       const activatedSkills = [...(yield* Ref5.get(toolState)).activatedSkillBodies.keys()];
       const approvalEvents = yield* Queue2.bounded(1);
       const fiber = yield* authorizer.authorize({
@@ -2786,8 +2764,8 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         ...authorizationToken === undefined ? {} : { authorizationToken },
         messages,
         execution: request,
-        onApprovalRequired: Queue2.offer(approvalEvents, { _tag: "ApprovalRequested", turn, call }).pipe(Effect18.asVoid)
-      }).pipe(Effect18.mapError((error) => authorizationError2(turn, error)), Effect18.ensuring(Queue2.end(approvalEvents).pipe(Effect18.asVoid)), Effect18.forkScoped({ startImmediately: true }));
+        onApprovalRequired: Queue2.offer(approvalEvents, { _tag: "ApprovalRequested", turn, call }).pipe(Effect21.asVoid)
+      }).pipe(Effect21.mapError((error) => authorizationError2(turn, error)), Effect21.ensuring(Queue2.end(approvalEvents).pipe(Effect21.asVoid)), Effect21.forkScoped({ startImmediately: true }));
       return Stream4.concat(Stream4.fromQueue(approvalEvents), Stream4.fromEffect(Fiber.join(fiber)).pipe(Stream4.flatMap((decision2) => {
         switch (decision2._tag) {
           case "Execute":
@@ -2815,8 +2793,8 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       })));
     }));
   };
-  const captureFinishPart = (part) => Effect18.gen(function* () {
-    const span = yield* Effect18.currentSpan;
+  const captureFinishPart = (part) => Effect21.gen(function* () {
+    const span = yield* Effect21.currentSpan;
     state.finish = {
       usage: state.finish === undefined ? part.usage : addUsage(state.finish.usage, part.usage),
       reason: part.reason
@@ -2830,9 +2808,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       },
       response: { finishReasons: [part.reason] }
     });
-  }).pipe(Effect18.orDie);
-  const captureStructuredUsage = (content) => Effect18.gen(function* () {
-    const span = yield* Effect18.currentSpan;
+  }).pipe(Effect21.orDie);
+  const captureStructuredUsage = (content) => Effect21.gen(function* () {
+    const span = yield* Effect21.currentSpan;
     for (const part of content) {
       if (part.type === "finish") {
         state.usage = state.usage === undefined ? part.usage : addUsage(state.usage, part.usage);
@@ -2846,10 +2824,10 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         });
       }
     }
-  }).pipe(Effect18.orDie);
-  const withModelResilience = (effect) => Option12.match(resilienceService, {
+  }).pipe(Effect21.orDie);
+  const withModelResilience = (effect) => Option14.match(resilienceService, {
     onNone: () => effect,
-    onSome: (resilience) => Effect18.flatMap(LanguageModel5.LanguageModel, (model) => effect.pipe(Effect18.provideService(LanguageModel5.LanguageModel, apply(model, {
+    onSome: (resilience) => Effect21.flatMap(LanguageModel5.LanguageModel, (model) => effect.pipe(Effect21.provideService(LanguageModel5.LanguageModel, apply(model, {
       ...resilience,
       classify: (error) => classifyFailure(model, error) === "context-overflow" ? "terminal" : resilience.classify(error)
     }))))
@@ -2873,33 +2851,33 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     }
     return modelPart;
   };
-  const recordPending = (event) => Effect18.sync(() => {
+  const recordPending = (event) => Effect21.sync(() => {
     if (event._tag === "ToolExecutionCompleted")
       state.pending.push(event.result);
   });
-  const transformPart = (turn, part) => applyPartChain(chain, part, { agentName: agent.name, turn }).pipe(Effect18.flatMap(Option12.match({
-    onSome: (transformed) => Effect18.succeed(Option12.some(transformed)),
-    onNone: () => part.type === "tool-call" ? Effect18.fail(MiddlewareViolation.make({
+  const transformPart = (turn, part) => applyPartChain(chain, part, { agentName: agent.name, turn }).pipe(Effect21.flatMap(Option14.match({
+    onSome: (transformed) => Effect21.succeed(Option14.some(transformed)),
+    onNone: () => part.type === "tool-call" ? Effect21.fail(MiddlewareViolation.make({
       turn,
       detail: "ModelMiddleware dropped a tool-call part"
-    })) : Effect18.succeed(Option12.none())
+    })) : Effect21.succeed(Option14.none())
   })));
   const validateToolCallId = (idState, part) => {
     if (part.type !== "tool-call")
-      return Effect18.void;
+      return Effect21.void;
     return Ref5.modify(idState, (current) => {
-      const existingFirstIndex = HashMap4.get(current.firstIndexes, part.id);
-      const duplicate = Option12.map(existingFirstIndex, (index) => DuplicateToolCallId.make({ id: part.id, firstIndex: index, duplicateIndex: current.nextIndex }));
+      const existingFirstIndex = HashMap5.get(current.firstIndexes, part.id);
+      const duplicate = Option14.map(existingFirstIndex, (index) => DuplicateToolCallId.make({ id: part.id, firstIndex: index, duplicateIndex: current.nextIndex }));
       return [
         duplicate,
         {
           nextIndex: current.nextIndex + 1,
-          firstIndexes: Option12.isSome(existingFirstIndex) ? current.firstIndexes : HashMap4.set(current.firstIndexes, part.id, current.nextIndex)
+          firstIndexes: Option14.isSome(existingFirstIndex) ? current.firstIndexes : HashMap5.set(current.firstIndexes, part.id, current.nextIndex)
         }
       ];
-    }).pipe(Effect18.flatMap(Option12.match({
-      onNone: () => Effect18.void,
-      onSome: Effect18.fail
+    }).pipe(Effect21.flatMap(Option14.match({
+      onNone: () => Effect21.void,
+      onSome: Effect21.fail
     })));
   };
   const modelTurn = (turn, prompt, registry, overrides) => {
@@ -2911,32 +2889,32 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       let preparedState;
       const singleFailure = (cause) => {
         const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-        return reason !== undefined && Cause4.isFailReason(reason) ? Option12.some(reason.error) : Option12.none();
+        return reason !== undefined && Cause4.isFailReason(reason) ? Option14.some(reason.error) : Option14.none();
       };
       const retryableOverflow = (cause, hasEmitted) => {
         const failure2 = singleFailure(cause);
-        return retryOverflow && !hasEmitted && Option12.isSome(failure2) && classifyFailure2(failure2.value) === "context-overflow" && Option12.isSome(compactionService);
+        return retryOverflow && !hasEmitted && Option14.isSome(failure2) && classifyFailure2(failure2.value) === "context-overflow" && Option14.isSome(compactionService);
       };
       return Stream4.fromChannel(Channel.acquireUseRelease(Ref5.make({
         nextIndex: 0,
-        firstIndexes: HashMap4.empty()
-      }), (toolCallIds) => Stream4.unwrap(Effect18.gen(function* () {
+        firstIndexes: HashMap5.empty()
+      }), (toolCallIds) => Stream4.unwrap(Effect21.gen(function* () {
         const activeModel = yield* LanguageModel5.LanguageModel;
         classifyFailure2 = (error) => classifyFailure(activeModel, error);
         const prepared = yield* preparePrompt(turn, activePrompt, compactOverflow);
         if (compactOverflow && !prepared.changed && overflowCause !== undefined) {
-          return yield* Effect18.failCause(overflowCause);
+          return yield* Effect21.failCause(overflowCause);
         }
         const preparedPrompt = prepared.prompt;
         const history = yield* Ref5.get(chat.history);
         preparedState = { history, preparedPrompt };
-        const responsePrompt = Prompt9.concat(history, preparedPrompt);
+        const responsePrompt = Prompt11.concat(history, preparedPrompt);
         const messages = responsePrompt.content;
         const rawParts = LanguageModel5.streamText({
           prompt: responsePrompt,
           toolkit: activeRegistry.toolkit,
           disableToolCallResolution: true
-        }).pipe(Stream4.tap(() => Effect18.sync(() => {
+        }).pipe(Stream4.tap(() => Effect21.sync(() => {
           emitted = true;
         })), Stream4.catchCause((cause) => {
           if (Cause4.hasInterrupts(cause) || Cause4.hasDies(cause))
@@ -2944,18 +2922,18 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
           if (retryableOverflow(cause, emitted))
             return Stream4.failCause(cause);
           const error = singleFailure(cause);
-          if (Option12.isNone(error))
+          if (Option14.isNone(error))
             return Stream4.failCause(cause);
-          return Stream4.make(Response7.makePart("error", { error: error.value }));
+          return Stream4.make(Response10.makePart("error", { error: error.value }));
         }));
-        return rawParts.pipe(Stream4.mapEffect((part) => transformPart(turn, part)), Stream4.flatMap(Option12.match({ onNone: () => Stream4.empty, onSome: Stream4.make })), Stream4.map((part) => ({
+        return rawParts.pipe(Stream4.mapEffect((part) => transformPart(turn, part)), Stream4.flatMap(Option14.match({ onNone: () => Stream4.empty, onSome: Stream4.make })), Stream4.map((part) => ({
           part,
           messages,
-          accept: validateToolCallId(toolCallIds, part).pipe(Effect18.andThen(Effect18.sync(() => {
+          accept: validateToolCallId(toolCallIds, part).pipe(Effect21.andThen(Effect21.sync(() => {
             transformedParts.push(part);
           })))
         })));
-      })).pipe(Stream4.toChannel), (_, exit) => preparedState === undefined || Exit2.isFailure(exit) && retryableOverflow(exit.cause, emitted) ? Effect18.void : Ref5.set(chat.history, Prompt9.concat(Prompt9.concat(preparedState.history, preparedState.preparedPrompt), Prompt9.fromResponseParts(transformedParts))).pipe(Effect18.andThen(persisted === undefined ? Effect18.void : persisted.save), Effect18.orDie, Effect18.asVoid))).pipe(Stream4.catchCause((cause) => {
+      })).pipe(Stream4.toChannel), (_, exit) => preparedState === undefined || Exit2.isFailure(exit) && retryableOverflow(exit.cause, emitted) ? Effect21.void : Ref5.set(chat.history, Prompt11.concat(Prompt11.concat(preparedState.history, preparedState.preparedPrompt), Prompt11.fromResponseParts(transformedParts))).pipe(Effect21.andThen(persisted === undefined ? Effect21.void : persisted.save), Effect21.orDie, Effect21.asVoid))).pipe(Stream4.catchCause((cause) => {
         if (Cause4.hasInterrupts(cause) || Cause4.hasDies(cause))
           return Stream4.failCause(cause);
         if (retryableOverflow(cause, emitted)) {
@@ -2964,15 +2942,15 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         return Stream4.failCause(cause);
       }), Stream4.catchCause((cause) => {
         const failure2 = singleFailure(cause);
-        return Option12.isSome(failure2) && AiError3.isAiError(failure2.value) ? Stream4.fail(AgentError.make({ message: errorMessage(failure2.value), turn, cause: failure2.value })) : Stream4.failCause(cause);
+        return Option14.isSome(failure2) && AiError4.isAiError(failure2.value) ? Stream4.fail(AgentError.make({ message: errorMessage(failure2.value), turn, cause: failure2.value })) : Stream4.failCause(cause);
       }));
     };
-    const parts = Stream4.unwrap(applyPromptChain(chain, Prompt9.make(prompt), { agentName: agent.name, turn }).pipe(Effect18.map((transformedPrompt) => {
+    const parts = Stream4.unwrap(applyPromptChain(chain, Prompt11.make(prompt), { agentName: agent.name, turn }).pipe(Effect21.map((transformedPrompt) => {
       let nextToolCallIndex = 0;
       const calls = new Array;
       const executions = new Array;
       const toolCallBatch = { calls };
-      const accepted = attempt(transformedPrompt, true).pipe(Stream4.mapEffect(({ accept, part, messages }) => accept.pipe(Effect18.as({ part, messages }))), Stream4.map(({ part, messages }) => {
+      const accepted = attempt(transformedPrompt, true).pipe(Stream4.mapEffect(({ accept, part, messages }) => accept.pipe(Effect21.as({ part, messages }))), Stream4.map(({ part, messages }) => {
         const toolCallIndex = nextToolCallIndex;
         if (part.type === "tool-call" && part.providerExecuted !== true) {
           const call = part;
@@ -2990,9 +2968,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
         return concurrency === 1 ? executionStreams.pipe(Stream4.flatMap(({ call, messages, toolCallIndex }) => toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry)), Stream4.tap(recordPending)) : executionStreams.pipe(Stream4.mapEffect(({ call, messages, toolCallIndex }) => Stream4.runCollect(toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry)), { concurrency }), Stream4.flatMap(Stream4.fromIterable), Stream4.tap(recordPending));
       }));
     })));
-    const resilientParts = Option12.match(resilienceService, {
+    const resilientParts = Option14.match(resilienceService, {
       onNone: () => parts,
-      onSome: (resilience) => Stream4.unwrap(LanguageModel5.LanguageModel.pipe(Effect18.map((model) => parts.pipe(Stream4.provideService(LanguageModel5.LanguageModel, apply(model, {
+      onSome: (resilience) => Stream4.unwrap(LanguageModel5.LanguageModel.pipe(Effect21.map((model) => parts.pipe(Stream4.provideService(LanguageModel5.LanguageModel, apply(model, {
         ...resilience,
         classify: (error) => classifyFailure(model, error) === "context-overflow" ? "terminal" : resilience.classify(error)
       }))))))
@@ -3012,30 +2990,30 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     transcript,
     ...state.usage === undefined ? {} : { usage: state.usage }
   });
-  const structuredFinalEvents = (structuredTurn, config) => Stream4.fromEffect(Effect18.gen(function* () {
-    const transformedPrompt = yield* applyPromptChain(chain, Prompt9.make(config.objectPrompt), {
+  const structuredFinalEvents = (structuredTurn, config) => Stream4.fromEffect(Effect21.gen(function* () {
+    const transformedPrompt = yield* applyPromptChain(chain, Prompt11.make(config.objectPrompt), {
       agentName: agent.name,
       turn: structuredTurn
     });
     const history = yield* Ref5.get(chat.history);
     const response = yield* LanguageModel5.generateObject({
-      prompt: Prompt9.concat(history, transformedPrompt),
+      prompt: Prompt11.concat(history, transformedPrompt),
       schema: config.schema,
       objectName: config.objectName,
       toolChoice: "none"
-    }).pipe(withModelResilience, withAgentModel, Effect18.catchCause((cause) => {
+    }).pipe(withModelResilience, withAgentModel, Effect21.catchCause((cause) => {
       const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-      return reason !== undefined && Cause4.isFailReason(reason) ? Effect18.fail(AgentError.make({
+      return reason !== undefined && Cause4.isFailReason(reason) ? Effect21.fail(AgentError.make({
         message: errorMessage(reason.error),
         turn: structuredTurn,
         cause: reason.error
-      })) : Effect18.failCause(cause);
+      })) : Effect21.failCause(cause);
     }));
     yield* captureStructuredUsage(response.content);
-    const transcript = Prompt9.concat(Prompt9.concat(history, transformedPrompt), Prompt9.fromResponseParts(response.content));
+    const transcript = Prompt11.concat(Prompt11.concat(history, transformedPrompt), Prompt11.fromResponseParts(response.content));
     const path = yield* syncSession(structuredTurn, history);
-    yield* applyCompactionResult(structuredTurn, { _tag: "Microcompact", history: transcript, prompt: Prompt9.empty }, path.at(-1)?.id ?? null);
-    if (Option12.isNone(activeSession))
+    yield* applyCompactionResult(structuredTurn, { _tag: "Microcompact", history: transcript, prompt: Prompt11.empty }, path.at(-1)?.id ?? null);
+    if (Option14.isNone(activeSession))
       yield* savePersisted(structuredTurn);
     const structuredOutput = {
       _tag: "StructuredOutput",
@@ -3045,16 +3023,16 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     };
     return [structuredOutput, terminalCompletedEvent(structuredTurn, transcript)];
   })).pipe(Stream4.flatMap((events) => Stream4.fromIterable(events)));
-  const promptFromSteeringMessages = (messages) => messages.reduce((prompt, message) => Prompt9.concat(prompt, message.prompt), Prompt9.empty);
-  const takeSteering = () => Option12.match(steeringService, {
-    onNone: () => Effect18.succeed([]),
+  const promptFromSteeringMessages = (messages) => messages.reduce((prompt, message) => Prompt11.concat(prompt, message.prompt), Prompt11.empty);
+  const takeSteering = () => Option14.match(steeringService, {
+    onNone: () => Effect21.succeed([]),
     onSome: (service) => service.takeSteering
   });
-  const takeFollowUp = () => Option12.match(steeringService, {
-    onNone: () => Effect18.succeed([]),
+  const takeFollowUp = () => Option14.match(steeringService, {
+    onNone: () => Effect21.succeed([]),
     onSome: (service) => service.takeFollowUp
   });
-  const afterTurn = (turn) => Effect18.gen(function* () {
+  const afterTurn = (turn) => Effect21.gen(function* () {
     const pending = state.pending;
     const transcript = yield* checkpointPending(turn, pending);
     const path = yield* syncSession(turn, transcript);
@@ -3110,7 +3088,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     }
     state.pending = [];
     const steering = yield* takeSteering();
-    const basePrompt = steering.length === 0 ? Prompt9.empty : promptFromSteeringMessages(steering);
+    const basePrompt = steering.length === 0 ? Prompt11.empty : promptFromSteeringMessages(steering);
     const prompt = decision2.overrides?.instructions === undefined ? basePrompt : withSystem(decision2.overrides.instructions, basePrompt);
     return {
       events: Stream4.fromIterable(steering.length === 0 ? [completed] : [completed, steeringDrainedEvent(turn, "steering", steering)]),
@@ -3124,7 +3102,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
   const runTurn = (turn, prompt, overrides) => {
     let next;
     let structuredTurn;
-    const currentTurn = Stream4.fromIterable([{ _tag: "TurnStarted", turn }]).pipe(Stream4.concat(resetTurnState(turn)), Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect18.map(({ registry }) => modelTurn(turn, prompt, registry, overrides))))), Stream4.concat(Stream4.unwrap(afterTurn(turn).pipe(Effect18.map((result) => {
+    const currentTurn = Stream4.fromIterable([{ _tag: "TurnStarted", turn }]).pipe(Stream4.concat(resetTurnState(turn)), Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect21.map(({ registry }) => modelTurn(turn, prompt, registry, overrides))))), Stream4.concat(Stream4.unwrap(afterTurn(turn).pipe(Effect21.map((result) => {
       next = result.next;
       structuredTurn = result.structuredTurn;
       return result.events;
@@ -3138,10 +3116,10 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
   };
   const resumeStream = (checkpoint) => {
     let next;
-    const currentTurn = resetTurnState(0).pipe(Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect18.map((tools) => {
+    const currentTurn = resetTurnState(0).pipe(Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect21.map((tools) => {
       const suspension2 = checkpoint.suspension;
       const registry = suspension2.authorization_stage === undefined && suspension2.active_tools === undefined ? tools.registry : select(tools.registry, suspension2.active_tools ?? []);
-      const calls = suspension2.tool_call_batch.map((call) => Response7.makePart("tool-call", {
+      const calls = suspension2.tool_call_batch.map((call) => Response10.makePart("tool-call", {
         id: call.id,
         name: call.name,
         params: call.params,
@@ -3157,23 +3135,23 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
       const execute = ({ call, toolCallIndex }) => toolCallEvents(0, toolCallBatch, toolCallIndex, call, checkpoint.messages, registry, toolCallIndex === startIndex ? suspension2.authorization_stage : undefined, toolCallIndex === startIndex ? suspension2.token : undefined);
       const concurrency = agent.toolExecution?.concurrency ?? 1;
       return concurrency === 1 ? executions.pipe(Stream4.flatMap(execute), Stream4.tap(recordPending)) : executions.pipe(Stream4.mapEffect((execution) => Stream4.runCollect(execute(execution)), { concurrency }), Stream4.flatMap(Stream4.fromIterable), Stream4.tap(recordPending));
-    })))), Stream4.concat(Stream4.unwrap(afterTurn(0).pipe(Effect18.map((result) => {
+    })))), Stream4.concat(Stream4.unwrap(afterTurn(0).pipe(Effect21.map((result) => {
       next = result.next;
       return result.events;
     })))), Stream4.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": 0 } }));
     return Stream4.concat(currentTurn, Stream4.suspend(() => next === undefined ? Stream4.empty : runTurn(1, next.prompt, next.overrides)));
   };
-  const baseInitialPrompt = seedSystem === undefined ? Prompt9.make(options.prompt) : withSystem(seedSystem, Prompt9.make(options.prompt));
+  const baseInitialPrompt = seedSystem === undefined ? Prompt11.make(options.prompt) : withSystem(seedSystem, Prompt11.make(options.prompt));
   const initialPrompt = options.resume === undefined ? yield* recallInitialPrompt(baseInitialPrompt) : baseInitialPrompt;
   const runStream = validatedResume === undefined ? runTurn(0, initialPrompt) : resumeStream(validatedResume);
   return runStream.pipe(Stream4.catchCause((cause) => {
     const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-    if (reason !== undefined && Cause4.isFailReason(reason) && Schema14.is(DuplicateToolCallId)(reason.error)) {
-      return Stream4.unwrap(checkpointPending(state.turn, state.pending).pipe(Effect18.map(() => Stream4.failCause(cause))));
+    if (reason !== undefined && Cause4.isFailReason(reason) && Schema18.is(DuplicateToolCallId)(reason.error)) {
+      return Stream4.unwrap(checkpointPending(state.turn, state.pending).pipe(Effect21.map(() => Stream4.failCause(cause))));
     }
-    if (reason !== undefined && Cause4.isFailReason(reason) && Schema14.is(AgentSuspended)(reason.error)) {
+    if (reason !== undefined && Cause4.isFailReason(reason) && Schema18.is(AgentSuspended)(reason.error)) {
       const suspension2 = reason.error;
-      return Stream4.unwrap(Effect18.gen(function* () {
+      return Stream4.unwrap(Effect21.gen(function* () {
         const checkpoint = yield* checkpointSuspended(state.turn, state.pending, suspension2);
         yield* syncSession(state.turn, checkpoint);
         return Stream4.concat(Stream4.fromIterable([turnCompletedEvent(state.turn, checkpoint)]), Stream4.failCause(cause));
@@ -3182,6 +3160,45 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen
     return Stream4.failCause(cause);
   }));
 })).pipe(Stream4.withSpan("Baton.Agent.run", { attributes: { "baton.agent.name": agent.name } }), (run) => agent[ModelLayerTypeId] === undefined ? run : run.pipe(Stream4.provide(agent[ModelLayerTypeId])));
+
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent.js
+var AgentTypeId = Symbol.for("@batonfx/core/Agent");
+function make5(options) {
+  const declaredTools = "tools" in options && Array.isArray(options.tools) ? options.tools : undefined;
+  const toolkit = declaredTools === undefined ? options.toolkit ?? Toolkit5.empty : Toolkit5.make(...declaredTools);
+  if (declaredTools !== undefined) {
+    for (const tool of declaredTools) {
+      if (!Object.hasOwn(toolkit.tools, tool.name)) {
+        Object.defineProperty(toolkit.tools, tool.name, {
+          configurable: true,
+          enumerable: true,
+          value: tool,
+          writable: true
+        });
+      }
+    }
+  }
+  return {
+    [AgentTypeId]: {
+      tools: (value) => value,
+      requirements: (value) => value
+    },
+    name: options.name,
+    ...options.instructions === undefined ? {} : { instructions: options.instructions },
+    toolkit,
+    policy: options.policy ?? defaultPolicy,
+    ...options.model === undefined ? {} : { model: options.model },
+    ...options.memory === undefined ? {} : { memory: options.memory },
+    ...options.authorization === undefined ? {} : { authorization: options.authorization },
+    ...options.toolExecution === undefined ? {} : { toolExecution: options.toolExecution },
+    ...options.metadata === undefined ? {} : { metadata: options.metadata },
+    toolDeclarations: (declaredTools ?? Object.values(toolkit.tools)).map((tool) => ({
+      tool,
+      origin: { _tag: "Static", agent: options.name }
+    }))
+  };
+}
+var defaultObjectPrompt = "Return the final structured output for the task above.";
 var provideModel = dual7(2, (agent, layer8) => ({
   ...agent,
   policy: agent.policy,
@@ -3194,99 +3211,63 @@ var provideModel = dual7(2, (agent, layer8) => ({
   },
   [ModelLayerTypeId]: layer8
 }));
-var stream2 = dual7(2, (agent, options) => streamInternal(agent, options, undefined));
-var persisted = dual7(2, (agent, options) => streamInternal(agent, options, undefined));
-var streamObject = dual7(2, (agent, options) => streamInternal(agent, options, {
-  schema: options.schema,
-  objectName: options.objectName ?? "output",
-  objectPrompt: options.objectPrompt ?? defaultObjectPrompt
-}));
-var persistedObject = dual7(2, (agent, options) => streamInternal(agent, options, {
+var stream2 = dual7(2, (agent, options) => streamInternal(agent, options, options.schema === undefined ? undefined : {
   schema: options.schema,
   objectName: options.objectName ?? "output",
   objectPrompt: options.objectPrompt ?? defaultObjectPrompt
 }));
-var generate = dual7(2, (agent, options) => Stream4.runLast(stream2(agent, options)).pipe(Effect18.flatMap(Option12.match({
-  onNone: () => Effect18.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 })),
-  onSome: (event) => event._tag === "Completed" ? Effect18.succeed({ text: event.text, turns: event.turns, transcript: event.transcript }) : Effect18.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 }))
-}))));
-var generatePersisted = dual7(2, (agent, options) => Stream4.runLast(persisted(agent, options)).pipe(Effect18.flatMap(Option12.match({
-  onNone: () => Effect18.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 })),
-  onSome: (event) => event._tag === "Completed" ? Effect18.succeed({ text: event.text, turns: event.turns, transcript: event.transcript }) : Effect18.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 }))
-}))));
-var generateObject = dual7(2, (agent, options) => Stream4.runFold(streamObject(agent, options), () => ({
-  value: Option12.none(),
-  completed: Option12.none()
-}), (acc, event) => {
-  if (event._tag === "StructuredOutput") {
-    return { ...acc, value: Option12.some(event.value) };
-  }
-  if (event._tag === "Completed") {
-    return { ...acc, completed: Option12.some(event) };
-  }
-  return acc;
-}).pipe(Effect18.flatMap(({ value, completed }) => Option12.match(completed, {
-  onNone: () => Effect18.fail(AgentError.make({ message: "Agent object run ended without a Completed event", turn: 0 })),
-  onSome: (event) => Option12.match(value, {
-    onNone: () => Effect18.fail(AgentError.make({
-      message: "Agent object run ended without a StructuredOutput event",
-      turn: 0
-    })),
-    onSome: (typedValue) => Effect18.succeed({
-      text: event.text,
-      turns: event.turns,
-      transcript: event.transcript,
-      value: typedValue
-    })
-  })
-}))));
-var generatePersistedObject = dual7(2, (agent, options) => Stream4.runFold(persistedObject(agent, options), () => ({ value: Option12.none(), completed: Option12.none() }), (acc, event) => event._tag === "StructuredOutput" ? { ...acc, value: Option12.some(event.value) } : event._tag === "Completed" ? { ...acc, completed: Option12.some(event) } : acc).pipe(Effect18.flatMap(({ value, completed }) => Option12.match(completed, {
-  onNone: () => Effect18.fail(AgentError.make({ message: "Agent object run ended without a Completed event", turn: 0 })),
-  onSome: (event) => Option12.match(value, {
-    onNone: () => Effect18.fail(AgentError.make({ message: "Agent object run ended without a StructuredOutput event", turn: 0 })),
-    onSome: (typedValue) => Effect18.succeed({
+var generateText = (agent, options) => Stream5.runLast(stream2(agent, options)).pipe(Effect22.flatMap(Option15.match({
+  onNone: () => Effect22.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 })),
+  onSome: (event) => event._tag === "Completed" ? Effect22.succeed({ text: event.text, turns: event.turns, transcript: event.transcript }) : Effect22.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 }))
+})));
+var generateObjectResult = (agent, options) => Stream5.runFold(stream2(agent, options), () => ({ value: Option15.none(), completed: Option15.none() }), (acc, event) => event._tag === "StructuredOutput" ? { ...acc, value: Option15.some(event.value) } : event._tag === "Completed" ? { ...acc, completed: Option15.some(event) } : acc).pipe(Effect22.flatMap(({ value, completed }) => Option15.match(completed, {
+  onNone: () => Effect22.fail(AgentError.make({ message: "Agent object run ended without a Completed event", turn: 0 })),
+  onSome: (event) => Option15.match(value, {
+    onNone: () => Effect22.fail(AgentError.make({ message: "Agent object run ended without a StructuredOutput event", turn: 0 })),
+    onSome: (typedValue) => Effect22.succeed({
       text: event.text,
       turns: event.turns,
       transcript: event.transcript,
       value: typedValue
     })
   })
-}))));
+})));
+var generate = dual7(2, (agent, options) => options.schema === undefined ? generateText(agent, options) : generateObjectResult(agent, options));
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/agent-tool.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-tool.js
 var exports_agent_tool = {};
 __export(exports_agent_tool, {
   asTool: () => asTool
 });
-import { Cause as Cause5, Effect as Effect19, Function as Function7, Schema as Schema15 } from "effect";
-import { Prompt as Prompt10, Tool as Tool8, Toolkit as Toolkit5 } from "effect/unstable/ai";
-var defaultParameters = Schema15.Struct({ prompt: Schema15.String });
+import { Cause as Cause5, Effect as Effect23, Function as Function7, Schema as Schema20 } from "effect";
+import { Prompt as Prompt13, Tool as Tool12, Toolkit as Toolkit6 } from "effect/unstable/ai";
+var defaultParameters = Schema20.Struct({ prompt: Schema20.String });
 var errorMessage2 = (error) => {
-  if (Schema15.is(AgentSuspended)(error)) {
+  if (Schema20.is(AgentSuspended)(error)) {
     return `suspended on ${error.tool_name}: ${error.reason}`;
   }
-  if (Schema15.is(AgentError)(error)) {
+  if (Schema20.is(AgentError)(error)) {
     return `failed on turn ${error.turn}: ${error.message}`;
   }
-  if (Schema15.is(ResumeMismatch)(error)) {
+  if (Schema20.is(ResumeMismatch)(error)) {
     return `resume mismatch: ${error.reason}`;
   }
-  if (Schema15.is(TurnLimitExceeded)(error)) {
+  if (Schema20.is(TurnLimitExceeded)(error)) {
     return `turn limit exceeded at turn ${error.turn}`;
   }
-  if (Schema15.is(TurnPolicyStopped)(error)) {
+  if (Schema20.is(TurnPolicyStopped)(error)) {
     return `policy stopped at turn ${error.turn}: ${error.reason._tag}`;
   }
-  if (Schema15.is(TurnPolicyError)(error)) {
+  if (Schema20.is(TurnPolicyError)(error)) {
     return `turn policy failed: ${error.message}`;
   }
-  if (Schema15.is(MiddlewareViolation)(error)) {
+  if (Schema20.is(MiddlewareViolation)(error)) {
     return `middleware violation on turn ${error.turn}: ${error.detail}`;
   }
-  if (Schema15.is(DuplicateToolCallId)(error)) {
+  if (Schema20.is(DuplicateToolCallId)(error)) {
     return `duplicate tool-call ID '${error.id}' at position ${error.duplicateIndex} (first at ${error.firstIndex})`;
   }
-  if (Schema15.is(ToolNameCollision)(error)) {
+  if (Schema20.is(ToolNameCollision)(error)) {
     return `tool name collision: ${error.name} (${error.origins.map((origin) => origin._tag === "Static" ? `static:${origin.agent}` : origin._tag === "Builtin" ? `builtin:${origin.builtin}` : origin._tag === "Skill" ? `skill:${origin.skill}` : `handoff:${origin.specialist}`).join(", ")})`;
   }
   return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
@@ -3296,35 +3277,35 @@ var lazyHandled = (toolkit, name, handler) => ({
   tools: toolkit.tools,
   handle: (toolName, params) => toolkit.toHandlers({
     [name]: handler
-  }).pipe(Effect19.flatMap((handlers) => toolkit.pipe(Effect19.provide(handlers))), Effect19.flatMap((handled) => handled.handle(toolName, params)))
+  }).pipe(Effect23.flatMap((handlers) => toolkit.pipe(Effect23.provide(handlers))), Effect23.flatMap((handled) => handled.handle(toolName, params)))
 });
 var asTool = Function7.dual((args) => args.length !== 1 || ("name" in args[0]), (agent, options = {}) => {
   const name = options.name ?? agent.name;
   const parameters = options.parameters ?? defaultParameters;
-  const success2 = options.success ?? Schema15.String;
+  const success2 = options.success ?? Schema20.String;
   const toPrompt = options.toPrompt ?? ((params) => params.prompt);
   const fromResult = options.fromResult ?? ((result) => result.text);
-  const tool = Tool8.make(name, {
+  const tool = Tool12.make(name, {
     ...options.description === undefined ? {} : { description: options.description },
     parameters,
     success: success2,
-    failure: Schema15.String,
+    failure: Schema20.String,
     failureMode: "return"
   });
-  const toolkit = Toolkit5.make(tool);
-  const handler = (params) => Effect19.gen(function* () {
-    const prompt = yield* Effect19.try({ try: () => toPrompt(params), catch: errorMessage2 });
-    const result = yield* generate(agent, { prompt }).pipe(Effect19.catchCause((cause) => {
+  const toolkit = Toolkit6.make(tool);
+  const handler = (params) => Effect23.gen(function* () {
+    const prompt = yield* Effect23.try({ try: () => toPrompt(params), catch: errorMessage2 });
+    const result = yield* generate(agent, { prompt }).pipe(Effect23.catchCause((cause) => {
       if (Cause5.hasInterrupts(cause))
-        return Effect19.interrupt;
-      return Effect19.fail(causeMessage(agent.name, cause));
+        return Effect23.interrupt;
+      return Effect23.fail(causeMessage(agent.name, cause));
     }));
-    return yield* Effect19.try({ try: () => fromResult(result), catch: errorMessage2 });
+    return yield* Effect23.try({ try: () => fromResult(result), catch: errorMessage2 });
   });
   return lazyHandled(toolkit, name, handler);
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/guardrail.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/guardrail.js
 var exports_guardrail = {};
 __export(exports_guardrail, {
   validateInput: () => validateInput,
@@ -3332,17 +3313,17 @@ __export(exports_guardrail, {
   redactInput: () => redactInput,
   filterOutput: () => filterOutput
 });
-import { Effect as Effect20, Option as Option13 } from "effect";
-import { Prompt as Prompt11, Response as Response8 } from "effect/unstable/ai";
+import { Effect as Effect24, Option as Option16 } from "effect";
+import { Prompt as Prompt14, Response as Response11 } from "effect/unstable/ai";
 var replacement = (options) => options.replacement ?? "[redacted]";
 var redactText = (text, options) => text.replace(options.pattern, replacement(options));
-var redactUserPart = (part, options) => part.type === "text" ? Prompt11.makePart("text", { text: redactText(part.text, options), options: part.options }) : part;
+var redactUserPart = (part, options) => part.type === "text" ? Prompt14.makePart("text", { text: redactText(part.text, options), options: part.options }) : part;
 var redactAssistantPart = (part, options) => {
   switch (part.type) {
     case "text":
-      return Prompt11.makePart("text", { text: redactText(part.text, options), options: part.options });
+      return Prompt14.makePart("text", { text: redactText(part.text, options), options: part.options });
     case "reasoning":
-      return Prompt11.makePart("reasoning", { text: redactText(part.text, options), options: part.options });
+      return Prompt14.makePart("reasoning", { text: redactText(part.text, options), options: part.options });
     default:
       return part;
   }
@@ -3350,51 +3331,51 @@ var redactAssistantPart = (part, options) => {
 var redactToolPart = (part, options) => {
   if (part.type !== "tool-approval-response" || part.reason === undefined)
     return part;
-  return Prompt11.makePart("tool-approval-response", {
+  return Prompt14.makePart("tool-approval-response", {
     approvalId: part.approvalId,
     approved: part.approved,
     reason: redactText(part.reason, options),
     options: part.options
   });
 };
-var redactPromptText = (prompt, options) => Prompt11.fromMessages(prompt.content.map((message) => {
+var redactPromptText = (prompt, options) => Prompt14.fromMessages(prompt.content.map((message) => {
   switch (message.role) {
     case "system":
-      return Prompt11.makeMessage("system", {
+      return Prompt14.makeMessage("system", {
         content: redactText(message.content, options),
         options: message.options
       });
     case "user":
-      return isMessageFromRecall(message) ? replaceRecalledMessage(message, message.content.map((part) => redactUserPart(part, options))) : Prompt11.makeMessage("user", {
+      return isMessageFromRecall(message) ? replaceRecalledMessage(message, message.content.map((part) => redactUserPart(part, options))) : Prompt14.makeMessage("user", {
         content: message.content.map((part) => redactUserPart(part, options)),
         options: message.options
       });
     case "assistant":
-      return Prompt11.makeMessage("assistant", {
+      return Prompt14.makeMessage("assistant", {
         content: message.content.map((part) => redactAssistantPart(part, options)),
         options: message.options
       });
     case "tool":
-      return Prompt11.makeMessage("tool", {
+      return Prompt14.makeMessage("tool", {
         content: message.content.map((part) => redactToolPart(part, options)),
         options: message.options
       });
   }
 }));
 var validateInput = (check) => ({
-  transformPrompt: (prompt, context) => check(prompt, context).pipe(Effect20.flatMap(Option13.match({
-    onNone: () => Effect20.succeed(prompt),
-    onSome: (reason) => Effect20.fail(AgentError.make({ message: `Input guardrail blocked: ${reason}`, turn: context.turn }))
+  transformPrompt: (prompt, context) => check(prompt, context).pipe(Effect24.flatMap(Option16.match({
+    onNone: () => Effect24.succeed(prompt),
+    onSome: (reason) => Effect24.fail(AgentError.make({ message: `Input guardrail blocked: ${reason}`, turn: context.turn }))
   })))
 });
 var redactInput = (options) => ({
-  transformPrompt: (prompt) => Effect20.succeed(redactPromptText(prompt, options))
+  transformPrompt: (prompt) => Effect24.succeed(redactPromptText(prompt, options))
 });
 var redactOutput = (options) => ({
   transformPart: (part) => {
     if (part.type !== "text-delta")
-      return Effect20.succeed(Option13.some(part));
-    return Effect20.succeed(Option13.some(Response8.makePart("text-delta", {
+      return Effect24.succeed(Option16.some(part));
+    return Effect24.succeed(Option16.some(Response11.makePart("text-delta", {
       id: part.id,
       delta: redactText(part.delta, options),
       metadata: part.metadata
@@ -3402,23 +3383,23 @@ var redactOutput = (options) => ({
   }
 });
 var filterOutput = (keep) => ({
-  transformPart: (part, context) => Effect20.succeed(part.type === "tool-call" || keep(part, context) ? Option13.some(part) : Option13.none())
+  transformPart: (part, context) => Effect24.succeed(part.type === "tool-call" || keep(part, context) ? Option16.some(part) : Option16.none())
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/handoff.js
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/handoff.js
 var exports_handoff = {};
 __export(exports_handoff, {
   transferTool: () => transferTool,
   supervisor: () => supervisor,
   fanOut: () => fanOut
 });
-import { Effect as Effect21, Function as Function8, Schema as Schema16 } from "effect";
-import { AiError as AiError4, LanguageModel as LanguageModel6, Prompt as Prompt12, Tool as Tool9, Toolkit as Toolkit6 } from "effect/unstable/ai";
-var defaultTransferParameters = Schema16.Struct({ prompt: Schema16.String });
+import { Effect as Effect25, Function as Function8, Schema as Schema21 } from "effect";
+import { AiError as AiError6, LanguageModel as LanguageModel7, Prompt as Prompt15, Tool as Tool13, Toolkit as Toolkit7 } from "effect/unstable/ai";
+var defaultTransferParameters = Schema21.Struct({ prompt: Schema21.String });
 var transferName = (agentName) => `transfer_to_${agentName}`;
 var positiveConcurrency = (value) => {
   const concurrency = value ?? 4;
-  return Number.isInteger(concurrency) && concurrency > 0 ? Effect21.succeed(concurrency) : Effect21.fail(AgentError.make({
+  return Number.isInteger(concurrency) && concurrency > 0 ? Effect25.succeed(concurrency) : Effect25.fail(AgentError.make({
     message: "Handoff.fanOut concurrency must be a positive integer",
     turn: 0
   }));
@@ -3436,10 +3417,10 @@ var mergeHandled = (toolkits) => {
     tools,
     handle: (name, params) => {
       const entry = entries.get(String(name));
-      return entry === undefined ? Effect21.fail(AiError4.make({
+      return entry === undefined ? Effect25.fail(AiError6.make({
         module: "Handoff",
         method: `${String(name)}.handle`,
-        reason: AiError4.ToolNotFoundError.make({
+        reason: AiError6.ToolNotFoundError.make({
           toolName: String(name),
           availableTools: Object.keys(tools)
         })
@@ -3447,7 +3428,7 @@ var mergeHandled = (toolkits) => {
     }
   };
 };
-var toolkitFromHandled = (toolkit) => Toolkit6.make(...Object.values(toolkit.tools));
+var toolkitFromHandled = (toolkit) => Toolkit7.make(...Object.values(toolkit.tools));
 var transferTool = Function8.dual((args) => args.length !== 1 || ("name" in args[0]), (target, options = {}) => asTool(target, {
   name: options.nameOverride ?? transferName(target.name),
   description: options.description ?? `Transfer to ${target.name}`,
@@ -3456,7 +3437,7 @@ var transferTool = Function8.dual((args) => args.length !== 1 || ("name" in args
   ...options.toPrompt === undefined ? {} : { toPrompt: options.toPrompt },
   ...options.fromResult === undefined ? {} : { fromResult: options.fromResult }
 }));
-var fanOut = Function8.dual((args) => args.length !== 1 || Array.isArray(args[0]), (children, options = {}) => positiveConcurrency(options.concurrency).pipe(Effect21.flatMap((concurrency) => Effect21.forEach(children, (child) => {
+var fanOut = Function8.dual((args) => args.length !== 1 || Array.isArray(args[0]), (children, options = {}) => positiveConcurrency(options.concurrency).pipe(Effect25.flatMap((concurrency) => Effect25.forEach(children, (child) => {
   const runOptions = {
     ...child.options,
     prompt: child.prompt
@@ -3485,7 +3466,7 @@ var supervisor = (options) => {
   };
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.6.4/node_modules/@batonfx/core/dist/index.js
-import { AiError as AiError5, Chat as Chat2, EmbeddingModel, IdGenerator, LanguageModel as LanguageModel7, Model as Model2, Prompt as Prompt13, Response as Response9, ResponseIdTracker, Telemetry as Telemetry2, Tokenizer as Tokenizer3, Tool as Tool10, Toolkit as Toolkit7 } from "effect/unstable/ai";
+// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/index.js
+import { AiError as AiError7, Chat as Chat4, EmbeddingModel, IdGenerator, LanguageModel as LanguageModel8, Model as Model2, Prompt as Prompt16, Response as Response12, ResponseIdTracker, Telemetry as Telemetry2, Tokenizer as Tokenizer3, Tool as Tool14, Toolkit as Toolkit8 } from "effect/unstable/ai";
 
-export { exports_turn_policy, exports_agent_event, exports_tool_context, exports_tool_executor, exports_approvals, exports_memory, exports_session, exports_tool_output, exports_compaction, exports_instructions, exports_model_middleware, exports_model_registry, exports_model_resilience, exports_permissions, exports_skill_source, exports_steering, exports_agent, exports_agent_tool, exports_guardrail, exports_handoff, AiError5 as AiError, Chat2 as Chat, EmbeddingModel, IdGenerator, Model2 as Model, Prompt13 as Prompt, Response9 as Response, ResponseIdTracker, Telemetry2 as Telemetry, Tokenizer3 as Tokenizer, Tool10 as Tool, Toolkit7 as Toolkit };
+export { exports_turn_policy, exports_agent_event, exports_memory, exports_model_registry, exports_tool_context, exports_tool_executor, exports_approvals, exports_session, exports_tool_output, exports_compaction, exports_instructions, exports_model_middleware, exports_model_resilience, exports_permissions, exports_skill_source, exports_steering, exports_agent, exports_agent_tool, exports_guardrail, exports_handoff, AiError7 as AiError, Chat4 as Chat, EmbeddingModel, IdGenerator, Model2 as Model, Prompt16 as Prompt, Response12 as Response, ResponseIdTracker, Telemetry2 as Telemetry, Tokenizer3 as Tokenizer, Tool14 as Tool, Toolkit8 as Toolkit };