@demlik/tea 0.12.0 → 0.14.0

package/dist/chunk-Z2L3LSNV.js

@@ -0,0 +1,1470 @@
+import { createMonitoredRun } from './chunk-HYDWG35Q.js';
+import { createFanOut, initFanOut } from './chunk-MYXFNWAJ.js';
+import { MsgType, createResilientCall } from './chunk-AQ6ZIMEA.js';
+import { subscribeDeadline } from './chunk-F2US5BW6.js';
+import { describeError } from './chunk-G5E74IJB.js';
+import { Cmd, cmdEdgeOf, detachWorkOf, absurd, defineMachine, malformedResult, run, driveToDone } from './chunk-RQULHGYH.js';
+import { Result } from 'better-result';
+import { z } from 'zod';
+
+// src/internal/llm-call/index.ts
+function plainModel(fn) {
+  return () => ({
+    withStructuredOutput(schema) {
+      return {
+        invoke: async (messages) => schema.parse(await fn(messages))
+      };
+    }
+  });
+}
+function isPlainModel(model) {
+  return Object.prototype.toString.call(model) === "[object AsyncFunction]";
+}
+var PLAIN_MODEL_MISROUTE_REASON = "model: a sync function returned a Promise where an Llm was expected \u2014 a promise-returning model that is not declared `async` must be wrapped in plainModel(fn) (see the llm-call module)";
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function asModelFactory(model) {
+  if (isPlainModel(model)) return plainModel(model);
+  return (modelId) => {
+    const llm = model(modelId);
+    if (isThenable(llm)) {
+      llm.then(void 0, () => void 0);
+      throw new Error(PLAIN_MODEL_MISROUTE_REASON);
+    }
+    return llm;
+  };
+}
+function createLlmCall(config, rng = Math.random) {
+  const resilientConfig = {
+    ...config.retry === void 0 ? {} : { retry: config.retry }
+  };
+  const rc = createResilientCall(resilientConfig, rng);
+  const modelOf = asModelFactory(config.model);
+  function init() {
+    return rc.init();
+  }
+  function attempt(s, input, at, key = input.purpose) {
+    return rc.attempt(s, key, input, at);
+  }
+  function succeed(s, key, msg) {
+    return rc.succeed(s, key, msg);
+  }
+  function fail(s, key, msg) {
+    return rc.fail(s, key, msg);
+  }
+  function onTimer(s, msg) {
+    return rc.onTimer(s, msg);
+  }
+  function subs(s) {
+    return rc.subs(s);
+  }
+  async function invokeOne(input) {
+    const model = modelOf(input.model);
+    const messages = config.loadMessages ? await config.loadMessages(input) : [];
+    const schema = config.schemas[input.purpose];
+    const structured = model.withStructuredOutput(schema);
+    const raw = await structured.invoke(messages);
+    const output = schema.parse(raw);
+    return { key: input.purpose, purpose: input.purpose, output };
+  }
+  const resilientRunHandler = rc.handlers({
+    run: (input) => invokeOne(input)
+  }).resilient_run;
+  async function settleOf(cmd) {
+    const settle = await resilientRunHandler(cmd, {});
+    if (settle.type === MsgType.ResilientOk) {
+      return { ...settle, result: { ...settle.result, key: cmd.key } };
+    }
+    const rawError = settle.error;
+    const err = {
+      key: cmd.key,
+      purpose: cmd.input.purpose,
+      reason: describeError(rawError),
+      error: rawError
+    };
+    return {
+      type: MsgType.ResilientErr,
+      key: settle.key,
+      error: err,
+      at: settle.at
+    };
+  }
+  function handlers(ports) {
+    if (ports === void 0) {
+      return { resilient_run: (cmd) => settleOf(cmd) };
+    }
+    return {
+      resilient_run: (cmd, ctx) => {
+        const fired = (async () => {
+          const settle = await settleOf(cmd);
+          if (settle.type === MsgType.ResilientOk) {
+            const msg2 = ports.onOk(settle.result);
+            if (msg2 !== void 0) await ctx.dispatch(msg2);
+            return;
+          }
+          const msg = ports.onErr(settle.error);
+          if (msg !== void 0) await ctx.dispatch(msg);
+        })();
+        ctx.waitUntil(fired);
+      }
+    };
+  }
+  return { init, attempt, succeed, fail, onTimer, subs, handlers, invokeOne };
+}
+
+// src/agent/schema.ts
+function schemaFromGuard(guard, name) {
+  return {
+    parse: (value) => {
+      if (!guard(value)) {
+        throw new Error(`structured-output parse failed: not ${name}`);
+      }
+      return value;
+    }
+  };
+}
+
+// src/agent/compaction.ts
+var COMPACTION_PURPOSE = "$compact";
+function isCompactionSummary(value) {
+  if (value === null || typeof value !== "object") return false;
+  return typeof value.summary === "string";
+}
+var compactionSummarySchema = schemaFromGuard(isCompactionSummary, "a CompactionSummary");
+
+// src/agent/internal.ts
+function freshConversation() {
+  return {
+    turns: [],
+    toolRecords: [],
+    turnCount: 0,
+    awaiting: { kind: "llm" }
+  };
+}
+function dedupeByCallId(calls) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const call of calls) {
+    if (seen.has(call.callId)) continue;
+    seen.add(call.callId);
+    out.push(call);
+  }
+  return out;
+}
+function foldSummary(conv, folding, summaryTurn) {
+  const shift = folding - 1;
+  const survivingTurns = conv.turns.slice(folding);
+  const survivingRecords = conv.toolRecords.filter((rec) => rec.turn >= folding).map((rec) => ({ ...rec, turn: rec.turn - shift }));
+  return {
+    ...conv,
+    turns: [summaryTurn, ...survivingTurns],
+    toolRecords: survivingRecords,
+    awaiting: { kind: "llm" }
+  };
+}
+function currentStage(s) {
+  return s.run.stepStates.find((i) => i.status === "running")?.input;
+}
+function isSettled(s) {
+  return s.run.phase === "done" || s.run.phase === "failed" || s.run.phase === "cancelled" || s.failure !== null;
+}
+function requireAwaiting(s, kind) {
+  if (isSettled(s)) return null;
+  const conv = s.conversation;
+  if (conv === null || conv.awaiting.kind !== kind) return null;
+  return conv;
+}
+function toCompactRunCmd(cmd) {
+  return {
+    type: MsgType.CompactRun,
+    key: COMPACTION_PURPOSE,
+    input: cmd.input
+  };
+}
+
+// src/agent/machine.ts
+function agentBootMsg(at) {
+  return { type: MsgType.AgentBoot, at };
+}
+function agentCancelMsg(at) {
+  return { type: MsgType.AgentCancel, at };
+}
+function agentEvents(opts) {
+  const tools = opts?.tools;
+  return (msg, state) => {
+    const events = [];
+    if (state.run.phase === "cancelled") return events;
+    const refused = new Set(state.refusedCalls ?? []);
+    const routed = tools === void 0 ? null : tools.outcomeOf(msg);
+    if (routed !== null) {
+      if (routed.outcome.kind === "ok" && !refused.has(routed.callId)) {
+        events.push({
+          type: "ToolSettled",
+          callId: routed.callId,
+          result: routed.outcome.result
+        });
+      }
+    } else {
+      projectOwn(msg, events, refused);
+    }
+    if (state.run.phase === "done") {
+      events.push({ type: "RunDone", output: state.output });
+    }
+    return events;
+  };
+}
+function projectOwn(msg, events, refused) {
+  switch (msg.type) {
+    case MsgType.ResilientOk:
+      events.push({ type: "TurnSettled", turn: msg.result.output });
+      break;
+    case MsgType.AgentToolOk:
+      if (!refused.has(msg.callId)) {
+        events.push({
+          type: "ToolSettled",
+          callId: msg.callId,
+          result: msg.result
+        });
+      }
+      break;
+    // start / boot / cancel / timer / the *_err arms / the compaction settles
+    // carry no public event. (No `default`: the switch is exhaustive over the Msg
+    // discriminant, so a new Msg variant forces a decision here at compile
+    // time.) Compaction is an internal optimization, not a semantic lifecycle
+    // moment a UI folds — its settles are deliberately silent here. Cancel is
+    // silent for a stronger reason: the run the caller stopped owes the public
+    // channel nothing after the stop, so a `RunCancelled` would be one more
+    // late thing to have to ignore.
+    case MsgType.AgentStart:
+    case MsgType.AgentCancel:
+    case MsgType.AgentToolErr:
+    case MsgType.ResilientErr:
+    case MsgType.CompactOk:
+    case MsgType.CompactErr:
+    case "deadline_exceeded":
+    case MsgType.AgentBoot:
+      break;
+  }
+}
+function mergeInterpret(a, b) {
+  return { ...a ?? {}, ...b };
+}
+function liftAgent(state, [slice, cmds]) {
+  return [{ ...state, agent: slice }, cmds];
+}
+var REJECTED_TYPE = "tool_rejected";
+var SNAPSHOT_WRITE_TYPE = "snapshot_write";
+var SETTLE_SUFFIX = /_(?:ok|err|run)$/;
+var reservedToolNames = /* @__PURE__ */ new Set([
+  ...Object.values(MsgType),
+  ...Object.values(MsgType).flatMap((t) => {
+    const suffix = SETTLE_SUFFIX.exec(t);
+    return suffix === null ? [] : [t.slice(0, suffix.index)];
+  }),
+  REJECTED_TYPE,
+  SNAPSHOT_WRITE_TYPE
+]);
+function isReservedToolName(name) {
+  return reservedToolNames.has(name);
+}
+function tool(name, spec, handler) {
+  if (isReservedToolName(name)) {
+    throw new Error(
+      `tool: "${name}" is reserved \u2014 it is an agent-owned Msg prefix`
+    );
+  }
+  const def = Cmd.define(name, {
+    input: z.object({
+      callId: z.string(),
+      args: spec.input
+    }),
+    ok: spec.ok,
+    err: [...spec.err, "thrown"],
+    requirements: spec.requirements
+  });
+  const declared = new Set(spec.err);
+  const settle = {
+    ok: (value) => Result.ok(value),
+    fail: (error) => Result.err(error)
+  };
+  const asDeclared = (thrown) => {
+    if (isTagged(thrown) && declared.has(thrown._tag)) return thrown;
+    return { _tag: "thrown", message: describeError(thrown) };
+  };
+  const interpret = async (cmd, ctx) => {
+    let result;
+    try {
+      result = await handler(cmd.args, ctx, settle);
+    } catch (thrown) {
+      return def.err(cmd, asDeclared(thrown));
+    }
+    return result.match({
+      ok: (value) => {
+        const parsed = spec.ok.safeParse(value);
+        return parsed.success ? def.ok(cmd, parsed.data) : {
+          type: def.errType,
+          cmd,
+          error: malformedResult(parsed.error.issues)
+        };
+      },
+      err: (error) => def.err(cmd, error)
+    });
+  };
+  return Object.assign(def, {
+    description: spec.description,
+    args: spec.input,
+    resilience: resilienceOf(spec),
+    interpret
+  });
+}
+function resilienceOf(spec) {
+  if (spec.timeoutMs === void 0 && spec.retry === void 0) return null;
+  return {
+    ...spec.timeoutMs !== void 0 ? { timeoutMs: spec.timeoutMs } : {},
+    ...spec.retry !== void 0 ? { retry: spec.retry } : {}
+  };
+}
+function isTagged(value) {
+  return typeof value === "object" && value !== null && typeof value._tag === "string";
+}
+var rejected = Cmd.define(REJECTED_TYPE, {
+  input: z.custom(
+    () => true
+  ),
+  ok: z.never(),
+  err: ["unknown_tool", "malformed_args"]
+});
+function toolRouter(tools) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const t of tools) {
+    if (byName.has(t.cmdType)) {
+      throw new Error(`toolRouter: tool "${t.cmdType}" is declared twice`);
+    }
+    byName.set(t.cmdType, t);
+  }
+  const defs = [...tools, rejected];
+  const okTypes = new Map(defs.map((d) => [d.okType, d]));
+  const errTypes = new Map(defs.map((d) => [d.errType, d]));
+  const toolOf = (call) => {
+    const t = byName.get(call.name);
+    if (t === void 0) {
+      return rejected({
+        callId: call.callId,
+        error: { _tag: "unknown_tool", name: call.name }
+      });
+    }
+    const parsed = t.args.safeParse(call.args);
+    if (!parsed.success) {
+      return rejected({
+        callId: call.callId,
+        error: {
+          _tag: "malformed_args",
+          name: call.name,
+          issues: malformedResult(parsed.error.issues).issues
+        }
+      });
+    }
+    const build = t;
+    return build({ callId: call.callId, args: parsed.data });
+  };
+  const handlers = {
+    [rejected.cmdType]: async (cmd) => rejected.err(cmd, cmd.error)
+  };
+  for (const t of tools) handlers[t.cmdType] = t.interpret;
+  const interpret = handlers;
+  const outcomeOf = (msg) => {
+    if (okTypes.has(msg.type)) {
+      const ok = msg;
+      return {
+        callId: ok.cmd.callId,
+        outcome: { kind: "ok", result: ok.value }
+      };
+    }
+    if (errTypes.has(msg.type)) {
+      const err = msg;
+      return {
+        callId: err.cmd.callId,
+        // The tag and its payload spread FIRST, so `kind` and `reason` are
+        // written over anything a payload field of those names carries: the
+        // discriminant and the model's channel are the router's to state, and a
+        // tool that fails with `{ _tag, kind: "ok" }` must not be able to say
+        // otherwise.
+        outcome: {
+          ...err.error,
+          reason: toolErrorReason(err.error),
+          kind: "error"
+        }
+      };
+    }
+    return null;
+  };
+  const resilienceOf2 = (call) => byName.get(call.name)?.resilience ?? null;
+  return { defs, toolOf, interpret, outcomeOf, resilienceOf: resilienceOf2 };
+}
+function fanOutInterpret(interpret) {
+  let release = Promise.resolve();
+  const fanned = {};
+  for (const [type, cell] of Object.entries(
+    interpret
+  )) {
+    fanned[type] = async (cmd, ctx, dispatch) => {
+      const edge = cmdEdgeOf(ctx);
+      const detach = detachWorkOf(ctx);
+      const work = (async () => cell(cmd, ctx, dispatch))();
+      const prior = release;
+      const settled = work.then(async (follow) => {
+        await prior;
+        const msg = edge(cmd, follow);
+        if (msg === void 0 || msg === null) return;
+        dispatch?.(msg);
+      });
+      release = settled.then(swallow, swallow);
+      detach(settled);
+      return void 0;
+    };
+  }
+  return fanned;
+}
+function swallow() {
+}
+function toolErrorReason(error) {
+  const { _tag, ...detail } = error;
+  return Object.keys(detail).length === 0 ? _tag : `${_tag} ${JSON.stringify(detail)}`;
+}
+
+// src/agent/types.ts
+function isStreamingModel(model) {
+  return model.length >= 2;
+}
+function isToolCall(value) {
+  if (value === null || typeof value !== "object") return false;
+  const t = value;
+  return typeof t.callId === "string" && typeof t.name === "string" && t.args !== null && typeof t.args === "object";
+}
+function isAgentTurn(value) {
+  if (value === null || typeof value !== "object") return false;
+  const t = value;
+  return typeof t.content === "string" && Array.isArray(t.toolCalls) && t.toolCalls.every(isToolCall);
+}
+var agentTurnSchema = schemaFromGuard(
+  isAgentTurn,
+  "an AgentTurn"
+);
+var TOOL_TIMEOUT_TAG = "timeout";
+var TOOL_RETRY_EXHAUSTED_TAG = "retry_exhausted";
+function status(s) {
+  if (s.failure !== null) {
+    return { kind: "failed", failure: s.failure };
+  }
+  const run2 = s.run;
+  switch (run2.phase) {
+    // 2) Never started — monitored-run's `idle` phase is exactly the "has this
+    //    actually started?" guard, and the status channel keeps that distinction.
+    case "idle":
+      return { kind: "idle" };
+    // 3) The monitored-run terminal failure (deadline / stage). `run.failure`
+    //    rides ONLY the `failed` arm of the discriminated union, so narrowing on
+    //    `phase === "failed"` surfaces it with no nullable side field and no
+    //    fabricated fallback — the old "failed-yet-failure-null" state is
+    //    unrepresentable.
+    case "failed":
+      return { kind: "failed", failure: run2.failure };
+    // 4) The pipeline finished — the terminal output landed on `state.output`.
+    case "done":
+      return { kind: "done", output: s.output };
+    // 5) Stopped from outside. Terminal, and deliberately NOT folded into
+    //    `failed`: the unified failure channel answers "what went wrong", and
+    //    nothing did.
+    case "cancelled":
+      return { kind: "cancelled", at: run2.at };
+    // 6) Live. Awaiting tools is the resumable shape — the outstanding calls are
+    //    the in-flight fan-out batch (`tools.running`); anything else is plain
+    //    `running`, which is also where `stale` reads (a soft mark the next
+    //    progress clears, not an outcome).
+    case "running":
+    case "stale":
+      return s.conversation !== null && s.conversation.awaiting.kind === "tools" ? { kind: "suspended", pending: s.tools.running } : { kind: "running" };
+  }
+  return absurd(run2);
+}
+
+// src/agent/tool-resilience.ts
+var TOOL_KEY_PREFIX = "$tool:";
+var NAME_CALL_SEP = "#";
+function toolCallKey(name, callId) {
+  return `${TOOL_KEY_PREFIX}${name}${NAME_CALL_SEP}${callId}`;
+}
+function readToolCallKey(key) {
+  if (!key.startsWith(TOOL_KEY_PREFIX)) return null;
+  const body = key.slice(TOOL_KEY_PREFIX.length);
+  const at = body.indexOf(NAME_CALL_SEP);
+  if (at <= 0) return null;
+  return { name: body.slice(0, at), callId: body.slice(at + 1) };
+}
+function isToolTimerId(id) {
+  return keyOfTimerId(id) !== null;
+}
+function keyOfTimerId(id) {
+  for (const prefix of ["resilient:retry:", "resilient:deadline:"]) {
+    if (id.startsWith(prefix)) {
+      const key = id.slice(prefix.length);
+      return key.startsWith(TOOL_KEY_PREFIX) ? key : null;
+    }
+  }
+  return null;
+}
+function createToolLadder(resilienceOf2, toolOf, rng) {
+  const instances = /* @__PURE__ */ new Map();
+  function rcFor(call) {
+    const policy = resilienceOf2(call);
+    if (policy === null) return null;
+    if (policy.timeoutMs === void 0 && policy.retry === void 0) {
+      return null;
+    }
+    const cached = instances.get(call.name);
+    if (cached !== void 0) return cached;
+    const made = createResilientCall(
+      {
+        ...policy.retry !== void 0 ? { retry: policy.retry } : {},
+        ...policy.timeoutMs !== void 0 ? { deadline: { ms: policy.timeoutMs } } : {}
+      },
+      rng
+    );
+    instances.set(call.name, made);
+    return made;
+  }
+  function sliceOf(s, name, rc) {
+    return s[name] ?? rc.init();
+  }
+  function toLaunchCmds(runCmds) {
+    return runCmds.map((cmd) => toolOf(cmd.input));
+  }
+  const launch = (s, calls, at) => {
+    let next = s;
+    const cmds = [];
+    for (const call of calls) {
+      const rc = rcFor(call);
+      if (rc === null) {
+        cmds.push(toolOf(call));
+        continue;
+      }
+      const [slice, runCmds] = rc.attempt(
+        sliceOf(next, call.name, rc),
+        toolCallKey(call.name, call.callId),
+        call,
+        at
+      );
+      next = { ...next, [call.name]: slice };
+      cmds.push(...toLaunchCmds(runCmds));
+    }
+    return [next, cmds];
+  };
+  const ok = (s, call, at) => {
+    const rc = rcFor(call);
+    if (rc === null) return s;
+    const key = toolCallKey(call.name, call.callId);
+    const [slice] = rc.succeed(sliceOf(s, call.name, rc), key, {
+      type: MsgType.ResilientOk,
+      key,
+      result: null,
+      at
+    });
+    return { ...s, [call.name]: forget(slice, key) };
+  };
+  const err = (s, call, failure, at) => {
+    const rc = rcFor(call);
+    if (rc === null) return [s, failure];
+    const key = toolCallKey(call.name, call.callId);
+    const before = sliceOf(s, call.name, rc);
+    const [slice] = rc.fail(before, key, {
+      type: MsgType.ResilientErr,
+      key,
+      error: failure,
+      at
+    });
+    if (slice.calls[key]?.phase === "waiting_retry") {
+      return [{ ...s, [call.name]: slice }, null];
+    }
+    const attempts = before.retry[key]?.attempt;
+    const settled = resilienceOf2(call)?.retry === void 0 ? failure : exhaustedFailure((attempts ?? 0) + 1, failure);
+    return [{ ...s, [call.name]: forget(slice, key) }, settled];
+  };
+  const onTimer = (s, msg) => {
+    const key = keyOfTimerId(msg.id);
+    const parsed = key === null ? null : readToolCallKey(key);
+    if (key === null || parsed === null) return [s, { cmds: [], settle: [] }];
+    const slice = s[parsed.name];
+    if (slice === void 0) return [s, { cmds: [], settle: [] }];
+    const remembered = inputOf(slice, key);
+    const rc = remembered === null ? null : rcFor(remembered);
+    if (rc === null) return [s, { cmds: [], settle: [] }];
+    const [next, runCmds] = rc.onTimer(slice, msg);
+    const phase = next.calls[key];
+    if (phase?.phase === "failed" && isDeadline(phase.error)) {
+      return [
+        { ...s, [parsed.name]: forget(next, key) },
+        {
+          cmds: [],
+          settle: [{ callId: parsed.callId, failure: timeoutFailure() }]
+        }
+      ];
+    }
+    return [
+      { ...s, [parsed.name]: next },
+      { cmds: toLaunchCmds(runCmds), settle: [] }
+    ];
+  };
+  const boot = (s, calls, at) => {
+    let next = s;
+    const cmds = [];
+    const settle = [];
+    for (const call of calls) {
+      const rc = rcFor(call);
+      if (rc === null) {
+        cmds.push(toolOf(call));
+        continue;
+      }
+      const key = toolCallKey(call.name, call.callId);
+      next = {
+        ...next,
+        [call.name]: rc.resume(sliceOf(next, call.name, rc), at)
+      };
+      const phase = sliceOf(next, call.name, rc).calls[key]?.phase;
+      if (phase === "waiting_retry") continue;
+      const [slice, runCmds] = rc.attempt(
+        sliceOf(next, call.name, rc),
+        key,
+        call,
+        at
+      );
+      const settled = slice.calls[key];
+      if (settled?.phase === "failed" && isDeadline(settled.error)) {
+        next = { ...next, [call.name]: forget(slice, key) };
+        settle.push({ callId: call.callId, failure: timeoutFailure() });
+        continue;
+      }
+      next = { ...next, [call.name]: slice };
+      cmds.push(...toLaunchCmds(runCmds));
+    }
+    return [next, { cmds, settle }];
+  };
+  const subs = (s) => {
+    const out = [];
+    for (const slice of Object.values(s)) {
+      const sample = firstInput(slice);
+      const rc = sample === null ? null : rcFor(sample);
+      if (rc !== null) out.push(...rc.subs(slice));
+    }
+    return out;
+  };
+  return { init: () => ({}), launch, ok, err, onTimer, boot, subs };
+}
+function forget(s, key) {
+  const { [key]: _settled, ...calls } = s.calls;
+  const { [key]: _spent, ...retry } = s.retry;
+  return { ...s, calls, retry };
+}
+function inputOf(s, key) {
+  const call = s.calls[key];
+  if (call === void 0) return null;
+  return call.phase === "running" || call.phase === "waiting_retry" ? call.input : null;
+}
+function firstInput(s) {
+  for (const key of Object.keys(s.calls)) {
+    const input = inputOf(s, key);
+    if (input !== null) return input;
+  }
+  return null;
+}
+function isDeadline(error) {
+  return typeof error === "object" && error !== null && error._tag === "deadline_exceeded";
+}
+function exhaustedFailure(attempts, last) {
+  return taggedFailure({
+    _tag: TOOL_RETRY_EXHAUSTED_TAG,
+    attempts,
+    last: last.reason
+  });
+}
+function timeoutFailure() {
+  return taggedFailure({ _tag: TOOL_TIMEOUT_TAG });
+}
+function taggedFailure(tagged) {
+  return { ...tagged, reason: toolErrorReason(tagged), kind: "error" };
+}
+
+// src/agent/define-agent.ts
+function defineAgent(config) {
+  const router = toolRouter(config.tools);
+  const { onToolError } = config;
+  const tools = onToolError === void 0 ? router : withToolErrorHook(router, onToolError);
+  return definedAgent(config, { router, tools }, []);
+}
+function definedAgent(config, wiring, overlays) {
+  const { router, tools } = wiring;
+  const { onToolError } = config;
+  const machineWith = (input, onChunk) => {
+    const brain = brainOf(config.model, onChunk);
+    const core = {
+      stages: [input],
+      turnOf: () => "act",
+      schemas: { act: agentTurnSchema },
+      model: brain,
+      instructions: config.instructions,
+      payloadOf: promptOf,
+      loadMessages: messagesOf,
+      toolOf: tools.toolOf,
+      // The per-tool timeout / retry knob (#117). The lid grows no option for
+      // it: the policy is declared on the `tool()` that needs it, and the
+      // router is what carries it down to the reducer that runs it.
+      toolResilienceOf: tools.resilienceOf,
+      // The BRAIN-call ladder (#146), which does grow one, because a bare
+      // `model` function has nowhere else to declare it. Forwarded only when
+      // set, so an omitted lid option leaves `AgentConfigCore.retry` unset
+      // and the brain call unbackedoff, byte for byte as before.
+      ...config.retry !== void 0 ? { retry: config.retry } : {},
+      // Forwarded only when set, for the same reason: an omitted knob leaves
+      // `AgentConfigCore.toolConcurrency` unset and the fan-out at its serial
+      // default.
+      ...config.toolConcurrency !== void 0 ? { toolConcurrency: config.toolConcurrency } : {},
+      maxTurns: config.maxTurns,
+      deadlineMs: config.deadlineMs,
+      maxElapsedMs: config.maxElapsedMs,
+      stopWhen: config.stopWhen
+    };
+    const compaction = config.compaction;
+    const agent = compaction === void 0 ? (
+      // The one assertion in the pair, and it widens the Cmd union rather
+      // than the interpret obligation: this machine's `AgentCmd` fixes
+      // compaction OFF, `DefinedAgentMachine` names the ON superset, and the
+      // gap is the `compact_run` Cmd a policy-less reducer provably never
+      // emits. Widening a union nothing can produce is sound; the reverse —
+      // claiming a cell that is not wired — is what the discriminant refuses.
+      createAgent(core).toMachine({
+        tools
+      })
+    ) : compactingMachine(core, compaction, brain, tools);
+    return overlaid(agent, overlays);
+  };
+  const machine = (input) => machineWith(input, void 0);
+  const drive = (input, ...[opts = noHost()]) => {
+    const { onEvent, onChunk } = opts;
+    const handle = run(machineWith(input, onChunk), {
+      ...opts,
+      terminal: isEnded,
+      events: onEvent === void 0 ? void 0 : agentEvents({
+        tools
+      })
+    });
+    if (onEvent !== void 0) forwardEvents(handle, onEvent);
+    if (onToolError !== void 0) {
+      forwardLadderErrors(handle, router, onToolError);
+    }
+    const clock = opts.clock ?? Date.now;
+    const begin = (booted) => {
+      const at = clock();
+      return isMidRun(booted) ? agentBootMsg(at) : startMsg(opts.runId ?? crypto.randomUUID(), at);
+    };
+    const signal = opts.signal;
+    if (signal === void 0) {
+      return ended(driveToDone(handle, begin, isEnded, { failed: isFailed }));
+    }
+    return ended(
+      driveToDone(handle, begin, isEnded, {
+        failed: isFailed,
+        signal,
+        cancel: () => agentCancelMsg(clock())
+      })
+    );
+  };
+  return {
+    machine,
+    run: drive,
+    with: (overlay) => definedAgent(config, wiring, [...overlays, overlay.interpret])
+  };
+}
+function overlaid(machine, overlays) {
+  if (overlays.length === 0) return machine;
+  const cells = { ...machine.interpret };
+  for (const overlay of overlays) {
+    const wrappers = overlay;
+    for (const [type, wrap] of Object.entries(wrappers)) {
+      const cell = cells[type];
+      if (cell === void 0) {
+        throw new Error(
+          `@demlik/tea: defineAgent(...).with named the interpret cell "${type}", which this agent's machine has none of. Its cells are: ${Object.keys(cells).sort().join(", ")}.`
+        );
+      }
+      cells[type] = wrap(cell);
+    }
+  }
+  return defineMachine({
+    ...machine,
+    interpret: cells
+  });
+}
+function brainOf(model, onChunk) {
+  if (!isStreamingModel(model)) {
+    return model;
+  }
+  const streaming = model;
+  const stream = {
+    onChunk: onChunk === void 0 ? dropChunk : contained("onChunk", onChunk)
+  };
+  return async (messages) => streaming(messages, stream);
+}
+function dropChunk() {
+}
+function contained(what, listener) {
+  return (event) => {
+    try {
+      listener(event);
+    } catch (err) {
+      console.warn(`@demlik/tea: a run's ${what} listener threw`, err);
+    }
+  };
+}
+function compactingMachine(core, knob, brain, tools) {
+  const agent = createAgent({ ...core, compaction: compactionPolicyOf(knob) });
+  const wiring = {
+    tools,
+    toolInterpret: { compact_run: summarizeWith(brain) }
+  };
+  return agent.toMachine(wiring);
+}
+var SUMMARIZE_INSTRUCTION = "Summarize the conversation so far. Preserve the facts, decisions and tool results a continuation would need, and drop everything else. Reply with the summary as your message content and request no tools.";
+function compactionPolicyOf(knob) {
+  const keep = knob.keepTurns ?? 0;
+  return {
+    planCompaction: (conversation) => conversation.turns.length >= knob.afterTurns ? Math.max(0, conversation.turns.length - keep) : 0,
+    payloadOf: (conversation, folding) => ({
+      instructions: SUMMARIZE_INSTRUCTION,
+      input: null,
+      conversation: {
+        ...conversation,
+        turns: conversation.turns.slice(0, folding),
+        toolRecords: conversation.toolRecords.filter((r) => r.turn < folding)
+      }
+    })
+  };
+}
+function summarizeWith(model) {
+  return async (cmd) => {
+    const payload = cmd.input.payload;
+    const turn = await model(renderPrompt(payload));
+    return {
+      type: MsgType.CompactOk,
+      key: COMPACTION_PURPOSE,
+      result: {
+        key: COMPACTION_PURPOSE,
+        purpose: COMPACTION_PURPOSE,
+        output: { summary: turn.content }
+      },
+      at: Date.now()
+    };
+  };
+}
+function promptOf(stage, conversation, instructions) {
+  return { instructions, input: stage ?? null, conversation };
+}
+var messagesOf = async (call) => renderPrompt(call.payload);
+function renderPrompt(prompt) {
+  const head = [];
+  if (prompt.instructions !== null) {
+    head.push({ role: "system", content: prompt.instructions });
+  }
+  if (prompt.input !== null) {
+    head.push({ role: "user", content: prompt.input });
+  }
+  const { turns, toolRecords } = prompt.conversation;
+  const transcript2 = turns.flatMap((turn, i) => [
+    assistantOf(turn),
+    ...toolRecords.filter((r) => r.turn === i).map((r) => ({
+      role: "tool",
+      callId: r.call.callId,
+      name: r.call.name,
+      outcome: r.outcome
+    }))
+  ]);
+  return [...head, ...transcript2];
+}
+function assistantOf(turn) {
+  const { content, toolCalls } = turn;
+  return "provider" in turn ? { role: "assistant", content, toolCalls, provider: turn.provider } : { role: "assistant", content, toolCalls };
+}
+function noHost() {
+  return {};
+}
+var AGENT_EVENT_TYPES = ["TurnSettled", "ToolSettled", "RunDone"];
+function forwardEvents(handle, onEvent) {
+  const deliver = contained("onEvent", onEvent);
+  for (const type of AGENT_EVENT_TYPES) {
+    handle.on(type, deliver);
+  }
+}
+function forwardLadderErrors(handle, router, onToolError) {
+  const fired = /* @__PURE__ */ new Set();
+  handle.observe((msg, state) => {
+    const seeding = msg.type === MsgType.AgentStart || msg.type === MsgType.AgentBoot;
+    for (const record of state.conversation?.toolRecords ?? []) {
+      const { outcome, call } = record;
+      if (outcome.kind !== "error") continue;
+      if (fired.has(call.callId)) continue;
+      fired.add(call.callId);
+      if (seeding) continue;
+      if (router.resilienceOf(call) === null) continue;
+      void Promise.resolve(
+        onToolError(outcome, {
+          callId: call.callId,
+          name: call.name
+        })
+      ).catch((err) => {
+        console.warn("@demlik/tea: a run's onToolError hook threw", err);
+      });
+    }
+  });
+}
+function withToolErrorHook(router, onToolError) {
+  const handlers = router.interpret;
+  const wrapped = {};
+  for (const [type, handler] of Object.entries(handlers)) {
+    wrapped[type] = async (cmd, ctx) => {
+      const msg = await handler(cmd, ctx);
+      if (msg === void 0) return msg;
+      const settled = router.outcomeOf(msg);
+      if (settled === null || settled.outcome.kind === "ok") return msg;
+      if (ownedByLadder(router, cmd, settled.callId)) return msg;
+      try {
+        await onToolError(settled.outcome, {
+          callId: settled.callId,
+          name: calledName(cmd)
+        });
+      } catch (err) {
+        console.warn("@demlik/tea: a run's onToolError hook threw", err);
+      }
+      return msg;
+    };
+  }
+  return {
+    ...router,
+    interpret: wrapped
+  };
+}
+function ownedByLadder(router, cmd, callId) {
+  return router.resilienceOf({ name: cmd.type, callId, args: {} }) !== null;
+}
+function calledName(cmd) {
+  const rejection = cmd.error;
+  return typeof rejection?.name === "string" ? rejection.name : cmd.type;
+}
+function startMsg(runId, at) {
+  return { type: MsgType.AgentStart, runId, at };
+}
+function isMidRun(s) {
+  const { kind } = status(s);
+  return kind === "running" || kind === "suspended";
+}
+function isEnded(s) {
+  return s.run.phase === "done" || s.run.phase === "cancelled";
+}
+function ended(drive) {
+  return drive;
+}
+function isFailed(s) {
+  return status(s).kind === "failed";
+}
+
+// src/agent/transcript.ts
+function transcript(seed) {
+  const turns = [...seed?.conversation?.turns ?? []];
+  const tools = (seed?.conversation?.toolRecords ?? []).flatMap(
+    (record) => record.outcome.kind === "ok" ? [{ callId: record.call.callId, result: record.outcome.result }] : []
+  );
+  let outcome = { kind: "running" };
+  return {
+    onEvent: (event) => {
+      switch (event.type) {
+        case "TurnSettled":
+          turns.push(event.turn);
+          return;
+        case "ToolSettled":
+          tools.push({ callId: event.callId, result: event.result });
+          return;
+        case "RunDone":
+          outcome = { kind: "done", output: event.output };
+          return;
+      }
+    },
+    read: () => ({ turns: [...turns], tools: [...tools], outcome })
+  };
+}
+
+// src/agent/index.ts
+function createAgent(config) {
+  const rng = config.rng ?? Math.random;
+  const run2 = createMonitoredRun({
+    ...config.stages !== void 0 ? { stages: config.stages } : {},
+    ...config.deadlineMs !== void 0 ? { deadlineMs: config.deadlineMs } : {},
+    ...config.snapshotEvery !== void 0 ? { snapshotEvery: config.snapshotEvery } : {}
+  });
+  const llm = createLlmCall(
+    {
+      model: config.model,
+      schemas: config.schemas,
+      ...config.retry !== void 0 ? { retry: config.retry } : {},
+      ...config.loadMessages !== void 0 ? { loadMessages: config.loadMessages } : {}
+    },
+    rng
+  );
+  const compactRc = createResilientCall({ ...config.retry !== void 0 ? { retry: config.retry } : {} }, rng);
+  const fan = createFanOut({
+    concurrency: config.toolConcurrency ?? 1,
+    idOf: (call) => call.callId,
+    of: (call) => config.toolOf(call)
+  });
+  const ladder = createToolLadder(
+    config.toolResilienceOf ?? (() => null),
+    config.toolOf,
+    rng
+  );
+  function init() {
+    return {
+      run: run2.init(),
+      resilience: llm.init(),
+      tools: initFanOut(),
+      conversation: null,
+      compaction: compactRc.init(),
+      toolResilience: ladder.init(),
+      refusedCalls: [],
+      failure: null,
+      output: null,
+      instructions: config.instructions ?? null
+    };
+  }
+  function brainCall(s) {
+    const stage = currentStage(s);
+    const conversation = s.conversation ?? freshConversation();
+    const instructions = s.instructions ?? null;
+    return {
+      purpose: config.turnOf(stage),
+      model: config.modelId ?? null,
+      payload: config.payloadOf ? config.payloadOf(stage, conversation, instructions) : null
+    };
+  }
+  function fireBrainCall(s, at) {
+    const call = brainCall(s);
+    const [resilience, cmds] = llm.attempt(s.resilience, call, at);
+    return [{ ...s, resilience }, cmds];
+  }
+  function compactionCall(conv, folding) {
+    const payloadOf = config.compaction?.payloadOf;
+    return {
+      purpose: COMPACTION_PURPOSE,
+      model: config.modelId ?? null,
+      payload: payloadOf ? payloadOf(conv, folding) : null
+    };
+  }
+  function reKeyCompactCmds(result) {
+    const [slice, cmds] = result;
+    return [slice, cmds.map(toCompactRunCmd)];
+  }
+  const compact = {
+    attempt: (slice, key, input, at) => reKeyCompactCmds(compactRc.attempt(slice, key, input, at)),
+    succeed: (slice, key, msg) => reKeyCompactCmds(compactRc.succeed(slice, key, msg)),
+    fail: (slice, key, msg) => reKeyCompactCmds(compactRc.fail(slice, key, msg)),
+    onTimer: (slice, msg) => reKeyCompactCmds(compactRc.onTimer(slice, msg))
+  };
+  function start(s, runId, at) {
+    const [runSlice] = run2.start(s.run, runId, at);
+    const conversation = freshConversation();
+    const withRun = {
+      ...s,
+      run: runSlice,
+      conversation,
+      failure: null,
+      // A restart clears the prior run's terminal output — `result()` reads
+      // `undefined` again until THIS run finishes (#46).
+      output: null,
+      tools: initFanOut(),
+      // A restart also clears any prior compaction slice — a fresh run never
+      // inherits the previous run's summarize retry bookkeeping (#85).
+      compaction: compactRc.init(),
+      // …and the prior run's refusals: those `callId`s belong to a batch this
+      // run will never settle, so carrying them would only grow the Model (#145).
+      refusedCalls: []
+    };
+    return fireBrainCall(withRun, at);
+  }
+  function turn(s, result, at) {
+    const conv = requireAwaiting(s, "llm");
+    if (conv === null) return [s, []];
+    const withTurn = {
+      ...conv,
+      turns: [...conv.turns, result]
+    };
+    if (result.toolCalls.length === 0) {
+      return advanceStage({ ...s, conversation: withTurn }, result, at);
+    }
+    const batch = dedupeByCallId(result.toolCalls);
+    const [tools] = fan.scatter(initFanOut(), batch);
+    const nextConv = {
+      ...withTurn,
+      awaiting: { kind: "tools", batchTurn: withTurn.turnCount }
+    };
+    const [runSlice] = run2.progress(s.run, void 0, at);
+    const [toolResilience, launchCmds] = armLaunch(s, [], tools.running, at);
+    return [
+      { ...s, run: runSlice, tools, toolResilience, conversation: nextConv },
+      launchCmds
+    ];
+  }
+  function advanceStage(s, terminatingTurn, at) {
+    const [runSlice, runCmds] = run2.advance(
+      s.run,
+      void 0,
+      { kind: "ok" },
+      at
+    );
+    if (runSlice.phase === "done") {
+      return [
+        { ...s, run: runSlice, conversation: null, output: terminatingTurn },
+        runCmds
+      ];
+    }
+    const conversation = freshConversation();
+    const moved = {
+      ...s,
+      run: runSlice,
+      conversation,
+      tools: initFanOut()
+    };
+    const [fired, llmCmds] = fireBrainCall(moved, at);
+    return [fired, [...runCmds, ...llmCmds]];
+  }
+  function toolOk(s, callId, result, at) {
+    const call = inFlight(s, callId);
+    const laddered = call === null ? s : { ...s, toolResilience: ladder.ok(toolSlice(s), call, at) };
+    return settleTool(laddered, callId, { kind: "ok", result }, at);
+  }
+  function toolErr(s, callId, reported, at) {
+    const failure = typeof reported === "string" ? { kind: "error", reason: reported } : reported;
+    const call = inFlight(s, callId);
+    if (call === null) return settleTool(s, callId, failure, at);
+    const [toolResilience, settled] = ladder.err(
+      toolSlice(s),
+      call,
+      failure,
+      at
+    );
+    const next = { ...s, toolResilience };
+    if (settled === null) return [next, []];
+    return settleTool(next, callId, settled, at);
+  }
+  function inFlight(s, callId) {
+    return s.tools.running.find((c) => c.callId === callId) ?? null;
+  }
+  function toolSlice(s) {
+    return s.toolResilience ?? {};
+  }
+  function refusedOf(s) {
+    return s.refusedCalls ?? [];
+  }
+  function armLaunch(s, before, after, at) {
+    const known = new Set(before.map((c) => c.callId));
+    return ladder.launch(
+      toolSlice(s),
+      after.filter((c) => !known.has(c.callId)),
+      at
+    );
+  }
+  function settleTool(prev, callId, outcome, at) {
+    const conv = requireAwaiting(prev, "tools");
+    if (conv === null) return [prev, []];
+    const call = prev.tools.running.find((c) => c.callId === callId);
+    if (call === void 0) return [prev, []];
+    const [tools] = outcome.kind === "ok" ? fan.itemOk(prev.tools, callId, outcome) : fan.itemErr(prev.tools, callId, outcome);
+    const [toolResilience, launchCmds] = armLaunch(
+      prev,
+      prev.tools.running,
+      tools.running,
+      at
+    );
+    const refusedCalls = outcome.kind === "ok" ? refusedOf(prev) : [...refusedOf(prev), callId];
+    const s = { ...prev, toolResilience, refusedCalls };
+    const foldedConv = {
+      ...conv,
+      // Stamp the producing-turn index on the record (#85, A1). At settle time
+      // `conv.turnCount` equals the index in `turns` of the turn that scattered
+      // this batch (each prior drained batch bumped `turnCount` exactly once, and
+      // each tool-bearing turn appended exactly one entry to `turns`), so a record
+      // carrying `turn: conv.turnCount` is dropped iff its producing turn is folded
+      // (`turn < N`) — the association the fold-back relies on.
+      toolRecords: [
+        ...conv.toolRecords,
+        { call, outcome, turn: conv.turnCount }
+      ]
+    };
+    if (!fan.isComplete(tools)) {
+      const [runSlice2] = run2.progress(s.run, void 0, at);
+      return [
+        { ...s, run: runSlice2, tools, conversation: foldedConv },
+        launchCmds
+      ];
+    }
+    const turnedConv = {
+      ...foldedConv,
+      turnCount: foldedConv.turnCount + 1,
+      awaiting: { kind: "llm" }
+    };
+    const turned = { ...s, tools, conversation: turnedConv };
+    const stopped = stopConditions(turned, at);
+    if (stopped !== null) return stopped;
+    const drained = {
+      ...turned,
+      tools: initFanOut()
+    };
+    const compacting = maybeCompact(drained, at);
+    if (compacting !== null) return compacting;
+    const [runSlice] = run2.progress(drained.run, void 0, at);
+    const [fired, llmCmds] = fireBrainCall({ ...drained, run: runSlice }, at);
+    return [fired, [...launchCmds, ...llmCmds]];
+  }
+  function maybeCompact(s, at) {
+    const policy = config.compaction;
+    const conv = s.conversation;
+    if (policy === void 0 || conv === null) return null;
+    const requested = policy.planCompaction(conv);
+    const folding = Math.min(requested, conv.turns.length);
+    if (folding < 2) return null;
+    const compactConv = {
+      ...conv,
+      awaiting: { kind: "compacting", folding }
+    };
+    const [runSlice] = run2.progress(s.run, void 0, at);
+    const input = compactionCall(conv, folding);
+    const [compaction, cmds] = compact.attempt(
+      s.compaction,
+      COMPACTION_PURPOSE,
+      input,
+      at
+    );
+    return [
+      { ...s, run: runSlice, conversation: compactConv, compaction },
+      cmds
+    ];
+  }
+  function stopConditions(s, at) {
+    const turnCount = s.conversation?.turnCount ?? 0;
+    if (config.maxTurns !== void 0 && turnCount >= config.maxTurns) {
+      return [{ ...s, failure: { reason: "turn_limit", at } }, []];
+    }
+    if (config.maxElapsedMs !== void 0 && at - s.run.startedAt >= config.maxElapsedMs) {
+      return [{ ...s, failure: { reason: "elapsed_limit", at } }, []];
+    }
+    if (config.stopWhen?.(s) === true) return cancel(s, at);
+    return null;
+  }
+  function succeed(s, key, msg, at) {
+    const [resilience, retryCmds] = llm.succeed(s.resilience, key, msg);
+    const settled = { ...s, resilience };
+    const [withTurn, turnCmds] = turn(settled, msg.result.output, at);
+    return [withTurn, [...retryCmds, ...turnCmds]];
+  }
+  function fail(s, key, msg, at) {
+    const [resilience, cmds] = llm.fail(s.resilience, key, msg);
+    const call = resilience.calls[key];
+    const failure = call?.phase === "failed" ? { reason: "llm", error: msg.error, at } : s.failure;
+    return [{ ...s, resilience, failure }, cmds];
+  }
+  function compactOk(s, key, msg, at) {
+    const [compaction, retryCmds] = compact.succeed(s.compaction, key, {
+      type: MsgType.ResilientOk,
+      key: msg.key,
+      result: msg.result,
+      at: msg.at
+    });
+    const settledRetry = { ...s, compaction };
+    const conv = requireAwaiting(settledRetry, "compacting");
+    if (conv === null) return [settledRetry, retryCmds];
+    const folding = conv.awaiting.folding;
+    const summaryTurn = {
+      content: msg.result.output.summary,
+      toolCalls: []
+    };
+    const foldedConv = foldSummary(conv, folding, summaryTurn);
+    const [fired, llmCmds] = fireBrainCall(
+      { ...settledRetry, conversation: foldedConv },
+      at
+    );
+    return [fired, [...retryCmds, ...llmCmds]];
+  }
+  function compactErr(s, key, msg, at) {
+    const [compaction, cmds] = compact.fail(s.compaction, key, {
+      type: MsgType.ResilientErr,
+      key: msg.key,
+      error: msg.error,
+      at: msg.at
+    });
+    const settledRetry = { ...s, compaction };
+    const call = compaction.calls[key];
+    if (call?.phase === "waiting_retry") {
+      return [settledRetry, cmds];
+    }
+    const conv = requireAwaiting(settledRetry, "compacting");
+    if (conv === null) return [settledRetry, cmds];
+    const resumedConv = { ...conv, awaiting: { kind: "llm" } };
+    const [fired, llmCmds] = fireBrainCall(
+      { ...settledRetry, conversation: resumedConv },
+      at
+    );
+    return [fired, [...cmds, ...llmCmds]];
+  }
+  function onTimer(s, msg) {
+    if (msg.id.startsWith("monitored:")) {
+      const [runSlice] = run2.onDeadline(s.run, msg);
+      return [{ ...s, run: runSlice }, []];
+    }
+    if (msg.id.endsWith(`:${COMPACTION_PURPOSE}`)) {
+      const [compaction, cmds2] = compact.onTimer(s.compaction, msg);
+      return [{ ...s, compaction }, cmds2];
+    }
+    if (isToolTimerId(msg.id)) return toolTimer(s, msg);
+    const [resilience, cmds] = llm.onTimer(s.resilience, msg);
+    return [{ ...s, resilience }, cmds];
+  }
+  function toolTimer(s, msg) {
+    const [toolResilience, outcome] = ladder.onTimer(toolSlice(s), msg);
+    return applyLadder(s, toolResilience, outcome, msg.atMs);
+  }
+  function applyLadder(s, toolResilience, outcome, at) {
+    let next = { ...s, toolResilience };
+    const cmds = [...outcome.cmds];
+    for (const order of outcome.settle) {
+      const [settled, more] = settleTool(next, order.callId, order.failure, at);
+      next = settled;
+      cmds.push(...more);
+    }
+    return [next, cmds];
+  }
+  function boot(s, at) {
+    const [runSlice] = run2.boot(s.run, at);
+    const rebooted = { ...s, run: runSlice };
+    if (isSettled(rebooted)) return [rebooted, []];
+    const conv = rebooted.conversation;
+    if (conv === null) return [rebooted, []];
+    if (conv.awaiting.kind === "llm") {
+      return fireBrainCall(rebooted, at);
+    }
+    if (conv.awaiting.kind === "compacting") {
+      const input = compactionCall(conv, conv.awaiting.folding);
+      const [compaction, cmds] = compact.attempt(
+        rebooted.compaction,
+        COMPACTION_PURPOSE,
+        input,
+        at
+      );
+      return [{ ...rebooted, compaction }, cmds];
+    }
+    const [toolResilience, outcome] = ladder.boot(
+      toolSlice(rebooted),
+      rebooted.tools.running,
+      at
+    );
+    return applyLadder(rebooted, toolResilience, outcome, at);
+  }
+  function cancel(s, at) {
+    const [runSlice] = run2.cancel(s.run, at);
+    return [{ ...s, run: runSlice }, []];
+  }
+  function subs(s) {
+    return [
+      ...llm.subs(s.resilience),
+      ...compactRc.subs(s.compaction),
+      ...ladder.subs(toolSlice(s)),
+      ...run2.subs(s.run)
+    ];
+  }
+  function unsafeDetachedHandlers(ports) {
+    return llm.handlers(ports);
+  }
+  function brainHandlers() {
+    return llm.handlers();
+  }
+  function toMachine(opts) {
+    const tools = opts?.tools;
+    const toolCellsInterpret = tools === void 0 ? void 0 : (config.toolConcurrency ?? 1) > 1 ? fanOutInterpret(tools.interpret) : tools.interpret;
+    const consumerInterpret = {
+      ...toolCellsInterpret,
+      ...opts?.toolInterpret
+    };
+    const interpret = mergeInterpret(consumerInterpret, brainHandlers());
+    const foldTool = (s, m) => {
+      const settled = tools?.outcomeOf(m);
+      if (settled === void 0 || settled === null) return [s, []];
+      return settled.outcome.kind === "ok" ? toolOk(s, settled.callId, settled.outcome.result, m.at) : toolErr(s, settled.callId, settled.outcome, m.at);
+    };
+    const toolCells = {};
+    for (const def of tools?.defs ?? []) {
+      toolCells[def.okType] = foldTool;
+      toolCells[def.errType] = foldTool;
+    }
+    const ownUpdate = {
+      [MsgType.AgentStart]: (s, m) => start(s, m.runId, m.at),
+      [MsgType.AgentToolOk]: (s, m) => toolOk(s, m.callId, m.result, m.at),
+      // `agent_tool_err` is `createAgent`'s own raw settle Msg and its wire
+      // shape is a bare `reason` string — a consumer routing their own interpret
+      // through it never declared a tag, so the failure it mints carries none.
+      [MsgType.AgentToolErr]: (s, m) => toolErr(s, m.callId, m.reason, m.at),
+      // The re-entered brain-call settle Msgs (from `brainHandlers`): success
+      // runs `succeed` (reset retry + fold the turn), failure runs `fail`.
+      [MsgType.ResilientOk]: (s, m) => succeed(s, m.key, m, m.at),
+      [MsgType.ResilientErr]: (s, m) => fail(s, m.key, m, m.at),
+      // The re-entered compaction settle Msgs (from the consumer's `compact_run`
+      // cell, #85): `compact_ok` folds the summary back (drop oldest turns +
+      // their records, fire the next brain call), `compact_err` backs off via the
+      // compaction retry or proceeds without compacting.
+      [MsgType.CompactOk]: (s, m) => compactOk(s, m.key, m, m.at),
+      [MsgType.CompactErr]: (s, m) => compactErr(s, m.key, m, m.at),
+      deadline_exceeded: (s, m) => onTimer(s, m),
+      [MsgType.AgentBoot]: (s, m) => boot(s, m.at),
+      [MsgType.AgentCancel]: (s, m) => cancel(s, m.at)
+    };
+    const update = { ...ownUpdate, ...toolCells };
+    const machine = {
+      init: (loaded) => loaded !== null ? [loaded, []] : [init(), []],
+      update,
+      subscriptions: (s) => subs(s),
+      subscribe: { deadline: subscribeDeadline },
+      interpret,
+      ...tools !== void 0 ? { cmds: tools.defs } : {}
+    };
+    return defineMachine(machine);
+  }
+  return {
+    init,
+    start,
+    turn,
+    toolOk,
+    toolErr,
+    succeed,
+    fail,
+    compactOk,
+    compactErr,
+    onTimer,
+    boot,
+    isSettled,
+    currentStage,
+    brainCall,
+    subs,
+    // `toMachine` is THE wired path. `unsafeDetachedHandlers` is the
+    // hand-wiring escape hatch — named to advertise the retry-loop gap so it is
+    // never mistaken for the loop driver (#54).
+    toMachine,
+    unsafeDetachedHandlers
+  };
+}
+
+export { COMPACTION_PURPOSE, PLAIN_MODEL_MISROUTE_REASON, TOOL_RETRY_EXHAUSTED_TAG, TOOL_TIMEOUT_TAG, agentBootMsg, agentCancelMsg, agentEvents, agentTurnSchema, compactionSummarySchema, createAgent, defineAgent, fanOutInterpret, isAgentTurn, isCompactionSummary, isReservedToolName, isStreamingModel, liftAgent, mergeInterpret, plainModel, renderPrompt, status, tool, toolErrorReason, toolRouter, transcript };
+//# sourceMappingURL=chunk-Z2L3LSNV.js.map
+//# sourceMappingURL=chunk-Z2L3LSNV.js.map