@relayfx/sdk 0.3.1 → 0.3.3

package/dist/index-25gwk9tj.js

@@ -0,0 +1,3423 @@
+// @bun
+import {
+  __export
+} from "./index-nb39b5ae.js";
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/turn-policy.js
+var exports_turn_policy = {};
+__export(exports_turn_policy, {
+  untilToolCall: () => untilToolCall,
+  recurs: () => recurs,
+  make: () => make,
+  fromLegacy: () => fromLegacy,
+  forever: () => forever,
+  defaultPolicy: () => defaultPolicy,
+  decision: () => decision,
+  both: () => both,
+  TurnPolicyError: () => TurnPolicyError,
+  StopReason: () => StopReason
+});
+import { Effect, Layer, Schema } from "effect";
+import { dual } from "effect/Function";
+import { LanguageModel, Prompt, Response } from "effect/unstable/ai";
+var StopReason = Schema.Union([
+  Schema.Struct({ _tag: Schema.tag("TurnLimit"), limit: Schema.Finite }),
+  Schema.Struct({ _tag: Schema.tag("GoalSatisfied") }),
+  Schema.Struct({ _tag: Schema.tag("BudgetExhausted"), budget: Schema.String }),
+  Schema.Struct({ _tag: Schema.tag("Policy"), detail: Schema.String })
+]);
+
+class TurnPolicyError extends Schema.TaggedErrorClass()("@batonfx/core/TurnPolicyError", {
+  message: Schema.String,
+  cause: Schema.optionalKey(Schema.Defect())
+}) {
+}
+var decision = {
+  continue: (overrides) => ({
+    _tag: "Continue",
+    ...overrides === undefined ? {} : { overrides }
+  }),
+  stop: (reason) => ({ _tag: "Stop", reason })
+};
+var make = (decide) => ({ decide });
+var fromLegacy = (decide) => make((info) => decide(info).pipe(Effect.map((result) => result._tag === "Stop" ? decision.stop({ _tag: "Policy", detail: "Legacy policy stopped" }) : result)));
+var forever = {
+  decide: () => Effect.succeed(decision.continue()),
+  snapshot: { _tag: "Forever" }
+};
+var recurs = (n) => ({
+  decide: (info) => Effect.succeed(info.turn < n + 1 ? decision.continue() : decision.stop(Number.isFinite(n) ? { _tag: "TurnLimit", limit: n } : { _tag: "Policy", detail: `Non-finite recurrence count stopped: ${String(n)}` })),
+  ...Number.isFinite(n) ? { snapshot: { _tag: "Recurs", count: n } } : {}
+});
+var untilToolCall = (name) => ({
+  decide: (info) => Effect.succeed(info.pendingToolResults.some((result) => result.name === name) ? decision.stop({ _tag: "GoalSatisfied" }) : decision.continue()),
+  snapshot: { _tag: "UntilToolCall", name }
+});
+var mergeOverrides = (first, second) => {
+  if (first === undefined)
+    return second;
+  if (second === undefined)
+    return first;
+  return { ...first, ...second };
+};
+var both = dual(2, (first, second) => ({
+  decide: (info) => Effect.gen(function* () {
+    const left = yield* first.decide(info);
+    if (left._tag === "Stop")
+      return left;
+    const right = yield* second.decide(info);
+    if (right._tag === "Stop")
+      return right;
+    return decision.continue(mergeOverrides(left.overrides, right.overrides));
+  }),
+  ...first.snapshot === undefined || second.snapshot === undefined ? {} : { snapshot: { _tag: "Both", first: first.snapshot, second: second.snapshot } }
+}));
+var defaultPolicy = forever;
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/agent-event.js
+var exports_agent_event = {};
+__export(exports_agent_event, {
+  addUsage: () => addUsage,
+  TurnPolicyStopped: () => TurnPolicyStopped,
+  TurnLimitExceeded: () => TurnLimitExceeded,
+  ToolOrigin: () => ToolOrigin,
+  ToolNameCollision: () => ToolNameCollision,
+  ResumeMismatch: () => ResumeMismatch,
+  ProgressOverflowError: () => ProgressOverflowError,
+  MiddlewareViolation: () => MiddlewareViolation,
+  DuplicateToolCallId: () => DuplicateToolCallId,
+  AgentSuspended: () => AgentSuspended,
+  AgentError: () => AgentError
+});
+import { Function, Schema as Schema2 } from "effect";
+import { Prompt as Prompt2, Response as Response2, Tool } from "effect/unstable/ai";
+var addUsageField = (left, right) => left === undefined && right === undefined ? undefined : (left ?? 0) + (right ?? 0);
+var addUsage = Function.dual(2, (left, right) => Response2.Usage.make({
+  inputTokens: {
+    uncached: addUsageField(left.inputTokens.uncached, right.inputTokens.uncached),
+    total: addUsageField(left.inputTokens.total, right.inputTokens.total),
+    cacheRead: addUsageField(left.inputTokens.cacheRead, right.inputTokens.cacheRead),
+    cacheWrite: addUsageField(left.inputTokens.cacheWrite, right.inputTokens.cacheWrite)
+  },
+  outputTokens: {
+    total: addUsageField(left.outputTokens.total, right.outputTokens.total),
+    text: addUsageField(left.outputTokens.text, right.outputTokens.text),
+    reasoning: addUsageField(left.outputTokens.reasoning, right.outputTokens.reasoning)
+  }
+}));
+
+class AgentError extends Schema2.TaggedErrorClass()("@batonfx/core/AgentError", {
+  message: Schema2.String,
+  turn: Schema2.Finite,
+  cause: Schema2.optionalKey(Schema2.Defect())
+}) {
+}
+
+class TurnLimitExceeded extends Schema2.TaggedErrorClass()("@batonfx/core/TurnLimitExceeded", {
+  turn: Schema2.Finite,
+  limit: Schema2.Finite,
+  pending: Schema2.Array(Schema2.Struct({
+    tool_call_id: Schema2.String,
+    tool_name: Schema2.String
+  }))
+}) {
+}
+
+class TurnPolicyStopped extends Schema2.TaggedErrorClass()("@batonfx/core/TurnPolicyStopped", {
+  turn: Schema2.Finite,
+  reason: StopReason,
+  pending: Schema2.Array(Schema2.Struct({
+    tool_call_id: Schema2.String,
+    tool_name: Schema2.String
+  }))
+}) {
+}
+
+class MiddlewareViolation extends Schema2.TaggedErrorClass()("@batonfx/core/MiddlewareViolation", {
+  turn: Schema2.Finite,
+  detail: Schema2.String
+}) {
+}
+
+class DuplicateToolCallId extends Schema2.TaggedErrorClass()("@batonfx/core/DuplicateToolCallId", {
+  id: Schema2.String,
+  firstIndex: Schema2.Finite,
+  duplicateIndex: Schema2.Finite
+}) {
+}
+
+class ProgressOverflowError extends Schema2.TaggedErrorClass()("@batonfx/core/ProgressOverflowError", {
+  turn: Schema2.Finite,
+  toolCallId: Schema2.String,
+  capacity: Schema2.Finite
+}) {
+}
+var ToolOrigin = Schema2.Union([
+  Schema2.TaggedStruct("Static", { agent: Schema2.String }),
+  Schema2.TaggedStruct("Builtin", { builtin: Schema2.Literal("activate_skill") }),
+  Schema2.TaggedStruct("Skill", { skill: Schema2.String }),
+  Schema2.TaggedStruct("Handoff", { specialist: Schema2.String })
+]);
+
+class ToolNameCollision extends Schema2.TaggedErrorClass()("@batonfx/core/ToolNameCollision", {
+  name: Schema2.String,
+  origins: Schema2.NonEmptyArray(ToolOrigin)
+}) {
+}
+
+class AgentSuspended extends Schema2.TaggedErrorClass()("@batonfx/core/AgentSuspended", {
+  token: Schema2.String,
+  reason: Schema2.Literals(["tool-wait", "approval"]),
+  authorization_stage: Schema2.optional(Schema2.Literals(["permission", "approval"])),
+  tool_call_id: Schema2.String,
+  tool_name: Schema2.String,
+  tool_params: Schema2.Unknown,
+  active_tools: Schema2.optional(Schema2.Array(Schema2.String)),
+  activated_skills: Schema2.optional(Schema2.Array(Schema2.String))
+}) {
+}
+
+class ResumeMismatch extends Schema2.TaggedErrorClass()("@batonfx/core/ResumeMismatch", {
+  reason: Schema2.Literals(["checkpoint-not-found", "identity-mismatch"]),
+  expected: Schema2.optional(AgentSuspended),
+  received: AgentSuspended
+}) {
+}
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/tool-context.js
+var exports_tool_context = {};
+__export(exports_tool_context, {
+  testLayer: () => testLayer,
+  layerDefault: () => layerDefault,
+  ToolContext: () => ToolContext
+});
+import { Context, Effect as Effect2, Layer as Layer2 } from "effect";
+
+class ToolContext extends Context.Service()("@batonfx/core/tool-context/ToolContext") {
+}
+var layerDefault = Layer2.sync(ToolContext, () => ToolContext.of({
+  signal: new AbortController().signal,
+  emit: () => Effect2.void,
+  sessionId: "local"
+}));
+var testLayer = (implementation) => Layer2.succeed(ToolContext, ToolContext.of(implementation));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/tool-executor.js
+var exports_tool_executor = {};
+__export(exports_tool_executor, {
+  testLayer: () => testLayer2,
+  sandbox: () => sandbox,
+  router: () => router,
+  routeToolkit: () => routeToolkit,
+  route: () => route,
+  remote: () => remote,
+  mcp: () => mcp,
+  fromToolkit: () => fromToolkit,
+  executeToolkit: () => executeToolkit,
+  client: () => client,
+  ToolExecutor: () => ToolExecutor,
+  RemoteRetryError: () => RemoteRetryError,
+  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"
+]);
+
+class FrameworkFailure extends Schema3.TaggedErrorClass()("@batonfx/core/FrameworkFailure", {
+  stage: FrameworkStage,
+  tool: Schema3.String,
+  message: Schema3.String
+}) {
+}
+
+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") {
+}
+var resultMessage = (result) => {
+  if (typeof result === "string")
+    return result;
+  if (result instanceof Error)
+    return `${result.name}: ${result.message}`;
+  try {
+    const message = JSON.stringify(result);
+    return message === undefined ? String(result) : message;
+  } catch {
+    return String(result);
+  }
+};
+var schemaMessage = (error) => error instanceof Error ? error.message : typeof error === "string" ? error : resultMessage(error);
+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)));
+};
+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)));
+};
+var encodeDomainCandidate = (tool, failure) => !Schema3.is(tool.failureSchema)(failure) ? Effect3.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)));
+};
+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)));
+};
+var aiFrameworkFailure = (tool, error) => {
+  switch (error.reason._tag) {
+    case "ToolParameterValidationError":
+      return frameworkFailure("decode-input", tool.name, error);
+    case "ToolNotFoundError":
+      return frameworkFailure("missing-handler", tool.name, error);
+    case "InvalidToolResultError":
+      return frameworkFailure("handler", tool.name, 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);
+      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) => {
+  if (typeof response !== "object" || response === null || !("_tag" in response)) {
+    return Effect3.fail(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"));
+    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"));
+    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"));
+    default:
+      return Effect3.fail(frameworkFailure("placement", tool.name, "Placement returned an unknown response tag"));
+  }
+};
+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`));
+  }
+  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);
+  };
+  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"));
+    }
+    const result = option.value;
+    if (!result.isFailure) {
+      return Effect3.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));
+};
+function executeToolkit(toolkitOrRequest, request) {
+  if (request === undefined) {
+    let pipeable = function(toolkit2) {
+      return "handle" in toolkit2 ? executeWithToolkit(toolkit2, pipeableRequest) : executeToolkit(toolkit2, pipeableRequest);
+    };
+    const pipeableRequest = toolkitOrRequest;
+    return pipeable;
+  }
+  const toolkit = toolkitOrRequest;
+  return ("handle" in toolkit ? Effect3.succeed(toolkit) : toolkit).pipe(Effect3.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({
+    execute: (request) => executeWithToolkit(handled, request)
+  }))));
+}
+var route = (options) => {
+  const routedTools = options.tools ?? [];
+  return {
+    tools: routedTools,
+    matches: (request) => routedTools.includes(request.call.name) || options.matches?.(request) === true,
+    execute: options.execute
+  };
+};
+var placementRoute = (placement, options) => {
+  const routedTools = options.tools ?? Object.keys(options.toolkit.tools);
+  return route({
+    tools: routedTools,
+    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 decodeInput(tool, request.call.params).pipe(Effect3.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)));
+    }
+  });
+};
+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(() => {
+  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"));
+  }
+  const operationKey = typeof options.operationKey === "function" ? options.operationKey(request) : undefined;
+  return validateOperationKey(operationKey).pipe(Effect3.flatMap((stableKey) => {
+    let attempt = 0;
+    const executeAttempt = Effect3.suspend(() => {
+      const currentKey = attempt === 0 ? stableKey : options.operationKey(request);
+      attempt += 1;
+      return validateOperationKey(currentKey).pipe(Effect3.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"))));
+    });
+    return Effect3.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)));
+  }));
+});
+var client = (options) => placementRoute("client", options);
+var remote = (options) => options.retrySafe === true ? placementRoute("remote", {
+  toolkit: options.toolkit,
+  ...options.tools === undefined ? {} : { tools: options.tools },
+  execute: (request) => retryRemote(options, request)
+}) : placementRoute("remote", options);
+var mcp = (options) => placementRoute("mcp", options);
+var sandbox = (options) => placementRoute("sandbox", options);
+function routeToolkit(toolkit) {
+  const makeRoute = (handled) => route({
+    tools: Object.keys(handled.tools),
+    execute: (request) => executeWithToolkit(handled, request)
+  });
+  return "handle" in toolkit ? makeRoute(toolkit) : toolkit.pipe(Effect3.map(makeRoute));
+}
+var routeInputEffect = (input) => Effect3.isEffect(input) ? input : Effect3.succeed(input);
+function router(routes) {
+  return Layer3.effect(ToolExecutor, Effect3.all(Array.from(routes, routeInputEffect)).pipe(Effect3.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);
+    }
+  }))));
+}
+var testLayer2 = (implementation) => Layer3.succeed(ToolExecutor, ToolExecutor.of(implementation));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/approvals.js
+var exports_approvals = {};
+__export(exports_approvals, {
+  testLayer: () => testLayer3,
+  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") {
+}
+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));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/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.1/node_modules/@batonfx/core/dist/session.js
+var exports_session = {};
+__export(exports_session, {
+  testLayer: () => testLayer5,
+  memoryLayer: () => memoryLayer,
+  layerMemory: () => layerMemory,
+  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 { Prompt as Prompt4 } from "effect/unstable/ai";
+class SessionStoreError extends Schema5.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
+  message: Schema5.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 SessionStore extends Context5.Service()("@batonfx/core/session/SessionStore") {
+}
+var initialState = {
+  entries: HashMap.empty(),
+  order: [],
+  leaf: null,
+  counter: 0
+};
+var success = (value) => ({ _tag: "Success", value });
+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 entryFromInput = (input, id, parentId) => {
+  const base = {
+    id,
+    parentId,
+    ...input.metadata === undefined ? {} : { metadata: input.metadata }
+  };
+  switch (input._tag) {
+    case "Message":
+      return { ...base, _tag: "Message", message: input.message };
+    case "ToolCall":
+      return { ...base, _tag: "ToolCall", part: input.part };
+    case "ToolResult":
+      return { ...base, _tag: "ToolResult", part: input.part };
+    case "Memory":
+      return { ...base, _tag: "Memory", items: input.items };
+    case "Skill":
+      return { ...base, _tag: "Skill", name: input.name, body: input.body };
+    case "Steering":
+      return { ...base, _tag: "Steering", message: input.message };
+    case "Handoff":
+      return { ...base, _tag: "Handoff", target: input.target, summary: input.summary };
+    case "Compaction":
+      return { ...base, _tag: "Compaction", summary: input.summary, firstKeptEntryId: input.firstKeptEntryId };
+    case "BranchSummary":
+      return { ...base, _tag: "BranchSummary", summary: input.summary };
+  }
+};
+var pathFromState = (state, leaf) => {
+  const entries = [];
+  let cursor = leaf;
+  while (cursor !== null) {
+    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))
+      return failure(`Session entry ${cursor} does not exist`);
+    const value = entry.value;
+    entries.push(value);
+    cursor = value.parentId;
+  }
+  return success(entries.toReversed());
+};
+var validateCompaction = (state, input) => {
+  if (input._tag !== "Compaction")
+    return success(undefined);
+  if (state.leaf === null)
+    return failure(`Session compaction keeps missing entry ${input.firstKeptEntryId}`);
+  const path = pathFromState(state, state.leaf);
+  if (path._tag === "Failure")
+    return path;
+  if (!path.value.some((entry) => entry.id === input.firstKeptEntryId)) {
+    return failure(`Session compaction keeps missing entry ${input.firstKeptEntryId}`);
+  }
+  return success(undefined);
+};
+var appendState = (state, input, options) => {
+  if (options?.expectedLeafId !== undefined && options.expectedLeafId !== state.leaf) {
+    return [
+      SessionConflict.make({
+        reason: "stale-leaf",
+        message: `Expected Session leaf ${String(options.expectedLeafId)} but found ${String(state.leaf)}`
+      }),
+      state
+    ];
+  }
+  const valid = validateCompaction(state, input);
+  if (valid._tag === "Failure")
+    return [valid, state];
+  const id = String(state.counter);
+  const entry = entryFromInput(input, id, state.leaf);
+  return [
+    success(entry),
+    {
+      entries: HashMap.set(state.entries, id, entry),
+      order: [...state.order, id],
+      leaf: id,
+      counter: state.counter + 1
+    }
+  ];
+};
+var promptEquivalence = Schema5.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)) {
+    const entry = existing.value;
+    if (entry._tag !== "Compaction" || entry.version !== 2 || !checkpointMatches(entry, prepared)) {
+      return [
+        SessionConflict.make({
+          reason: "checkpoint-id-reused",
+          message: `Session checkpoint id ${prepared.id} was reused with different content`
+        }),
+        state
+      ];
+    }
+    const activePath = state.leaf === null ? success([]) : pathFromState(state, state.leaf);
+    if (activePath._tag === "Failure") {
+      return [
+        SessionConflict.make({ reason: "checkpoint-not-on-active-path", message: activePath.error.message }),
+        state
+      ];
+    }
+    if (!activePath.value.some((active) => active.id === entry.id)) {
+      return [
+        SessionConflict.make({
+          reason: "checkpoint-not-on-active-path",
+          message: `Session checkpoint id ${prepared.id} is not on the active path`
+        }),
+        state
+      ];
+    }
+    return [{ _tag: "AlreadyPresent", checkpoint: entry, leafId: state.leaf ?? entry.id }, state];
+  }
+  if (state.leaf !== prepared.parentId) {
+    return [
+      SessionConflict.make({
+        reason: "stale-leaf",
+        message: `Expected Session leaf ${String(prepared.parentId)} but found ${String(state.leaf)}`
+      }),
+      state
+    ];
+  }
+  const checkpoint = {
+    _tag: "Compaction",
+    version: 2,
+    id: prepared.id,
+    parentId: prepared.parentId,
+    projectedHistory: prepared.projectedHistory,
+    ...prepared.summary === undefined ? {} : { summary: prepared.summary }
+  };
+  return [
+    { _tag: "Appended", checkpoint, leafId: checkpoint.id },
+    {
+      ...state,
+      entries: HashMap.set(state.entries, checkpoint.id, checkpoint),
+      order: [...state.order, checkpoint.id],
+      leaf: checkpoint.id
+    }
+  ];
+};
+var setLeafState = (state, id) => {
+  if (id !== null && Option3.isNone(HashMap.get(state.entries, id)))
+    return [failure(`Session entry ${id} does not exist`), state];
+  return [success(undefined), { ...state, leaf: id }];
+};
+var messageFromText = (role, text) => role === "system" ? Prompt4.makeMessage("system", { content: text }) : Prompt4.makeMessage("user", { content: [Prompt4.makePart("text", { text })] });
+var checkpointMessage = (summary) => messageFromText("user", `<conversation-checkpoint>
+${summary}
+</conversation-checkpoint>`);
+var branchSummaryMessage = (summary) => messageFromText("system", `<abandoned-branch-summary>
+${summary}
+</abandoned-branch-summary>`);
+var attributeValue = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;");
+var memoryMessage = (items) => messageFromText("system", `<memory>
+${items.join(`
+`)}
+</memory>`);
+var skillMessage = (entry) => messageFromText("system", `<skill name="${attributeValue(entry.name)}">
+${entry.body}
+</skill>`);
+var handoffMessage = (entry) => messageFromText("system", `<handoff target="${attributeValue(entry.target)}">
+${entry.summary}
+</handoff>`);
+var projectedMessages = (path) => {
+  const compactionIndex = path.findLastIndex((entry) => entry._tag === "Compaction");
+  const compaction = compactionIndex === -1 ? undefined : path[compactionIndex];
+  const messages = compaction?.version === 2 ? [...compaction.projectedHistory.content] : [];
+  const keptIndex = compaction === undefined || compaction.version === 2 ? -1 : path.findIndex((entry) => entry.id === compaction.firstKeptEntryId);
+  const entries = compactionIndex === -1 ? path : compaction?.version === 2 ? path.slice(compactionIndex + 1) : path.slice(keptIndex === -1 ? compactionIndex + 1 : keptIndex);
+  if (compaction !== undefined && compaction.version !== 2)
+    messages.push(checkpointMessage(compaction.summary));
+  for (const entry of entries) {
+    switch (entry._tag) {
+      case "Message":
+        messages.push(entry.message);
+        break;
+      case "ToolCall":
+        messages.push(Prompt4.makeMessage("assistant", { content: [entry.part] }));
+        break;
+      case "ToolResult":
+        messages.push(Prompt4.makeMessage("tool", { content: [entry.part] }));
+        break;
+      case "Memory":
+        messages.push(memoryMessage(entry.items));
+        break;
+      case "Skill":
+        messages.push(skillMessage(entry));
+        break;
+      case "Steering":
+        messages.push(entry.message);
+        break;
+      case "Handoff":
+        messages.push(handoffMessage(entry));
+        break;
+      case "BranchSummary":
+        messages.push(branchSummaryMessage(entry.summary));
+        break;
+      case "Compaction":
+        break;
+    }
+  }
+  return messages;
+};
+var buildContext = (path) => Prompt4.fromMessages(projectedMessages(path));
+var buildMemoryContext = (path) => {
+  const messages = path.flatMap((entry) => {
+    switch (entry._tag) {
+      case "Message":
+        return [entry.message];
+      case "ToolCall":
+        return [Prompt4.makeMessage("assistant", { content: [entry.part] })];
+      case "ToolResult":
+        return [Prompt4.makeMessage("tool", { content: [entry.part] })];
+      case "Steering":
+        return [entry.message];
+      case "Memory":
+      case "Skill":
+      case "Handoff":
+      case "Compaction":
+      case "BranchSummary":
+        return [];
+    }
+  });
+  return projectTranscript(Prompt4.fromMessages(messages));
+};
+var layerMemory = Layer6.effect(SessionStore, Ref.make(initialState).pipe(Effect6.map((state) => SessionStore.of({
+  reserveEntryId: Ref.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))
+}))));
+var memoryLayer = layerMemory;
+var testLayer5 = (implementation) => Layer6.succeed(SessionStore, SessionStore.of(implementation));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/tool-output.js
+var exports_tool_output = {};
+__export(exports_tool_output, {
+  testLayer: () => testLayer6,
+  layerNoop: () => layerNoop2,
+  layerMemory: () => layerMemory2,
+  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") {
+}
+
+class ToolOutputError extends Schema6.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
+  message: Schema6.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 }) => {
+    const id = `mem:tool-output-${next + 1}`;
+    return [Option4.some(id), { next: next + 1, records: HashMap2.set(records, id, { toolCallId, content }) }];
+  })
+}))));
+var testLayer6 = (implementation) => Layer7.succeed(ToolOutputStore, ToolOutputStore.of(implementation));
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+var serialized = (value) => {
+  const json = JSON.stringify(value);
+  return json === undefined ? String(value) : json;
+};
+var preview = (value, maxBytes) => {
+  const encoded = encoder.encode(value);
+  let end = Math.min(encoded.byteLength, Math.floor(maxBytes));
+  while (end > 0 && end < encoded.byteLength) {
+    const next = encoded[end];
+    if (next === undefined || (next & 192) !== 128)
+      break;
+    end -= 1;
+  }
+  return decoder.decode(encoded.slice(0, end));
+};
+var isBoundedInline = (value) => typeof value === "object" && value !== null && ("truncated" in value) && value.truncated === true && ("bytes" in value) && typeof value.bytes === "number" && Number.isSafeInteger(value.bytes) && value.bytes >= 0 && ("maxBytes" in value) && typeof value.maxBytes === "number" && Number.isFinite(value.maxBytes) && value.maxBytes >= 0 && ("preview" in value) && typeof value.preview === "string" && encoder.encode(value.preview).byteLength <= value.maxBytes;
+var isToolOutput = (value) => typeof value === "object" && value !== null && ("inline" in value) && isBoundedInline(value.inline) && (!("outputPaths" in value) || Array.isArray(value.outputPaths) && value.outputPaths.every((path) => typeof path === "string"));
+var bounded = (inline, outputPaths) => {
+  const output = { 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) => {
+  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));
+}));
+var bound = Function2.dual(2, (result, options) => Effect7.gen(function* () {
+  if (isToolOutput(result.encodedResult)) {
+    const output = result.encodedResult;
+    const outputPaths = output.outputPaths ?? [];
+    if (encoder.encode(output.inline.preview).byteLength <= options.maxBytes) {
+      return bounded(output.inline, outputPaths);
+    }
+    return bounded({ ...output.inline, maxBytes: options.maxBytes, preview: preview(output.inline.preview, options.maxBytes) }, outputPaths);
+  }
+  const encoded = serialized(result.encodedResult);
+  const bytes = encoder.encode(encoded).byteLength;
+  if (bytes <= options.maxBytes)
+    return { ...result, outputPaths: [] };
+  const maybeStore = yield* Effect7.serviceOption(ToolOutputStore);
+  if (Option4.isNone(maybeStore))
+    return boundedFromOriginal(encoded, bytes, options.maxBytes, []);
+  const path = yield* optionalStore(maybeStore.value, options.toolCallId, result);
+  if (Option4.isNone(path))
+    return boundedFromOriginal(encoded, bytes, options.maxBytes, []);
+  return boundedFromOriginal(encoded, bytes, options.maxBytes, [path.value]);
+}));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/compaction.js
+var exports_compaction = {};
+__export(exports_compaction, {
+  truncate: () => truncate,
+  toolOutputBound: () => toolOutputBound,
+  testLayer: () => testLayer7,
+  structuredSummary: () => structuredSummary,
+  strategy: () => strategy,
+  make: () => make2,
+  layer: () => layer,
+  keepRecent: () => keepRecent,
+  defaultStrategy: () => defaultStrategy,
+  SUMMARY_TEMPLATE: () => SUMMARY_TEMPLATE,
+  DEFAULT_RESERVE_TOKENS: () => DEFAULT_RESERVE_TOKENS,
+  DEFAULT_KEEP_RECENT_TOKENS: () => DEFAULT_KEEP_RECENT_TOKENS,
+  CompactionError: () => CompactionError,
+  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";
+var DEFAULT_RESERVE_TOKENS = 16384;
+var DEFAULT_KEEP_RECENT_TOKENS = 20000;
+var SUMMARY_TEMPLATE = `Summarize the conversation so another agent can continue seamlessly.
+
+Use Markdown with these sections:
+
+## Goal
+## Constraints
+## Progress
+### Done
+### In Progress
+### Blocked
+## Key Decisions
+## Next Steps
+## 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)
+});
+
+class CompactionError extends Schema7.TaggedErrorClass()("@batonfx/core/CompactionError", {
+  message: Schema7.String,
+  cause: Schema7.optionalKey(Schema7.Defect())
+}) {
+}
+
+class Compaction extends Context7.Service()("@batonfx/core/compaction") {
+}
+var serialized2 = (value) => {
+  const json = JSON.stringify(value);
+  return json === undefined ? String(value) : json;
+};
+var safeNonNegativeInteger = (name, value) => {
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new TypeError(`${name} must be a non-negative safe integer`);
+  return value;
+};
+var markdownList = (items) => items.length === 0 ? "- None" : items.map((item) => `- ${item}`).join(`
+`);
+var renderAgentSummary = (summary) => [
+  `## Goal
+${summary.goal}`,
+  `## Facts
+${markdownList(summary.facts)}`,
+  `## Decisions
+${markdownList(summary.decisions)}`,
+  `## Open Questions
+${markdownList(summary.openQuestions)}`,
+  `## Tool Findings
+${markdownList(summary.toolFindings)}`
+].join(`
+
+`);
+var APPROX_CHARS_PER_TOKEN = 4;
+var estimateTokens = (text) => Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
+var estimateEntryTokens = (entry) => estimateTokens(serialized2(entry));
+var estimatePromptTokens = (prompt) => estimateTokens(serialized2(prompt.content));
+var fits = (history, prompt, usage) => Number.isFinite(usage.contextWindow) && estimatePromptTokens(Prompt5.concat(history, prompt)) <= usage.contextWindow - usage.reserveTokens;
+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* () {
+  if (part.isFailure)
+    return [part, false];
+  const success2 = { _tag: "Success", result: part.result, encodedResult: part.result };
+  const bounded2 = yield* bound(success2, { toolCallId: part.id, maxBytes });
+  if (bounded2.encodedResult === success2.encodedResult)
+    return [part, false];
+  return [
+    Prompt5.makePart("tool-result", {
+      id: part.id,
+      name: part.name,
+      isFailure: false,
+      result: bounded2.encodedResult
+    }),
+    true
+  ];
+});
+var microcompactPrompt = (prompt, maxBytes) => Effect8.gen(function* () {
+  let changed = false;
+  const messages = [];
+  for (const message of prompt.content) {
+    if (typeof message.content === "string") {
+      messages.push(message);
+    } else {
+      let messageChanged = false;
+      const content = [];
+      for (const part of message.content) {
+        if (!isPromptToolResult(part)) {
+          content.push(part);
+        } else {
+          const [compacted, didCompact] = yield* compactToolPart(part, maxBytes);
+          changed = changed || didCompact;
+          messageChanged = messageChanged || didCompact;
+          content.push(compacted);
+        }
+      }
+      messages.push(messageChanged ? { ...message, content } : message);
+    }
+  }
+  return [changed ? Prompt5.fromMessages(messages) : prompt, changed];
+});
+var checkpointMessage2 = (summary) => Prompt5.makeMessage("user", {
+  content: [Prompt5.makePart("text", { text: `<conversation-checkpoint>
+${summary}
+</conversation-checkpoint>` })]
+});
+var summaryPrompt = (template, prompt) => Prompt5.make(`${template}
+
+Conversation to summarize:
+${serialized2(prompt.content)}`);
+var systemMessages = (entries) => entries.flatMap((entry) => entry._tag === "Message" && entry.message.role === "system" ? [entry.message] : []);
+var compactedHistory = (summary, head, recent) => Prompt5.concat(Prompt5.fromMessages([...systemMessages(head), checkpointMessage2(summary)]), recent);
+var normalizeUsage = (usage, options) => ({
+  contextTokens: Number.isFinite(usage.contextTokens) ? usage.contextTokens : 0,
+  contextWindow: Number.isFinite(usage.contextWindow) ? usage.contextWindow : options.contextWindow ?? Number.POSITIVE_INFINITY,
+  reserveTokens: options.reserveTokens ?? (Number.isFinite(usage.reserveTokens) ? usage.reserveTokens : DEFAULT_RESERVE_TOKENS)
+});
+var makeMicrocompact = (history, prompt) => ({
+  _tag: "Microcompact",
+  history,
+  prompt
+});
+var safeCutIndex = (entries, keepRecentTokens) => {
+  let total = 0;
+  let index = entries.length;
+  while (index > 0 && total < keepRecentTokens) {
+    index -= 1;
+    total += estimateEntryTokens(entries[index]);
+  }
+  while (index > 0 && (isToolMessage(entries[index]) || isAssistantToolCallEntry(entries[index - 1]))) {
+    index -= 1;
+  }
+  return index;
+};
+var defaultStrategy = (options = {}) => ({
+  shouldCompact: (usage) => Number.isFinite(usage.contextWindow) && usage.contextTokens > usage.contextWindow - usage.reserveTokens,
+  cut: (entries, keepRecentTokens) => {
+    const index = safeCutIndex(entries, keepRecentTokens);
+    if (index <= 0 || index >= entries.length)
+      return Option5.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 });
+  },
+  summarize: (plan, request) => {
+    const effect = Effect8.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 })));
+    });
+    return options.summaryModel === undefined ? effect : Effect8.scoped(Layer8.build(options.summaryModel).pipe(Effect8.flatMap((context) => effect.pipe(Effect8.provide(context)))));
+  }
+});
+var strategy = Function3.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,
+  ...part.toolOutputMaxBytes !== undefined ? { toolOutputMaxBytes: part.toolOutputMaxBytes } : current.toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes: current.toolOutputMaxBytes },
+  ...part.keepRecentTokens !== undefined ? { keepRecentTokens: part.keepRecentTokens } : current.keepRecentTokens === undefined ? {} : { keepRecentTokens: current.keepRecentTokens }
+}), base));
+var toolOutputBound = (options) => ({
+  toolOutputMaxBytes: safeNonNegativeInteger("ToolOutputBoundOptions.maxBytes", options.maxBytes)
+});
+var keepRecent = (options) => ({
+  keepRecentTokens: safeNonNegativeInteger("KeepRecentOptions.tokens", options.tokens)
+});
+var structuredSummary = (options = {}) => ({
+  summarize: (plan, request) => {
+    const effect = Effect8.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.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 })));
+    });
+    return options.summaryModel === undefined ? effect : Effect8.scoped(Layer8.build(options.summaryModel).pipe(Effect8.flatMap((context) => effect.pipe(Effect8.provide(context)))));
+  }
+});
+var make2 = Function3.dual((args) => args.length !== 1 || ("shouldCompact" in args[0]), (compactionStrategy, options = {}) => ({
+  maybeCompact: (input) => Effect8.gen(function* () {
+    const usage = normalizeUsage(input.usage, options);
+    const shouldCompact = input.overflow || compactionStrategy.shouldCompact(usage);
+    if (!shouldCompact)
+      return Option5.none();
+    let history = input.history;
+    let prompt = input.prompt;
+    let changed = false;
+    const toolOutputMaxBytes = input.toolOutputMaxBytes ?? compactionStrategy.toolOutputMaxBytes;
+    if (toolOutputMaxBytes !== undefined) {
+      const [compactedHistoryPrompt, historyChanged] = yield* microcompactPrompt(history, toolOutputMaxBytes);
+      const [compactedPrompt, promptChanged] = yield* microcompactPrompt(prompt, toolOutputMaxBytes);
+      history = compactedHistoryPrompt;
+      prompt = compactedPrompt;
+      changed = historyChanged || promptChanged;
+      if (changed && fits(history, prompt, usage))
+        return Option5.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();
+    const summary = yield* compactionStrategy.summarize(plan.value, {
+      ...input,
+      history,
+      prompt,
+      usage,
+      ...toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes }
+    });
+    const recent = buildContext(plan.value.recent);
+    const [compactedRecent] = toolOutputMaxBytes === undefined ? [recent, false] : yield* microcompactPrompt(recent, toolOutputMaxBytes);
+    return Option5.some({
+      _tag: "Summarize",
+      history: compactedHistory(summary, plan.value.head, compactedRecent),
+      prompt,
+      summary,
+      firstKeptEntryId: plan.value.firstKeptEntryId
+    });
+  })
+}));
+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 truncate = (maxTokens) => ({
+  maybeCompact: (input) => Effect8.gen(function* () {
+    const usage = input.usage;
+    if (!input.overflow && !(Number.isFinite(usage.contextWindow) && usage.contextTokens > usage.contextWindow - usage.reserveTokens)) {
+      return Option5.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));
+  })
+});
+var testLayer7 = (implementation) => Layer8.succeed(Compaction, Compaction.of(implementation));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/instructions.js
+var exports_instructions = {};
+__export(exports_instructions, {
+  testLayer: () => testLayer8,
+  staticSource: () => staticSource,
+  renderUpdate: () => renderUpdate,
+  openEpoch: () => openEpoch,
+  layer: () => layer2,
+  Instructions: () => Instructions
+});
+import { Context as Context8, Effect as Effect9, Layer as Layer9, Option as Option6 } from "effect";
+import { dual as dual3 } from "effect/Function";
+class Instructions extends Context8.Service()("@batonfx/core/instructions") {
+}
+var staticSource = dual3(2, (id, text) => ({
+  id,
+  cache: "baseline",
+  render: () => Effect9.succeed(text.length === 0 ? Option6.none() : Option6.some(text))
+}));
+var openEpoch = dual3(2, (instructions, context) => Effect9.gen(function* () {
+  const baseline = [];
+  const dynamic = [];
+  for (const source of instructions.sources) {
+    if (source.cache === "dynamic") {
+      dynamic.push(source);
+    } else {
+      const rendered = yield* source.render(context);
+      if (Option6.isSome(rendered))
+        baseline.push(rendered.value);
+    }
+  }
+  return { baseline: baseline.join(`
+
+`), dynamic };
+}));
+var renderUpdate = dual3(2, (epoch, context) => Effect9.gen(function* () {
+  const fragments = [];
+  for (const source of epoch.dynamic) {
+    const rendered = yield* source.render(context);
+    if (Option6.isSome(rendered))
+      fragments.push(rendered.value);
+  }
+  return fragments.length === 0 ? Option6.none() : Option6.some(fragments.join(`
+
+`));
+}));
+var layer2 = (sources) => Layer9.succeed(Instructions, Instructions.of({ sources: [...sources] }));
+var testLayer8 = (implementation) => Layer9.succeed(Instructions, Instructions.of(implementation));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/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.1/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;
+});
+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;
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/model-resilience.js
+var exports_model_resilience = {};
+__export(exports_model_resilience, {
+  testLayer: () => testLayer10,
+  none: () => none,
+  make: () => make3,
+  layer: () => layer5,
+  defaultClassify: () => defaultClassify,
+  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";
+
+class ModelResilience extends Context11.Service()("@batonfx/core/model-resilience/ModelResilience") {
+}
+var defaultClassify = (error) => AiError2.isAiError(error) && error.isRetryable ? "transient" : "terminal";
+var none = { classify: () => "terminal", retrySchedule: Schedule2.recurs(0) };
+var make3 = (input) => ({
+  classify: input?.classify ?? defaultClassify,
+  retrySchedule: input?.retrySchedule ?? none.retrySchedule
+});
+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) => {
+  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({
+  schedule: resilience.retrySchedule,
+  while: (error) => resilience.classify(error) === "transient"
+}), Effect12.flatMap((result) => Result.isFailure(result) ? Effect12.failCause(result.failure) : Effect12.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(() => {
+    emitted = true;
+  })), Stream3.catchCause((cause) => {
+    const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
+    if (reason === undefined || !Cause2.isFailReason(reason))
+      return Stream3.succeed(Result.fail(cause));
+    return emitted ? Stream3.succeed(Result.succeed(onEmittedFailure(reason.error))) : Stream3.fail(reason.error);
+  }));
+}).pipe(Stream3.retry(retryStreamSchedule(resilience)), Stream3.flatMap((result) => Result.isFailure(result) ? Stream3.failCause(result.failure) : Stream3.succeed(result.success)));
+var apply = Function5.dual(2, (model, resilience) => ({
+  ...model,
+  generateText: (options) => retryEffect(() => model.generateText(options), resilience),
+  generateObject: (options) => {
+    const generate = model.generateObject;
+    return retryEffect(() => generate(options), resilience);
+  },
+  streamText: (options) => retryStream(() => model.streamText(options), (error) => Response5.makePart("error", { error }), resilience)
+}));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/permissions.js
+var exports_permissions = {};
+__export(exports_permissions, {
+  testLayer: () => testLayer11,
+  ruleStoreTestLayer: () => ruleStoreTestLayer,
+  ruleStoreMemory: () => ruleStoreMemory,
+  matches: () => matches,
+  matchRule: () => matchRule,
+  interactive: () => interactive,
+  fromRuleset: () => fromRuleset,
+  evaluate: () => evaluate,
+  allowAll: () => allowAll,
+  RuleStore: () => RuleStore,
+  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 { dual as dual4 } from "effect/Function";
+
+class PermissionError extends Schema10.TaggedErrorClass()("@batonfx/core/PermissionError", {
+  message: Schema10.String
+}) {
+}
+
+class Permissions extends Context12.Service()("@batonfx/core/permissions") {
+}
+
+class RuleStore extends Context12.Service()("@batonfx/core/permissions/RuleStore") {
+}
+var escapeRegExp = (value) => value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+var glob = (pattern) => new RegExp(`^${pattern.split("*").map(escapeRegExp).join(".*")}$`);
+var isTextLeaf = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+var collectCandidates = (value, visiting, out) => {
+  if (typeof value === "string") {
+    out.push(value);
+    return true;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    out.push(String(value));
+    return true;
+  }
+  if (value === null || value === undefined)
+    return true;
+  if (typeof value !== "object")
+    return false;
+  if (visiting.has(value))
+    return false;
+  visiting.add(value);
+  let complete = true;
+  if (Array.isArray(value)) {
+    const joined = value.filter(isTextLeaf).map(String);
+    if (joined.length > 0)
+      out.push(joined.join(" "));
+    for (const element of value) {
+      complete = collectCandidates(element, visiting, out) && complete;
+    }
+  } else {
+    for (const propValue of Object.values(value)) {
+      complete = collectCandidates(propValue, visiting, out) && complete;
+    }
+  }
+  visiting.delete(value);
+  return complete;
+};
+var serializedParams = (params) => {
+  try {
+    const json = JSON.stringify(params);
+    return json === undefined ? String(params) : json;
+  } catch {
+    return String(params);
+  }
+};
+var project = (params) => {
+  const candidates = [];
+  const complete = collectCandidates(params, new Set, candidates);
+  candidates.push(serializedParams(params));
+  return { candidates, complete };
+};
+var matchesProjection = (pattern, tool, projection, failClosed) => {
+  const separator = pattern.indexOf(":");
+  if (separator === -1)
+    return glob(pattern).test(tool);
+  const toolPattern = pattern.slice(0, separator);
+  if (!glob(toolPattern).test(tool))
+    return false;
+  if (!projection.complete && failClosed)
+    return true;
+  const paramsPattern = glob(pattern.slice(separator + 1));
+  return projection.candidates.some((candidate) => paramsPattern.test(candidate));
+};
+var matches = dual4(3, (pattern, tool, params) => matchesProjection(pattern, tool, project(params), false));
+var matchingRule = (ruleset, tool, params) => {
+  const projection = project(params);
+  let matched;
+  for (const rule of ruleset.rules) {
+    if (matchesProjection(rule.pattern, tool, projection, rule.level === "deny"))
+      matched = rule;
+  }
+  return matched;
+};
+var matchRule = dual4(3, (ruleset, tool, params) => Option9.fromNullishOr(matchingRule(ruleset, tool, params)));
+var evaluate = dual4(3, (ruleset, tool, params) => matchingRule(ruleset, tool, params)?.level ?? ruleset.fallback ?? "ask");
+var tokenFor = (request) => `permission:${request.toolCallId ?? `${request.agentName}:${request.turn}:${request.tool}`}`;
+var decisionFor = (ruleset, request) => {
+  const rule = matchingRule(ruleset, request.tool, request.params);
+  const level = rule?.level ?? ruleset.fallback ?? "ask";
+  switch (level) {
+    case "allow":
+      return { _tag: "Allow" };
+    case "deny":
+      return { _tag: "Deny", ...rule?.reason === undefined ? {} : { reason: rule.reason } };
+    case "ask":
+      return { _tag: "Ask", token: tokenFor(request) };
+  }
+};
+var fromRuleset = (ruleset) => Layer13.succeed(Permissions, Permissions.of({
+  evaluate: (request) => Effect13.succeed(decisionFor(ruleset, request)),
+  await: () => Effect13.succeed(Option9.none())
+}));
+var allowAll = Layer13.succeed(Permissions, Permissions.of({
+  evaluate: () => Effect13.succeed({ _tag: "Allow" }),
+  await: () => Effect13.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))
+}));
+var ruleStoreMemory = (initialRules = []) => Layer13.effect(RuleStore, Ref4.make(initialRules).pipe(Effect13.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.1/node_modules/@batonfx/core/dist/skill-source.js
+var exports_skill_source = {};
+__export(exports_skill_source, {
+  testLayer: () => testLayer12,
+  selectListings: () => selectListings,
+  merge: () => merge2,
+  makeListing: () => makeListing,
+  layer: () => layer6,
+  fromSkills: () => fromSkills,
+  empty: () => empty,
+  SkillSourceError: () => SkillSourceError,
+  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";
+
+class SkillSourceError extends Schema11.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
+  source: Schema11.String,
+  message: Schema11.String,
+  cause: Schema11.optionalKey(Schema11.Defect())
+}) {
+}
+var DESCRIPTION_CAP = 1024;
+
+class SkillSource extends Context13.Service()("@batonfx/core/skill-source/SkillSource") {
+}
+var makeListing = Function6.dual((args) => typeof args[0] !== "number", (frontmatter, descriptionCap = DESCRIPTION_CAP) => `- ${frontmatter.name}: ${frontmatter.description.slice(0, Math.max(0, descriptionCap))}`);
+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))
+  }));
+};
+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) => {
+    const byName = new Map;
+    for (const skills of groups) {
+      for (const skill of skills)
+        byName.set(skill.frontmatter.name, skill);
+    }
+    return [...byName.values()];
+  })),
+  get: (name) => Effect14.gen(function* () {
+    for (const source of sources.toReversed()) {
+      const found = yield* source.get(name);
+      if (found !== undefined)
+        return found;
+    }
+    return;
+  })
+});
+var layer6 = (sources) => Layer14.effect(SkillSource, Effect14.forEach(sources, (source) => source).pipe(Effect14.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);
+  return index === -1 ? -1 : index;
+};
+var selectListings = Function6.dual(3, (skills, budgetTokens, recentlyUsed) => {
+  if (budgetTokens <= 0)
+    return [];
+  const selected = skills.filter((skill) => skill.frontmatter.disableModelInvocation !== true && estimatedTokens(skill.listing) <= budgetTokens);
+  let total = selected.reduce((sum, skill) => sum + estimatedTokens(skill.listing), 0);
+  while (total > budgetTokens && selected.length > 0) {
+    let dropIndex = 0;
+    for (let index = 1;index < selected.length; index += 1) {
+      if (usageRank(selected[index], recentlyUsed) < usageRank(selected[dropIndex], recentlyUsed)) {
+        dropIndex = index;
+      }
+    }
+    const [dropped] = selected.splice(dropIndex, 1);
+    total -= dropped === undefined ? 0 : estimatedTokens(dropped.listing);
+  }
+  return selected;
+});
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/steering.js
+var exports_steering = {};
+__export(exports_steering, {
+  testLayer: () => testLayer13,
+  layer: () => layer7,
+  SteeringQueueFull: () => SteeringQueueFull,
+  Steering: () => Steering
+});
+import { Context as Context14, Effect as Effect15, Exit, Layer as Layer15, Queue, Schema as Schema12 } 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
+}) {
+}
+var resolvePolicy = (policy, mode) => ({
+  mode: policy?.mode ?? mode,
+  ...policy?.capacity === undefined ? {} : { capacity: policy.capacity },
+  onFull: policy?.onFull ?? "fail"
+});
+var queueStrategy = (strategy2) => {
+  switch (strategy2) {
+    case "drop-oldest":
+      return "sliding";
+    case "drop-newest":
+    case "fail":
+      return "dropping";
+    case "suspend":
+      return "suspend";
+  }
+};
+var makeQueue = (name, policy) => (policy.capacity === undefined ? Queue.unbounded() : Queue.make({ capacity: policy.capacity, strategy: queueStrategy(policy.onFull) })).pipe(Effect15.map((queue) => ({ name, queue, policy })));
+var offer = (runtime, message) => Queue.offer(runtime.queue, message).pipe(Effect15.flatMap((offered) => {
+  if (offered || runtime.policy.capacity === undefined || runtime.policy.onFull !== "fail")
+    return Effect15.void;
+  return SteeringQueueFull.make({ queue: runtime.name, capacity: runtime.policy.capacity });
+}));
+var drainOne = (queue) => Effect15.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* () {
+  const steeringQueue = yield* makeQueue("steering", resolvePolicy(options.steering, "all"));
+  const followUpQueue = yield* makeQueue("followUp", resolvePolicy(options.followUp, "one-at-a-time"));
+  return Steering.of({
+    steer: (message) => offer(steeringQueue, message),
+    followUp: (message) => offer(followUpQueue, message),
+    takeSteering: drain(steeringQueue.queue, steeringQueue.policy.mode),
+    takeFollowUp: drain(followUpQueue.queue, followUpQueue.policy.mode)
+  });
+}));
+var testLayer13 = (implementation) => Layer15.succeed(Steering, Steering.of(implementation));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/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 { 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";
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/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";
+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
+}) {
+}
+
+class AuthorizationError extends Schema13.TaggedErrorClass()("@batonfx/core/AuthorizationError", { message: Schema13.String, cause: Schema13.optional(Schema13.Defect()) }) {
+}
+
+class ToolAuthorizerService extends Context15.Service()("@batonfx/core/tool-authorization/ToolAuthorizerService") {
+}
+var deny = (message) => ({
+  _tag: "Deny",
+  error: PermissionDenied.make({ message })
+});
+var suspension = (request, token, stage) => ({
+  _tag: "Suspend",
+  suspension: AgentSuspended.make({
+    token,
+    reason: "approval",
+    authorization_stage: stage,
+    tool_call_id: request.call.id,
+    tool_name: request.call.name,
+    tool_params: request.call.params,
+    active_tools: request.activeTools,
+    activated_skills: request.activatedSkills
+  })
+});
+var authorizationError = (error) => AuthorizationError.make({ message: error.message, cause: error });
+var approvalRequired = (request) => {
+  const needsApproval = request.tool?.needsApproval;
+  if (needsApproval === undefined)
+    return Effect16.succeed(false);
+  if (typeof needsApproval === "boolean")
+    return Effect16.succeed(needsApproval);
+  return Effect16.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)));
+};
+var evaluationRequest = (request) => ({
+  tool: request.call.name,
+  params: request.call.params,
+  agentName: request.execution.agentName,
+  turn: request.execution.turn,
+  toolCallId: request.call.id,
+  sessionId: request.execution.sessionId
+});
+var rememberedDecision = (request, ruleStore) => ruleStore?.rules === undefined ? Effect16.succeedNone : ruleStore.rules.pipe(Effect16.map((rules) => {
+  if (rules.length === 0)
+    return Option10.none();
+  const matched = matchRule({ rules }, request.call.name, request.call.params);
+  if (Option10.isNone(matched))
+    return Option10.none();
+  switch (matched.value.level) {
+    case "allow":
+      return Option10.some({ _tag: "Allow" });
+    case "deny":
+      return Option10.some({
+        _tag: "Deny",
+        ...matched.value.reason === undefined ? {} : { reason: matched.value.reason }
+      });
+    case "ask":
+      return Option10.some({ _tag: "Ask", token: `permission:${request.call.id}` });
+  }
+}), Effect16.mapError(authorizationError));
+var resolveRequiredApproval = (request, approvals) => Effect16.gen(function* () {
+  yield* request.onApprovalRequired;
+  if (approvals === undefined)
+    return deny("Approvals service is required for approval-gated tools");
+  const decision2 = yield* approvals.check(request.execution);
+  switch (decision2._tag) {
+    case "Approved":
+      return { _tag: "Execute" };
+    case "Denied":
+      return deny(decision2.reason ?? "Tool call denied");
+    case "Pending":
+      return suspension(request, decision2.token, "approval");
+  }
+});
+var finalApproval = (request, approvals) => approvalRequired(request).pipe(Effect16.flatMap((required) => {
+  if (!required)
+    return Effect16.succeed({ _tag: "Execute" });
+  return resolveRequiredApproval(request, approvals);
+}));
+var make4 = (options = {}) => ({
+  authorize: (request) => Effect16.gen(function* () {
+    if (!request.active || request.tool === undefined) {
+      return deny(`Tool ${request.call.name} is not active for turn ${request.execution.turn}`);
+    }
+    if (request.authorizationStage === "approval") {
+      return yield* resolveRequiredApproval(request, options.approvals);
+    }
+    const remembered = yield* rememberedDecision(request, options.ruleStore);
+    if (Option10.isSome(remembered) && remembered.value._tag === "Deny") {
+      return deny(remembered.value.reason ?? "Permission denied");
+    }
+    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));
+        if (current2._tag === "Deny")
+          return deny(current2.reason ?? "Permission denied");
+      }
+      yield* request.onApprovalRequired;
+      if (options.permissions === undefined)
+        return suspension(request, token, "permission");
+      const answer2 = yield* options.permissions.await({
+        token,
+        tool: request.call.name,
+        params: request.call.params,
+        agentName: request.execution.agentName,
+        turn: request.execution.turn,
+        toolCallId: request.call.id
+      }).pipe(Effect16.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));
+      }
+      return yield* finalApproval(request, options.approvals);
+    }
+    if (options.permissions === undefined) {
+      if (Option10.isSome(remembered) && remembered.value._tag === "Ask") {
+        yield* request.onApprovalRequired;
+        return suspension(request, remembered.value.token, "permission");
+      }
+      return yield* finalApproval(request, options.approvals);
+    }
+    const permissions = options.permissions;
+    const current = yield* permissions.evaluate(evaluationRequest(request)).pipe(Effect16.mapError(authorizationError));
+    if (current._tag === "Deny")
+      return deny(current.reason ?? "Permission denied");
+    if (current._tag !== "Ask" || Option10.isSome(remembered) && remembered.value._tag === "Allow") {
+      return yield* finalApproval(request, options.approvals);
+    }
+    const pending = {
+      token: current.token,
+      tool: request.call.name,
+      params: request.call.params,
+      agentName: request.execution.agentName,
+      turn: request.execution.turn,
+      toolCallId: request.call.id
+    };
+    yield* request.onApprovalRequired;
+    const answer = yield* permissions.await(pending).pipe(Effect16.mapError(authorizationError));
+    if (Option10.isNone(answer))
+      return suspension(request, current.token, "permission");
+    switch (answer.value._tag) {
+      case "Denied":
+        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));
+        }
+        return yield* finalApproval(request, options.approvals);
+      case "Approved":
+        return yield* finalApproval(request, options.approvals);
+    }
+  })
+});
+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.1/node_modules/@batonfx/core/dist/tool-registry.js
+import { Effect as Effect17, 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";
+var makeToolkit = (entries) => {
+  const toolkit = Toolkit3.make(...entries.map((candidate) => candidate.tool));
+  for (const entry of entries) {
+    if (!Object.hasOwn(toolkit.tools, entry.tool.name)) {
+      Object.defineProperty(toolkit.tools, entry.tool.name, {
+        configurable: true,
+        enumerable: true,
+        value: entry.tool,
+        writable: true
+      });
+    }
+  }
+  return toolkit;
+};
+var assemble = (candidates) => {
+  const grouped = new Map;
+  for (const candidate of candidates) {
+    const existing = grouped.get(candidate.tool.name);
+    if (existing === undefined)
+      grouped.set(candidate.tool.name, [candidate]);
+    else
+      existing.push(candidate);
+  }
+  for (const candidate of candidates) {
+    const conflicts = grouped.get(candidate.tool.name);
+    if (conflicts !== undefined && conflicts.length > 1) {
+      return Effect17.fail(ToolNameCollision.make({
+        name: candidate.tool.name,
+        origins: [conflicts[0].origin, ...conflicts.slice(1).map((conflict) => conflict.origin)]
+      }));
+    }
+  }
+  const entries = [...candidates];
+  return Effect17.succeed({
+    entries,
+    byName: HashMap3.fromIterable(entries.map((candidate) => [candidate.tool.name, candidate])),
+    toolkit: makeToolkit(entries)
+  });
+};
+var get = dual6(2, (registry, name) => Option11.getOrUndefined(HashMap3.get(registry.byName, name)));
+var select = dual6(2, (registry, names) => {
+  const entries = registry.entries.filter((entry) => names.includes(entry.tool.name));
+  return {
+    entries,
+    byName: HashMap3.fromIterable(entries.map((candidate) => [candidate.tool.name, candidate])),
+    toolkit: makeToolkit(entries)
+  };
+});
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/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.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.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.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
+});
+var persistenceLocks = new WeakMap;
+var reservePersistedChatLock = (persistence, chatId) => {
+  const locks = persistenceLocks.get(persistence) ?? new Map;
+  if (!persistenceLocks.has(persistence))
+    persistenceLocks.set(persistence, locks);
+  const existing = locks.get(chatId);
+  if (existing !== undefined) {
+    existing.users += 1;
+    return existing;
+  }
+  const created = { semaphore: Semaphore2.makeUnsafe(1), users: 1 };
+  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"])),
+  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)
+    return;
+  const locks = persistenceLocks.get(persistence);
+  if (locks?.get(chatId) !== lock)
+    return;
+  locks.delete(chatId);
+  if (locks.size === 0)
+    persistenceLocks.delete(persistence);
+};
+var unresolvedToolCall = (messages) => {
+  const unpaired = new Map;
+  const ambiguous = new Set;
+  for (const [messageIndex, message] of messages.entries()) {
+    if (typeof message.content === "string")
+      continue;
+    for (const [partIndex, part] of message.content.entries()) {
+      if (part.type === "tool-call") {
+        const occurrences = unpaired.get(part.id) ?? [];
+        if (!part.providerExecuted && occurrences.some(({ call }) => !call.providerExecuted))
+          ambiguous.add(part.id);
+        occurrences.push({ call: part, messageIndex, partIndex });
+        unpaired.set(part.id, occurrences);
+      }
+      if (part.type === "tool-result") {
+        const occurrences = unpaired.get(part.id);
+        if (occurrences === undefined)
+          continue;
+        const matched = occurrences.findLastIndex(({ call }) => call.name === part.name);
+        if (matched !== -1)
+          occurrences.splice(matched, 1);
+        if (occurrences.length === 0) {
+          unpaired.delete(part.id);
+          ambiguous.delete(part.id);
+        }
+      }
+    }
+  }
+  const unresolved = [...unpaired.entries()].flatMap(([id, occurrences]) => ambiguous.has(id) ? [] : occurrences.filter(({ call }) => !call.providerExecuted));
+  const pending = unresolved[0];
+  return unresolved.length === 1 && pending !== undefined ? {
+    call: pending.call,
+    messages: messages.slice(0, pending.messageIndex),
+    messageIndex: pending.messageIndex,
+    partIndex: pending.partIndex
+  } : undefined;
+};
+var suspensionCheckpoint = (messages) => {
+  const unresolved = unresolvedToolCall(messages);
+  if (unresolved === undefined)
+    return;
+  const metadata = Schema14.decodeUnknownOption(suspensionMetadata)(unresolved.call.options[suspensionCheckpointOption]);
+  if (Option12.isNone(metadata))
+    return;
+  return {
+    call: unresolved.call,
+    messages: unresolved.messages,
+    suspension: AgentSuspended.make({
+      ...metadata.value,
+      tool_call_id: unresolved.call.id,
+      tool_name: unresolved.call.name,
+      tool_params: unresolved.call.params
+    })
+  };
+};
+var sameSuspension = (left, right) => left.token === right.token && left.reason === right.reason && left.authorization_stage === right.authorization_stage && 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 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({
+  id: call.id,
+  name: call.name,
+  isFailure: false,
+  result: outcome.result,
+  encodedResult: outcome.encodedResult,
+  providerExecuted: false,
+  preliminary: false
+});
+var domainFailureResult = (call, outcome) => Response7.toolResultPart({
+  id: call.id,
+  name: call.name,
+  isFailure: true,
+  result: outcome.failure,
+  encodedResult: outcome.encodedFailure,
+  providerExecuted: false,
+  preliminary: false
+});
+var suspended = (call, token, reason) => AgentSuspended.make({
+  token,
+  reason,
+  tool_call_id: call.id,
+  tool_name: call.name,
+  tool_params: call.params
+});
+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));
+};
+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 streamInternal = (agent, options, structured) => Stream4.unwrap(Effect18.gen(function* () {
+  if (options.history !== undefined && options.persistence !== undefined) {
+    return yield* AgentError.make({
+      message: "RunOptions.history and RunOptions.persistence are mutually exclusive",
+      turn: 0
+    });
+  }
+  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({
+      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), {
+        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({
+        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* () {
+      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))
+        return;
+      recoveredHistory = buildContext(path);
+    }).pipe(Effect18.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));
+    const received = resume.suspension;
+    const resumeHistory = recoveredHistory ?? (yield* Ref5.get(resumeChat.history));
+    validatedResume = yield* Effect18.succeed(resumeHistory).pipe(Effect18.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({
+        reason: "identity-mismatch",
+        expected: expected.suspension,
+        received
+      });
+    }));
+    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 })));
+    }
+  }
+  const staticCandidates = (agent.toolDeclarations ?? Object.values(agent.toolkit.tools).map((tool) => ({
+    tool,
+    origin: { _tag: "Static", agent: agent.name }
+  }))).map(({ origin, tool }) => ({
+    origin,
+    tool,
+    dispatch: "Static"
+  }));
+  const staticRegistry = yield* assemble(staticCandidates);
+  const staticToolkit = staticRegistry.toolkit;
+  if (agent.toolDeclarations !== undefined && (agent.toolDeclarations.length !== Object.keys(agent.toolkit.tools).length || agent.toolDeclarations.some((declaration) => agent.toolkit.tools[declaration.tool.name] !== declaration.tool))) {
+    return yield* AgentError.make({
+      message: "Agent tool declarations and toolkit must contain the same tool instances",
+      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 })));
+  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)) {
+    return yield* AgentError.make({
+      message: "RunOptions.toolProgress must select a supported policy with a positive safe-integer capacity",
+      turn: 0
+    });
+  }
+  const progressPolicy = decodedProgressPolicy.value;
+  if (options.compaction?.contextWindow !== undefined && (!Number.isFinite(options.compaction.contextWindow) || options.compaction.contextWindow <= 0)) {
+    return yield* AgentError.make({
+      message: "RunOptions.compaction.contextWindow must be a positive finite number",
+      turn: 0
+    });
+  }
+  const sessionId = options.sessionId ?? "local";
+  const instructionsService = yield* Effect18.serviceOption(Instructions);
+  const skillSourceService = yield* Effect18.serviceOption(SkillSource);
+  const skillRuntime = Option12.isNone(skillSourceService) ? undefined : {
+    source: skillSourceService.value,
+    skills: yield* skillSourceService.value.all.pipe(Effect18.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(`
+`);
+  const hasActivatableSkills = selectedSkills.length > 0;
+  const initialRegistry = yield* assemble([
+    ...staticCandidates,
+    ...hasActivatableSkills ? [
+      {
+        tool: activateSkillTool,
+        origin: { _tag: "Builtin", builtin: "activate_skill" },
+        dispatch: "Builtin"
+      }
+    ] : []
+  ]);
+  const instructionsEpoch = options.system === undefined && options.history === undefined && Option12.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 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({
+      message: "Agent.model requires ModelRegistry in context",
+      turn: 0
+    })),
+    onSome: Effect18.succeed
+  });
+  const memoryRuntime = memoryOptions === undefined ? undefined : {
+    key: memoryOptions.key,
+    service: yield* Option12.match(memoryService, {
+      onNone: () => Effect18.fail(AgentError.make({
+        message: options.memory === undefined ? "Agent.memory requires Memory in context" : "RunOptions.memory requires Memory in context",
+        turn: 0
+      })),
+      onSome: Effect18.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 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 withPending = yield* appendPending(turn, pending);
+    const unresolved = unresolvedToolCall(withPending.content);
+    if (unresolved === undefined || unresolved.call.id !== suspension2.tool_call_id || unresolved.call.name !== suspension2.tool_name || !Equal.equals(unresolved.call.params, suspension2.tool_params)) {
+      return yield* AgentError.make({
+        message: "Suspension does not match the unresolved checkpoint call",
+        turn
+      });
+    }
+    const metadata = {
+      token: suspension2.token,
+      reason: suspension2.reason,
+      ...suspension2.authorization_stage === undefined ? {} : { authorization_stage: suspension2.authorization_stage },
+      ...suspension2.active_tools === undefined ? {} : { active_tools: suspension2.active_tools },
+      ...suspension2.activated_skills === undefined ? {} : { activated_skills: suspension2.activated_skills }
+    };
+    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", {
+          id: part.id,
+          name: part.name,
+          params: part.params,
+          providerExecuted: part.providerExecuted,
+          options: { ...part.options, [suspensionCheckpointOption]: metadata }
+        }) : part),
+        options: message.options
+      });
+    });
+    const checkpoint = Prompt9.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* savePersisted(turn);
+    return yield* Ref5.get(chat.history);
+  });
+  const checkpointPending = (turn, pending) => appendPending(turn, pending).pipe(Effect18.tap((checkpoint) => syncSession(turn, checkpoint)));
+  const failSuspended = (call, token, reason) => Stream4.fail(suspended(call, token, reason));
+  const state = {
+    text: "",
+    turn: 0,
+    pending: [],
+    finish: undefined,
+    usage: undefined
+  };
+  const toolState = yield* Ref5.make({
+    registry: initialRegistry,
+    activatedSkillBodies: new Map
+  });
+  const restoreActivatedSkills = (history) => Effect18.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))
+          continue;
+        if (skillRuntime === undefined) {
+          return yield* AgentError.make({
+            message: "Resuming activated skill tools requires SkillSource in context",
+            turn: 0
+          });
+        }
+        const skill = yield* skillRuntime.source.get(activation.value.name);
+        if (skill === undefined) {
+          return yield* AgentError.make({
+            message: `Skill not found while restoring resume state: ${activation.value.name}`,
+            turn: 0
+          });
+        }
+        const current = yield* Ref5.get(toolState);
+        if (current.activatedSkillBodies.has(skill.frontmatter.name))
+          continue;
+        const registry = yield* assemble([
+          ...current.registry.entries,
+          ...skill.tools.map((tool) => ({
+            tool,
+            origin: { _tag: "Skill", skill: skill.frontmatter.name },
+            dispatch: "Skill"
+          }))
+        ]);
+        const activatedSkillBodies = new Map(current.activatedSkillBodies);
+        activatedSkillBodies.set(skill.frontmatter.name, activation.value.body);
+        yield* Ref5.set(toolState, { registry, activatedSkillBodies });
+      }
+    }
+  }).pipe(Effect18.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();
+  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 });
+  const skillError = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
+  const isSkillActivationCall = (call, registry) => get(registry, call.name)?.dispatch === "Builtin" && skillRuntime !== undefined;
+  const insertRecalledItems = (prompt, items) => {
+    const content = items.flatMap((item) => item.content);
+    if (content.length === 0)
+      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]);
+  };
+  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({
+    key: memoryRuntime.key,
+    turn,
+    transcript: Option12.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);
+  const sessionTranscriptCursor = (projection, transcript) => {
+    if (projection.length === 0)
+      return Option12.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();
+  };
+  const syncSession = (turn, transcript) => Option12.match(activeSession, {
+    onNone: () => Effect18.succeed([]),
+    onSome: (session) => Effect18.gen(function* () {
+      let path = yield* session.path();
+      const projection = buildContext(path);
+      const cursor = sessionTranscriptCursor(projection.content, transcript.content);
+      if (Option12.isNone(cursor)) {
+        const checkpoint = path.at(-1);
+        const before = buildContext(path.slice(0, -1));
+        if (checkpoint?._tag === "Compaction" && checkpoint.version === 2 && promptEquivalence2(before, transcript)) {
+          yield* Ref5.set(chat.history, projection);
+          yield* savePersisted(turn);
+          return path;
+        }
+        return yield* AgentError.make({
+          message: "Session projection is not a prefix of authoritative Chat history",
+          turn
+        });
+      }
+      let expectedLeafId = path.at(-1)?.id ?? null;
+      for (const message of transcript.content.slice(cursor.value)) {
+        const appended = yield* session.append({ _tag: "Message", message }, { expectedLeafId });
+        expectedLeafId = appended.id;
+      }
+      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)))
+  });
+  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 compactionUsage = (turn, history, prompt) => countTokens(turn, Prompt9.concat(history, prompt)).pipe(Effect18.map((contextTokens) => ({
+    contextTokens,
+    contextWindow: options.compaction?.contextWindow ?? Number.POSITIVE_INFINITY,
+    reserveTokens: DEFAULT_RESERVE_TOKENS
+  })));
+  const validateCompactionProjection = (turn, result) => {
+    const pending = new Set;
+    const optional = new Set;
+    for (const message of Prompt9.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 }));
+        }
+        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 }));
+      }
+      if (!hasResult)
+        optional.clear();
+      const responseCalls = new Set;
+      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 }));
+          }
+          responseCalls.add(part.id);
+          if (part.providerExecuted)
+            optional.add(part.id);
+          else
+            pending.add(part.id);
+        }
+        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 pending.size === 0 ? Effect18.void : Effect18.fail(AgentError.make({ message: "Compaction projection contains an unresolved tool call", turn }));
+  };
+  const applyCompactionResult = (turn, result, parentId) => Option12.match(activeSession, {
+    onNone: () => Ref5.set(chat.history, result.history),
+    onSome: (session) => Effect18.gen(function* () {
+      const id = yield* session.reserveEntryId;
+      yield* Effect18.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)))
+  });
+  const preparePrompt = (turn, prompt, overflow) => Option12.match(compactionService, {
+    onNone: () => Effect18.succeed({ prompt, changed: false }),
+    onSome: (compaction) => Effect18.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 compacted = yield* compaction.maybeCompact({
+        agentName: agent.name,
+        sessionId,
+        turn,
+        history: detachedHistory,
+        prompt: detachedPrompt,
+        path: detachedPath,
+        usage,
+        overflow,
+        ...options.toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes: options.toolOutputMaxBytes }
+      }).pipe(Effect18.mapError((error) => compactionError(turn, error)));
+      if (Option12.isNone(compacted))
+        return { prompt, changed: false };
+      const changed = !Equal.equals(originalHistory.content, compacted.value.history.content) || !Equal.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))) {
+        return yield* MiddlewareViolation.make({
+          turn,
+          detail: "Compaction must preserve recalled-memory message lineage outside the lossless Session path"
+        });
+      }
+      yield* validateCompactionProjection(turn, compacted.value);
+      yield* applyCompactionResult(turn, compacted.value, path.at(-1)?.id ?? null);
+      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 outcomeEvents = (turn, 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) => {
+          state.pending.push(result);
+          return Stream4.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result, ...metadata }]);
+        }));
+      case "DomainFailure": {
+        const result = domainFailureResult(call, outcome);
+        state.pending.push(result);
+        return Effect18.succeed(Stream4.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result, ...metadata }]));
+      }
+      case "Suspend":
+        return Effect18.succeed(failSuspended(call, outcome.token, "tool-wait"));
+    }
+  };
+  const defaultExecute = (request, registry) => {
+    const registered = get(registry, request.call.name);
+    if (registered?.dispatch === "Static") {
+      return executeToolkit(staticToolkit, request);
+    }
+    return registered === undefined ? Effect18.fail(FrameworkFailure.make({
+      stage: "missing-handler",
+      tool: request.call.name,
+      message: `Tool ${request.call.name} is not registered`
+    })) : Effect18.fail(FrameworkFailure.make({
+      stage: "missing-handler",
+      tool: request.call.name,
+      message: `Activated skill tool ${request.call.name} requires ToolExecutor`
+    }));
+  };
+  const makeProgressQueue = () => {
+    switch (progressPolicy._tag) {
+      case "Backpressure":
+        return Queue2.bounded(progressPolicy.capacity);
+      case "Dropping":
+      case "Fail":
+        return Queue2.dropping(progressPolicy.capacity);
+      case "Sliding":
+        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 droppedProgress = yield* Ref5.make(0);
+    const emitSemaphore = yield* Semaphore2.make(1);
+    const signal = yield* Effect18.abortSignal;
+    const context = ToolContext.of({
+      signal,
+      sessionId,
+      emit: (progress) => {
+        const event = {
+          _tag: "ToolProgress",
+          turn,
+          toolCallId: progress.toolCallId,
+          ...progress.message === undefined ? {} : { message: progress.message },
+          ...progress.data === undefined ? {} : { data: progress.data }
+        };
+        return emitSemaphore.withPermit(Effect18.gen(function* () {
+          if (progressPolicy._tag === "Sliding") {
+            const dropped = yield* Effect18.sync(() => {
+              const full = Queue2.isFullUnsafe(progressQueue);
+              Queue2.offerUnsafe(progressQueue, event);
+              return full;
+            });
+            if (dropped)
+              yield* Ref5.update(droppedProgress, (count) => count + 1);
+            return;
+          }
+          const offered = yield* Queue2.offer(progressQueue, event);
+          if (progressPolicy._tag === "Dropping" && !offered) {
+            yield* Ref5.update(droppedProgress, (count) => count + 1);
+          } else if (progressPolicy._tag === "Fail" && !offered) {
+            yield* Queue2.fail(progressQueue, ProgressOverflowError.make({ turn, toolCallId: call.id, capacity: progressPolicy.capacity }));
+          }
+        }));
+      }
+    });
+    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, call, outcome, dropped, registry)))))));
+  })));
+  const activateSkillOutcome = (turn, call) => Effect18.gen(function* () {
+    if (skillRuntime === undefined) {
+      return yield* FrameworkFailure.make({
+        stage: "missing-handler",
+        tool: call.name,
+        message: "SkillSource is not available"
+      });
+    }
+    const params = Schema14.decodeUnknownOption(activateSkillParameters)(call.params);
+    if (Option12.isNone(params)) {
+      return yield* FrameworkFailure.make({
+        stage: "decode-input",
+        tool: call.name,
+        message: "Skill activation requires a name"
+      });
+    }
+    const skill = yield* skillRuntime.source.get(params.value.name);
+    if (skill === undefined) {
+      const failure2 = { reason: "not-found", message: `Skill not found: ${params.value.name}` };
+      return { _tag: "DomainFailure", failure: failure2, encodedFailure: failure2 };
+    }
+    if (skill.frontmatter.disableModelInvocation === true) {
+      const failure2 = {
+        reason: "not-model-invocable",
+        message: `Skill is not model-invocable: ${params.value.name}`
+      };
+      return { _tag: "DomainFailure", failure: failure2, encodedFailure: failure2 };
+    }
+    const current = yield* Ref5.get(toolState);
+    let body = current.activatedSkillBodies.get(skill.frontmatter.name);
+    if (body === undefined) {
+      const registry = yield* assemble([
+        ...current.registry.entries,
+        ...skill.tools.map((tool) => ({
+          tool,
+          origin: { _tag: "Skill", skill: skill.frontmatter.name },
+          dispatch: "Skill"
+        }))
+      ]);
+      body = yield* skill.body;
+      const activatedSkillBodies = new Map(current.activatedSkillBodies);
+      activatedSkillBodies.set(skill.frontmatter.name, body);
+      yield* Ref5.set(toolState, { registry, activatedSkillBodies });
+    }
+    const output = {
+      name: skill.frontmatter.name,
+      body,
+      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)));
+  const authorizationError2 = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
+  const toolCallEvents = (turn, call, messages, registry, authorizationStage, authorizationToken) => {
+    const request = { call, turn, agentName: agent.name, sessionId };
+    const candidate = get(registry, call.name);
+    if (candidate === undefined)
+      return Stream4.fail(FrameworkFailure.make({
+        stage: "authorization",
+        tool: call.name,
+        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* () {
+      const activatedSkills = [...(yield* Ref5.get(toolState)).activatedSkillBodies.keys()];
+      const approvalEvents = yield* Queue2.bounded(1);
+      const fiber = yield* authorizer.authorize({
+        call,
+        tool: candidate.tool,
+        active: true,
+        activeTools,
+        activatedSkills,
+        ...authorizationStage === undefined ? {} : { authorizationStage },
+        ...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 }));
+      return Stream4.concat(Stream4.fromQueue(approvalEvents), Stream4.fromEffect(Fiber.join(fiber)).pipe(Stream4.flatMap((decision2) => {
+        switch (decision2._tag) {
+          case "Execute":
+            return executeApproved(turn, call, request, registry);
+          case "Deny":
+            return Stream4.fail(FrameworkFailure.make({
+              stage: "authorization",
+              tool: call.name,
+              message: decision2.error.message
+            }));
+          case "Suspend":
+            return Stream4.fail(AgentSuspended.make({
+              token: decision2.suspension.token,
+              reason: "approval",
+              authorization_stage: decision2.suspension.authorization_stage ?? "approval",
+              tool_call_id: call.id,
+              tool_name: call.name,
+              tool_params: call.params,
+              active_tools: activeTools,
+              activated_skills: activatedSkills
+            }));
+        }
+      })));
+    }));
+  };
+  const captureFinishPart = (part) => Effect18.gen(function* () {
+    const span = yield* Effect18.currentSpan;
+    state.finish = {
+      usage: state.finish === undefined ? part.usage : addUsage(state.finish.usage, part.usage),
+      reason: part.reason
+    };
+    state.usage = state.usage === undefined ? part.usage : addUsage(state.usage, part.usage);
+    Telemetry.addGenAIAnnotations(span, {
+      operation: { name: "chat" },
+      usage: {
+        inputTokens: part.usage.inputTokens.total,
+        outputTokens: part.usage.outputTokens.total
+      },
+      response: { finishReasons: [part.reason] }
+    });
+  }).pipe(Effect18.orDie);
+  const captureStructuredUsage = (content) => Effect18.gen(function* () {
+    const span = yield* Effect18.currentSpan;
+    for (const part of content) {
+      if (part.type === "finish") {
+        state.usage = state.usage === undefined ? part.usage : addUsage(state.usage, part.usage);
+        Telemetry.addGenAIAnnotations(span, {
+          operation: { name: "chat" },
+          usage: {
+            inputTokens: part.usage.inputTokens.total,
+            outputTokens: part.usage.outputTokens.total
+          },
+          response: { finishReasons: [part.reason] }
+        });
+      }
+    }
+  }).pipe(Effect18.orDie);
+  const withModelResilience = (effect) => Option12.match(resilienceService, {
+    onNone: () => effect,
+    onSome: (resilience) => Effect18.flatMap(LanguageModel5.LanguageModel, (model) => effect.pipe(Effect18.provideService(LanguageModel5.LanguageModel, apply(model, {
+      ...resilience,
+      classify: (error) => classifyFailure(model, error) === "context-overflow" ? "terminal" : resilience.classify(error)
+    }))))
+  });
+  const withAgentModel = (effect) => agentModelRegistry === undefined || agentModel === undefined ? effect : agentModelRegistry.operate(agentModel, effect);
+  function provideAgentModel(stream2) {
+    return agentModelRegistry === undefined || agentModel === undefined ? stream2 : agentModelRegistry.stream(agentModel, stream2).pipe(Stream4.catchTag("LanguageModelNotRegistered", (error) => Stream4.fail(AgentError.make({ message: errorMessage(error), turn: state.turn, cause: error }))));
+  }
+  const partEvents = (turn, part, messages, registry) => {
+    if (part.type === "error") {
+      if (isToolNameCollision(part.error))
+        return Stream4.fail(part.error);
+      return Stream4.fail(AgentError.make({ message: errorMessage(part.error), turn, cause: part.error }));
+    }
+    const modelPart = Stream4.fromIterable([{ _tag: "ModelPart", turn, part }]);
+    if (part.type === "tool-call") {
+      const call = part;
+      return call.providerExecuted === true ? modelPart : Stream4.concat(modelPart, toolCallEvents(turn, call, messages, registry));
+    }
+    if (part.type === "text-delta") {
+      state.text = `${state.text}${part.delta}`;
+    }
+    if (part.type === "finish") {
+      return modelPart.pipe(Stream4.tap(() => captureFinishPart(part)));
+    }
+    return modelPart;
+  };
+  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({
+      turn,
+      detail: "ModelMiddleware dropped a tool-call part"
+    })) : Effect18.succeed(Option12.none())
+  })));
+  const validateToolCallId = (idState, part) => {
+    if (part.type !== "tool-call")
+      return Effect18.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 }));
+      return [
+        duplicate,
+        {
+          nextIndex: current.nextIndex + 1,
+          firstIndexes: Option12.isSome(existingFirstIndex) ? current.firstIndexes : HashMap4.set(current.firstIndexes, part.id, current.nextIndex)
+        }
+      ];
+    }).pipe(Effect18.flatMap(Option12.match({
+      onNone: () => Effect18.void,
+      onSome: Effect18.fail
+    })));
+  };
+  const modelTurn = (turn, prompt, registry, overrides) => {
+    const activeRegistry = overrides?.activeTools === undefined ? registry : select(registry, overrides.activeTools);
+    const attempt = (activePrompt, retryOverflow, compactOverflow = false, overflowCause) => {
+      let emitted = false;
+      let classifyFailure2 = classifyOtherFailure;
+      const transformedParts = new Array;
+      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();
+      };
+      const retryableOverflow = (cause, hasEmitted) => {
+        const failure2 = singleFailure(cause);
+        return retryOverflow && !hasEmitted && Option12.isSome(failure2) && classifyFailure2(failure2.value) === "context-overflow" && Option12.isSome(compactionService);
+      };
+      return Stream4.fromChannel(Channel.acquireUseRelease(Ref5.make({
+        nextIndex: 0,
+        firstIndexes: HashMap4.empty()
+      }), (toolCallIds) => Stream4.unwrap(Effect18.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);
+        }
+        const preparedPrompt = prepared.prompt;
+        const history = yield* Ref5.get(chat.history);
+        preparedState = { history, preparedPrompt };
+        const responsePrompt = Prompt9.concat(history, preparedPrompt);
+        const messages = responsePrompt.content;
+        const rawParts = LanguageModel5.streamText({
+          prompt: responsePrompt,
+          toolkit: activeRegistry.toolkit,
+          disableToolCallResolution: true
+        }).pipe(Stream4.tap(() => Effect18.sync(() => {
+          emitted = true;
+        })), Stream4.catchCause((cause) => {
+          if (Cause4.hasInterrupts(cause) || Cause4.hasDies(cause))
+            return Stream4.failCause(cause);
+          if (retryableOverflow(cause, emitted))
+            return Stream4.failCause(cause);
+          const error = singleFailure(cause);
+          if (Option12.isNone(error))
+            return Stream4.failCause(cause);
+          return Stream4.make(Response7.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) => ({
+          part,
+          messages,
+          accept: validateToolCallId(toolCallIds, part).pipe(Effect18.andThen(Effect18.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) => {
+        if (Cause4.hasInterrupts(cause) || Cause4.hasDies(cause))
+          return Stream4.failCause(cause);
+        if (retryableOverflow(cause, emitted)) {
+          return attempt(preparedState?.preparedPrompt ?? activePrompt, false, true, cause);
+        }
+        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);
+      }));
+    };
+    const parts = Stream4.unwrap(applyPromptChain(chain, Prompt9.make(prompt), { agentName: agent.name, turn }).pipe(Effect18.map((transformedPrompt) => attempt(transformedPrompt, true).pipe(Stream4.flatMap(({ accept, part, messages }) => Stream4.fromEffect(accept).pipe(Stream4.flatMap(() => partEvents(turn, part, messages, activeRegistry))))))));
+    const resilientParts = Option12.match(resilienceService, {
+      onNone: () => parts,
+      onSome: (resilience) => Stream4.unwrap(LanguageModel5.LanguageModel.pipe(Effect18.map((model) => parts.pipe(Stream4.provideService(LanguageModel5.LanguageModel, apply(model, {
+        ...resilience,
+        classify: (error) => classifyFailure(model, error) === "context-overflow" ? "terminal" : resilience.classify(error)
+      }))))))
+    });
+    return overrides?.model === undefined ? provideAgentModel(resilientParts) : resilientParts.pipe(Stream4.provide(overrides.model));
+  };
+  const turnCompletedEvent = (turn, transcript) => ({
+    _tag: "TurnCompleted",
+    turn,
+    transcript,
+    ...state.finish === undefined ? {} : { usage: state.finish.usage, finishReason: state.finish.reason }
+  });
+  const terminalCompletedEvent = (turn, transcript) => ({
+    _tag: "Completed",
+    turns: turn + 1,
+    text: state.text,
+    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), {
+      agentName: agent.name,
+      turn: structuredTurn
+    });
+    const history = yield* Ref5.get(chat.history);
+    const response = yield* LanguageModel5.generateObject({
+      prompt: Prompt9.concat(history, transformedPrompt),
+      schema: config.schema,
+      objectName: config.objectName,
+      toolChoice: "none"
+    }).pipe(withModelResilience, withAgentModel, Effect18.catchCause((cause) => {
+      const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
+      return reason !== undefined && Cause4.isFailReason(reason) ? Effect18.fail(AgentError.make({
+        message: errorMessage(reason.error),
+        turn: structuredTurn,
+        cause: reason.error
+      })) : Effect18.failCause(cause);
+    }));
+    yield* captureStructuredUsage(response.content);
+    const transcript = Prompt9.concat(Prompt9.concat(history, transformedPrompt), Prompt9.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* savePersisted(structuredTurn);
+    const structuredOutput = {
+      _tag: "StructuredOutput",
+      turn: structuredTurn,
+      value: response.value,
+      content: response.content
+    };
+    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([]),
+    onSome: (service) => service.takeSteering
+  });
+  const takeFollowUp = () => Option12.match(steeringService, {
+    onNone: () => Effect18.succeed([]),
+    onSome: (service) => service.takeFollowUp
+  });
+  const afterTurn = (turn) => Effect18.gen(function* () {
+    const pending = state.pending;
+    const transcript = yield* checkpointPending(turn, pending);
+    const path = yield* syncSession(turn, transcript);
+    yield* rememberTurn(turn, transcript, pending.length === 0, path);
+    const completed = turnCompletedEvent(turn, transcript);
+    if (pending.length === 0) {
+      const followUp = yield* takeFollowUp();
+      if (followUp.length > 0) {
+        return {
+          events: Stream4.fromIterable([completed, steeringDrainedEvent(turn, "followUp", followUp)]),
+          next: { prompt: promptFromSteeringMessages(followUp) }
+        };
+      }
+      if (structured !== undefined) {
+        return {
+          events: Stream4.fromIterable([completed]),
+          structuredTurn: turn + 1
+        };
+      }
+      yield* savePersisted(turn);
+      return {
+        events: Stream4.fromIterable([completed, terminalCompletedEvent(turn, transcript)])
+      };
+    }
+    const evaluated = yield* agent.policy.decide({
+      turn: turn + 1,
+      history: transcript,
+      pendingToolResults: pending
+    });
+    if (!isTurnPolicyDecision(evaluated)) {
+      return yield* TurnPolicyError.make({
+        message: "TurnPolicy returned an invalid decision; reasonless Stop decisions must be adapted with TurnPolicy.fromLegacy",
+        cause: evaluated
+      });
+    }
+    const decision2 = evaluated;
+    if (decision2._tag === "Stop") {
+      const pendingCalls = pending.map((result) => ({
+        tool_call_id: result.id,
+        tool_name: result.name
+      }));
+      return {
+        events: Stream4.concat(Stream4.fromIterable([completed]), Stream4.fail(decision2.reason._tag === "TurnLimit" ? TurnLimitExceeded.make({
+          turn: turn + 1,
+          limit: decision2.reason.limit,
+          pending: pendingCalls
+        }) : TurnPolicyStopped.make({
+          turn: turn + 1,
+          reason: decision2.reason,
+          pending: pendingCalls
+        })))
+      };
+    }
+    state.pending = [];
+    const steering = yield* takeSteering();
+    const basePrompt = steering.length === 0 ? Prompt9.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)]),
+      next: { prompt, ...decision2.overrides === undefined ? {} : { overrides: decision2.overrides } }
+    };
+  });
+  const resetTurnState = (turn) => Stream4.sync(() => {
+    state.turn = turn;
+    state.finish = undefined;
+  }).pipe(Stream4.drain);
+  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) => {
+      next = result.next;
+      structuredTurn = result.structuredTurn;
+      return result.events;
+    })))), Stream4.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": turn } }));
+    return Stream4.concat(currentTurn, Stream4.suspend(() => {
+      if (structuredTurn !== undefined && structured !== undefined) {
+        return structuredFinalEvents(structuredTurn, structured).pipe(Stream4.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": structuredTurn } }));
+      }
+      return next === undefined ? Stream4.empty : runTurn(turn + 1, next.prompt, next.overrides);
+    }));
+  };
+  const resumeStream = (checkpoint) => {
+    let next;
+    const currentTurn = resetTurnState(0).pipe(Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect18.map((tools) => {
+      const suspension2 = checkpoint.suspension;
+      const registry = suspension2.authorization_stage === undefined && suspension2.active_tools === undefined ? tools.registry : select(tools.registry, suspension2.active_tools ?? []);
+      return toolCallEvents(0, Response7.makePart("tool-call", {
+        id: checkpoint.call.id,
+        name: checkpoint.call.name,
+        params: checkpoint.call.params,
+        providerExecuted: false
+      }), checkpoint.messages, registry, suspension2.authorization_stage, suspension2.token);
+    })))), Stream4.concat(Stream4.unwrap(afterTurn(0).pipe(Effect18.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 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) && Schema14.is(AgentSuspended)(reason.error)) {
+      const suspension2 = reason.error;
+      return Stream4.unwrap(Effect18.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));
+      }));
+    }
+    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])));
+var provideModel = dual7(2, (agent, layer8) => ({
+  ...agent,
+  policy: agent.policy,
+  ...agent.authorization === undefined ? {} : {
+    authorization: agent.authorization
+  },
+  [AgentTypeId]: {
+    tools: (value) => value,
+    requirements: (value) => value
+  },
+  [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, {
+  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({
+      text: event.text,
+      turns: event.turns,
+      transcript: event.transcript,
+      value: typedValue
+    })
+  })
+}))));
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/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 });
+var errorMessage2 = (error) => {
+  if (Schema15.is(AgentSuspended)(error)) {
+    return `suspended on ${error.tool_name}: ${error.reason}`;
+  }
+  if (Schema15.is(AgentError)(error)) {
+    return `failed on turn ${error.turn}: ${error.message}`;
+  }
+  if (Schema15.is(ResumeMismatch)(error)) {
+    return `resume mismatch: ${error.reason}`;
+  }
+  if (Schema15.is(TurnLimitExceeded)(error)) {
+    return `turn limit exceeded at turn ${error.turn}`;
+  }
+  if (Schema15.is(TurnPolicyStopped)(error)) {
+    return `policy stopped at turn ${error.turn}: ${error.reason._tag}`;
+  }
+  if (Schema15.is(TurnPolicyError)(error)) {
+    return `turn policy failed: ${error.message}`;
+  }
+  if (Schema15.is(MiddlewareViolation)(error)) {
+    return `middleware violation on turn ${error.turn}: ${error.detail}`;
+  }
+  if (Schema15.is(DuplicateToolCallId)(error)) {
+    return `duplicate tool-call ID '${error.id}' at position ${error.duplicateIndex} (first at ${error.firstIndex})`;
+  }
+  if (Schema15.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);
+};
+var causeMessage = (agentName, cause) => `sub-agent '${agentName}' could not complete: ${errorMessage2(Cause5.squash(cause))}`;
+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)))
+});
+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 toPrompt = options.toPrompt ?? ((params) => params.prompt);
+  const fromResult = options.fromResult ?? ((result) => result.text);
+  const tool = Tool8.make(name, {
+    ...options.description === undefined ? {} : { description: options.description },
+    parameters,
+    success: success2,
+    failure: Schema15.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) => {
+      if (Cause5.hasInterrupts(cause))
+        return Effect19.interrupt;
+      return Effect19.fail(causeMessage(agent.name, cause));
+    }));
+    return yield* Effect19.try({ try: () => fromResult(result), catch: errorMessage2 });
+  });
+  return lazyHandled(toolkit, name, handler);
+});
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/node_modules/@batonfx/core/dist/guardrail.js
+var exports_guardrail = {};
+__export(exports_guardrail, {
+  validateInput: () => validateInput,
+  redactOutput: () => redactOutput,
+  redactInput: () => redactInput,
+  filterOutput: () => filterOutput
+});
+import { Effect as Effect20, Option as Option13 } from "effect";
+import { Prompt as Prompt11, Response as Response8 } 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 redactAssistantPart = (part, options) => {
+  switch (part.type) {
+    case "text":
+      return Prompt11.makePart("text", { text: redactText(part.text, options), options: part.options });
+    case "reasoning":
+      return Prompt11.makePart("reasoning", { text: redactText(part.text, options), options: part.options });
+    default:
+      return part;
+  }
+};
+var redactToolPart = (part, options) => {
+  if (part.type !== "tool-approval-response" || part.reason === undefined)
+    return part;
+  return Prompt11.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) => {
+  switch (message.role) {
+    case "system":
+      return Prompt11.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", {
+        content: message.content.map((part) => redactUserPart(part, options)),
+        options: message.options
+      });
+    case "assistant":
+      return Prompt11.makeMessage("assistant", {
+        content: message.content.map((part) => redactAssistantPart(part, options)),
+        options: message.options
+      });
+    case "tool":
+      return Prompt11.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 }))
+  })))
+});
+var redactInput = (options) => ({
+  transformPrompt: (prompt) => Effect20.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", {
+      id: part.id,
+      delta: redactText(part.delta, options),
+      metadata: part.metadata
+    })));
+  }
+});
+var filterOutput = (keep) => ({
+  transformPart: (part, context) => Effect20.succeed(part.type === "tool-call" || keep(part, context) ? Option13.some(part) : Option13.none())
+});
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/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 });
+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({
+    message: "Handoff.fanOut concurrency must be a positive integer",
+    turn: 0
+  }));
+};
+var mergeHandled = (toolkits) => {
+  const entries = new Map;
+  for (const toolkit of toolkits) {
+    for (const tool of Object.values(toolkit.tools)) {
+      if (!entries.has(tool.name))
+        entries.set(tool.name, { tool, toolkit });
+    }
+  }
+  const tools = Object.fromEntries([...entries].map(([name, entry]) => [name, entry.tool]));
+  return {
+    tools,
+    handle: (name, params) => {
+      const entry = entries.get(String(name));
+      return entry === undefined ? Effect21.fail(AiError4.make({
+        module: "Handoff",
+        method: `${String(name)}.handle`,
+        reason: AiError4.ToolNotFoundError.make({
+          toolName: String(name),
+          availableTools: Object.keys(tools)
+        })
+      })) : entry.toolkit.handle(name, params);
+    }
+  };
+};
+var toolkitFromHandled = (toolkit) => Toolkit6.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}`,
+  ...options.parameters === undefined ? {} : { parameters: options.parameters },
+  ...options.success === undefined ? {} : { success: options.success },
+  ...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) => {
+  const runOptions = {
+    ...child.options,
+    prompt: child.prompt
+  };
+  return generate(child.agent, runOptions);
+}, { concurrency }))));
+var supervisor = (options) => {
+  const specialists = options.specialists;
+  const transferTools = specialists.map((specialist) => transferTool(specialist));
+  const toolkit = mergeHandled(transferTools);
+  const agent = make5({
+    name: options.name,
+    ...options.instructions === undefined ? {} : { instructions: options.instructions },
+    toolkit: toolkitFromHandled(toolkit),
+    ...options.policy === undefined ? {} : { policy: options.policy }
+  });
+  return {
+    agent: {
+      ...agent,
+      toolDeclarations: transferTools.flatMap((transfer, index) => Object.values(transfer.tools).map((tool) => ({
+        tool,
+        origin: { _tag: "Handoff", specialist: options.specialists[index].name }
+      })))
+    },
+    toolkit
+  };
+};
+
+// ../../node_modules/.bun/@batonfx+core@0.6.1/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";
+
+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 };