@demlik/tea 0.17.0 → 0.18.0

package/README.md

@@ -55,8 +55,9 @@ file imports only the core, so it runs unchanged on either engine.
   imports no engine.
 - `@demlik/tea/promise` — the Promise engine. Handlers return Promises.
 - `@demlik/tea/effect` — the Effect engine (`experimental`, Effect v4). Handlers
-  return Effects, services come from your Layers, and closing the scope
-  interrupts whatever is in flight.
+  return Effects, services come from your Layers, the handle's verbs return
+  Effects with typed errors, and closing the scope interrupts whatever is in
+  flight.
 
 [Run a machine on the Promise engine](https://github.com/kamp-us/demlik/blob/main/docs/how-to/run-on-the-promise-engine.md)
 and [on the Effect engine](https://github.com/kamp-us/demlik/blob/main/docs/how-to/run-on-the-effect-engine.md)

package/dist/agent/index.d.ts

@@ -1,19 +1,19 @@
-import { M as Machine, o as Interpret, d as Subscribe, C as Cmd } from '../core-rDbOaJTN.js';
-import { b as DeadlinesSub } from '../index-DaX_P35Q.js';
-export { a as DeadlineSub, c as deadlineSub, e as deadlinesSub, s as subscribeDeadline } from '../index-DaX_P35Q.js';
-import { T as ToolCall, a as ToolOutcome, C as Conversation, A as AnyToolDef, P as PlainModel, b as AgentTurn, S as StreamingModel, c as AgentState, d as ToolResult, e as ToolFailureOf, f as ToolsCtx, g as AgentEvent, h as TurnChunk, i as AgentMachineMsg, W as WiredToolMsg, j as AgentCmd, k as ToolCmd, l as AgentConfigCore, m as CompactionPolicy, n as AgentKnob } from '../machine-BcfCFMYF.js';
-export { o as AgentBootMsg, p as AgentCancelMsg, q as AgentCompactErrMsg, r as AgentCompactOkMsg, s as AgentCompactRunCmd, t as AgentCompactionConfig, u as AgentConfig, v as AgentFailure, w as AgentLlmErrMsg, x as AgentLlmOkMsg, y as AgentLlmRunCmd, z as AgentSnapshotConfig, B as AgentStatus, D as AgentTerminalFailure, E as AgentTimerMsg, F as AgentToMachine, G as Awaiting, H as COMPACTION_PURPOSE, I as CompactInterpret, J as CompactionOutputs, K as CompactionPurpose, L as CompactionSummary, M as Llm, N as LlmCall, O as LlmErr, Q as LlmFailMsg, R as LlmOk, U as LlmRunCmd, V as LlmSucceedMsg, X as MessageLoader, Y as ModelFactory, Z as ModelPort, _ as ModelStream, $ as PLAIN_MODEL_MISROUTE_REASON, a0 as ReservedToolName, a1 as Schema, a2 as SnapshotInterpret, a3 as TOOL_RETRY_EXHAUSTED_TAG, a4 as TOOL_TIMEOUT_TAG, a5 as TaggedFailure, a6 as ToolConstructors, a7 as ToolDef, a8 as ToolError, a9 as ToolFail, aa as ToolFailure, ab as ToolHandler, ac as ToolInput, ad as ToolMsg, ae as ToolOk, af as ToolRecord, ag as ToolRejectedCmd, ah as ToolRejection, ai as ToolResilience, aj as ToolResilienceError, ak as ToolRetryExhausted, al as ToolRouter, am as ToolSettlement, an as ToolThrown, ao as ToolTimedOut, ap as WiredToolCmd, aq as agentBootMsg, ar as agentCancelMsg, as as agentEvents, at as agentTurnSchema, au as compactionSummarySchema, av as fanOutInterpret, aw as isAgentTurn, ax as isCompactionSummary, ay as isReservedToolName, az as isStreamingModel, aA as liftAgent, aB as mergeInterpret, aC as plainModel, aD as status, aE as tool, aF as toolErrorReason, aG as toolRouter } from '../machine-BcfCFMYF.js';
-import { C as CtxArg, S as Store } from '../runtime-types-B62Ucnxr.js';
-import { E as EndedRun } from '../index-BOrsbdAf.js';
-export { M as MonitoredRunCmd, R as RunFailure } from '../index-BOrsbdAf.js';
+import { M as Machine, I as Interpret, S as Subscribe, H as HandlerCtx, C as Cmd } from '../core-Ce9ncpuv.js';
+import { b as DeadlinesSub } from '../index-e36uEyl4.js';
+export { a as DeadlineSub, m as deadlineSub, o as deadlinesSub, s as subscribeDeadline } from '../index-e36uEyl4.js';
+import { M as MessageContent, T as ToolCall, a as ToolOutcome, C as ContentPart, b as Conversation, c as AnyToolDef, d as ToolsCtx, e as AgentState, f as AgentTurn, g as ToolResult, A as AgentEvent, h as TurnChunk, i as AgentMachineMsg, W as WiredToolMsg, j as AgentCmd, k as ToolCmd, P as PlainModel, S as StreamingModel, l as ToolFailureOf, m as AgentTerminalFailure, N as NotReserved, n as ToolDef, o as ToolThrown, p as AgentEndedStatus, q as AgentConfigCore, r as CompactionPolicy, s as AgentKnob } from '../machine-CuojfZup.js';
+export { t as AGENT_EVENT_TYPES, u as AgentBootMsg, v as AgentCancelMsg, w as AgentCompactErrMsg, x as AgentCompactOkMsg, y as AgentCompactRunCmd, z as AgentCompactionConfig, B as AgentConfig, D as AgentEventHead, E as AgentFailure, F as AgentLifecycleNote, G as AgentLlmErrMsg, H as AgentLlmOkMsg, I as AgentLlmRunCmd, J as AgentSnapshotConfig, K as AgentStatus, L as AgentTimerMsg, O as AgentToMachine, Q as Awaiting, R as COMPACTION_PURPOSE, U as CompactInterpret, V as CompactionOutputs, X as CompactionPurpose, Y as CompactionSummary, Z as FILE_OMITTED, _ as FilePart, $ as IMAGE_OMITTED, a0 as ImagePart, a1 as Llm, a2 as LlmCall, a3 as LlmErr, a4 as LlmFailMsg, a5 as LlmOk, a6 as LlmRunCmd, a7 as LlmSucceedMsg, a8 as MediaSource, a9 as MessageLoader, aa as ModelFactory, ab as ModelPort, ac as ModelStream, ad as PLAIN_MODEL_MISROUTE_REASON, ae as ReservedToolName, af as Schema, ag as SnapshotInterpret, ah as TOOL_RETRY_EXHAUSTED_TAG, ai as TOOL_TIMEOUT_TAG, aj as TaggedFailure, ak as TextPart, al as ToolConstructors, am as ToolError, an as ToolFail, ao as ToolFailure, ap as ToolHandler, aq as ToolInput, ar as ToolMsg, as as ToolOk, at as ToolRecord, au as ToolRejectedCmd, av as ToolRejection, aw as ToolResilience, ax as ToolResilienceError, ay as ToolRetryExhausted, az as ToolRouter, aA as ToolSettlement, aB as ToolTimedOut, aC as TurnUsage, aD as WiredToolCmd, aE as agentBootMsg, aF as agentCancelMsg, aG as agentEvents, aH as agentTurnSchema, aI as compactionSummarySchema, aJ as contentParts, aK as fanOutInterpret, aL as isAgentTurn, aM as isCompactionSummary, aN as isReservedToolName, aO as isStreamingModel, aP as isTurnUsage, aQ as liftAgent, aR as mergeInterpret, aS as omitMedia, aT as plainModel, aU as status, aV as tool, aW as toolErrorReason, aX as toolRouter } from '../machine-CuojfZup.js';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { C as CtxArg, S as Store } from '../runtime-types-BKg2CGMx.js';
+import { E as EndedRun } from '../index-Dy3379ve.js';
+export { M as MonitoredRunCmd, R as RunFailure } from '../index-Dy3379ve.js';
 import { RetryPolicy } from '../retry-backoff/index.js';
-import '@standard-schema/spec';
-import '../types-DPm5YCDQ.js';
-import '../index-q1PoukOZ.js';
+import '../types-SzNSHKlV.js';
+import '../index-2kNxy6az.js';
 import '../protocol-ClRZBhHQ.js';
-import '../index-Cx0F2M34.js';
-import '../index-CcrKLtse.js';
-import '../index-CWmsXNdX.js';
+import '../index-Ce5GYAuI.js';
+import '../index-DWdg7R1l.js';
+import '../index-D8sYVzCI.js';
 
 /**
  * @demlik/tea/agent — `defineAgent`, the convenience layer over `createAgent`.
@@ -35,13 +35,19 @@ import '../index-CWmsXNdX.js';
  * adapter decides how a failure reads to its model. An `assistant` message
  * carries the turn's opaque `provider` slot exactly as the adapter returned it
  * (see `AgentTurn`), present only when the stored turn has one.
+ *
+ * A `user` message's content is a string or a list of {@link ContentPart}s —
+ * `contentParts` reads either as parts. A `tool` message carries `parts` beside
+ * its outcome when the tool declared `content` and settled `ok`: those parts
+ * are what the model should see (a screenshot, say), so an adapter sends them
+ * in place of the stringified result. No `parts` → the outcome is the payload.
  */
 type AgentMessage = {
     readonly role: "system";
     readonly content: string;
 } | {
     readonly role: "user";
-    readonly content: string;
+    readonly content: MessageContent;
 } | {
     readonly role: "assistant";
     readonly content: string;
@@ -52,7 +58,13 @@ type AgentMessage = {
     readonly callId: string;
     readonly name: string;
     readonly outcome: ToolOutcome<unknown>;
+    readonly parts?: readonly ContentPart[];
 };
+/**
+ * How `renderPrompt` reads the parts a settled call shows the model — a
+ * `ToolRouter`'s `partsOf`. `null` → the message carries no `parts`.
+ */
+type ToolPartsOf = (call: ToolCall, outcome: ToolOutcome<unknown>) => readonly ContentPart[] | null;
 /**
  * The brain-call payload `defineAgent` builds from the durable state — everything
  * `messagesOf` renders, so the prompt is a pure function of the Model and the
@@ -202,8 +214,9 @@ interface DefineAgentConfig<T extends AnyToolDef> {
      * the same terminal an aborted `signal` reaches, with the transcript intact
      * and no further model call made. Where `maxTurns` and `maxElapsedMs` bound
      * a quantity the agent counts for you and `deadlineMs` watches for a stall,
-     * this bounds whatever you name — a token ledger you keep, an external flag,
-     * a condition on the turns so far. Omit → no predicate.
+     * this bounds whatever you name — a token budget over `state.usage` (the
+     * run's provider-reported total), an external flag, a condition on the turns
+     * so far. Omit → no predicate.
      *
      * It must be PURE: the reducer calls it, so a replay hands it the same state
      * and must get the same answer. And it is config rather than Model — a
@@ -291,9 +304,14 @@ interface DefineAgentConfig<T extends AnyToolDef> {
     readonly toolConcurrency?: number;
 }
 /**
- * The lid's compaction budget: the two numbers that say when a transcript is
- * too long and how much of it survives the fold. Both are plain counts, so the
- * trigger they build is PURE — a replay re-decides identically, and no clock or
+ * The lid's compaction budget: when a transcript is too long, and how much of
+ * it survives the fold. "Too long" is a turn count (`afterTurns`), a context
+ * size (`afterContextTokens`), or both — whichever is reached first folds — and
+ * a budget naming neither is a compile error, because it could never fire.
+ *
+ * Both triggers read durable facts, so the trigger they build is PURE — a replay
+ * re-decides identically. The context size is what the PROVIDER reported on the
+ * last brain turn, journaled with that turn like its `content`; no clock and no
  * token estimate enters the Model (ADR 0004).
  *
  * This is deliberately a threshold rather than the core's `planCompaction`
@@ -302,12 +320,32 @@ interface DefineAgentConfig<T extends AnyToolDef> {
  * run that needs its own heuristic descends to `createAgent`, whose
  * `CompactionPolicy` this is built from.
  */
-interface DefineAgentCompaction {
+type DefineAgentCompaction = (CompactionTriggers & {
+    readonly afterTurns: number;
+    readonly afterContextTokens?: number;
+}) | (CompactionTriggers & {
+    readonly afterTurns?: number;
+    readonly afterContextTokens: number;
+});
+/** The fields every {@link DefineAgentCompaction} arm shares. */
+interface CompactionTriggers {
     /**
      * Fold once the conversation holds at least this many turns, counted BEFORE
      * the brain call about to fire. Must be at least `1`.
      */
-    readonly afterTurns: number;
+    readonly afterTurns?: number;
+    /**
+     * Fold once the latest context size — `inputTokens + outputTokens` the
+     * provider reported for the most recent brain turn — reaches this many
+     * tokens, checked BEFORE the brain call about to fire (#332). The number is
+     * yours: tea keeps no per-model window registry.
+     *
+     * A turn that reported no usage never fires it, and a fold clears the
+     * reading, so one reading folds at most once: the next fold waits for a turn
+     * to report what the shrunk transcript costs. It needs a `model` whose turns
+     * carry `usage`; with one that never reports it, this trigger never fires.
+     */
+    readonly afterContextTokens?: number;
     /**
      * How many of the NEWEST turns survive the fold intact, beside the summary.
      * Everything older becomes the summary's one synthetic head turn. Omit → `0`:
@@ -505,8 +543,119 @@ interface DefinedAgent<T extends AnyToolDef> {
  * defined agent, so `createAgent` is for a rebuild rather than for a detour.
  */
 declare function defineAgent<T extends AnyToolDef>(config: DefineAgentConfig<T>): DefinedAgent<T>;
-/** The prompt as messages: the head, then each turn with its tool outcomes. PURE. */
-declare function renderPrompt(prompt: AgentPrompt<unknown>): AgentMessage[];
+/**
+ * The prompt as messages: the head, then each turn with its tool outcomes.
+ * `partsOf` reads the parts a settled call shows the model; omit it and no
+ * `tool` message carries `parts`. PURE.
+ */
+declare function renderPrompt(prompt: AgentPrompt<unknown>, partsOf?: ToolPartsOf): AgentMessage[];
+
+/**
+ * @demlik/tea/agent — `agentTool()`: a child `defineAgent` as one tool a parent
+ * agent calls and awaits.
+ *
+ * The child is a durable run of its own, never a slice of the parent's Model:
+ * its `Store` and `runId` are keyed by the parent call's `callId` under a
+ * namespace the consumer reads off the parent's ctx. That key is the whole
+ * durability story. A parent resumed after an eviction re-fires the tool Cmd it
+ * was waiting on; the re-fired call reaches the same key, so `defineAgent`'s own
+ * `run` boots the child where its Store left it, or resolves a child that
+ * already ended without calling its model again. This is Temporal's child
+ * workflow (a re-issued start with the same id attaches to the same run),
+ * LangGraph's namespaced subgraph checkpoint and the OpenAI Agents SDK's
+ * `agent.as_tool()` (the parent keeps control and gets a result back).
+ */
+
+/** Why a child run ended `failed` — the reason `status()` reports for it. */
+type ChildFailureReason = AgentTerminalFailure<string>["reason"];
+/**
+ * The failures an agent tool settles with beside `thrown`. Each carries the
+ * child's `childRunId`, so the parent model's reason names the run a human can
+ * go and read. A child that `failed` also carries why — `turn_limit` when it hit
+ * its own `maxTurns`, `elapsed_limit`, `llm`, `deadline` or `stage`. A child that
+ * was `cancelled` (its `stopWhen` answered `true`) carries nothing more, because
+ * nothing went wrong.
+ */
+type AgentToolError = {
+    readonly _tag: "child_failed";
+    readonly childRunId: string;
+    readonly failure: ChildFailureReason;
+} | {
+    readonly _tag: "child_cancelled";
+    readonly childRunId: string;
+};
+/**
+ * How the child's ctx is derived from the parent's. Required when the child's
+ * tools read a ctx, and optional — defaulting to none — when they read nothing,
+ * the same rule `run`'s own `ctx` option follows.
+ */
+type ChildCtxOption<CT extends AnyToolDef, Ctx> = [
+    Record<never, never>
+] extends [DefinedAgentCtx<CT>] ? {
+    readonly childCtx?: (ctx: HandlerCtx<Ctx>) => DefinedAgentCtx<CT>;
+} : {
+    readonly childCtx: (ctx: HandlerCtx<Ctx>) => DefinedAgentCtx<CT>;
+};
+/** What `agentTool` takes. */
+type AgentToolSpec<Args, Ok, CT extends AnyToolDef, Ctx> = {
+    /** The model-facing sentence — the same field `tool()` declares. */
+    readonly description: string;
+    /** Parses the parent model's `args`. */
+    readonly input: StandardSchemaV1<unknown, Args>;
+    /** Parses what `result` returns, at the edge, like any tool's `ok`. */
+    readonly ok: StandardSchemaV1<unknown, Ok>;
+    /**
+     * The child. Its bounds (`maxTurns`, `maxElapsedMs`, `stopWhen`), its tools
+     * and its instructions are all its own definition's; the helper adds none.
+     */
+    readonly agent: DefinedAgent<CT>;
+    /**
+     * The child's whole input, derived from the call's args. It is the only thing
+     * the child is told: the parent's conversation never reaches it.
+     */
+    readonly prompt: (args: Args) => string;
+    /** The value the parent call settles with, read off the child's final turn. */
+    readonly result: (output: AgentTurn) => Ok;
+    /**
+     * The namespace the child run's key sits under, read off the parent's ctx —
+     * the parent run's id, a tenant, whatever keeps two parents' calls apart.
+     * The key is `<namespace>/<callId>`.
+     */
+    readonly namespace: (ctx: HandlerCtx<Ctx>) => string;
+    /**
+     * The child run's Store at `key`. The same key must reach the same durable
+     * cell on every call, in every process — that is what makes a re-fired call
+     * resume the child instead of restarting it.
+     */
+    readonly store: (key: string, ctx: HandlerCtx<Ctx>) => Store<DefinedAgentState<CT>>;
+} & ChildCtxOption<CT, Ctx>;
+/**
+ * Wrap a child `defineAgent` as a tool a parent `defineAgent` calls and awaits
+ * — pass it the child, how to phrase its input and how to read its answer, and
+ * get back a tool definition the parent's `tools` accepts like any `tool()`.
+ *
+ * A call runs the child to the end of its run and settles the parent's call:
+ *
+ *   - child `done` → `ok(result(output))`;
+ *   - child `failed` → `{ _tag: "child_failed", childRunId, failure }`;
+ *   - child `cancelled` → `{ _tag: "child_cancelled", childRunId }`.
+ *
+ * Both failures are data the parent model reads as the call's reason, so the
+ * parent run neither rejects nor throws when its child fails; it takes its next
+ * turn.
+ *
+ * The child's Store and `runId` are both the key `<namespace>/<callId>`. Firing
+ * the same call twice reaches the same child run, and a different call reaches
+ * a different one. So a parent killed while its child runs resumes the child
+ * from its Store when the tool Cmd re-fires: no settled child turn calls the
+ * model again, and no settled child tool runs again. A child that had already
+ * ended resolves with the outcome it recorded.
+ *
+ * It declares no `timeoutMs` and no `retry`. A timeout would settle the parent
+ * call while the child keeps running under the same key, and a retry of a child
+ * that ended `failed` reaches that same ended run and reads the same failure.
+ */
+declare function agentTool<const Name extends string, Args, Ok, CT extends AnyToolDef, Ctx = unknown>(name: Name & NotReserved<Name>, spec: AgentToolSpec<Args, Ok, CT, Ctx>): ToolDef<Name, Args, Ok, AgentToolError | ToolThrown, Ctx>;
 
 /**
  * @packageDocumentation
@@ -553,26 +702,24 @@ interface TranscriptToolResult<R> {
     readonly result: R;
 }
 /**
- * Whether the run has finished, and its terminal turn once it has.
+ * Whether the run has ended, and how: `running` until `RunDone`, then the
+ * ending it carried — `done` with the terminal turn, `failed` with the
+ * failure, or `cancelled`.
  *
- * The two cases are a union rather than a nullable `output` field because
- * `output` is legitimately `null` on a finished run — a `RunDone` with no
- * terminating turn — and a single field would make "not finished yet" and
- * "finished with nothing" the same reading.
+ * `done` keeps `output` inside its own arm because `output` is legitimately
+ * `null` on a finished run, and a single nullable field would make "not
+ * finished yet" and "finished with nothing" the same reading.
  */
 type TranscriptOutcome = {
     readonly kind: "running";
-} | {
-    readonly kind: "done";
-    readonly output: AgentTurn | null;
-};
+} | AgentEndedStatus;
 /** What a collector holds right now — a plain, immutable read. */
 interface TranscriptSnapshot<R> {
     /** Every model turn the transcript holds, in order. */
     readonly turns: readonly AgentTurn[];
     /** Every tool call that settled OK, in settle order. */
     readonly tools: readonly TranscriptToolResult<R>[];
-    /** Whether `RunDone` has been seen, and the terminal turn if so. */
+    /** Whether `RunDone` has been seen, and how the run ended if so. */
     readonly outcome: TranscriptOutcome;
 }
 /**
@@ -757,4 +904,4 @@ declare function createAgent<Stage, P extends string, O extends Record<P, AgentT
     readonly compaction?: never;
 }): AgentKnob<Stage, P, O, R, TC, false, false>;
 
-export { AgentCmd, AgentConfigCore, AgentEvent, AgentKnob, AgentMachineMsg, type AgentMessage, type AgentPrompt, AgentState, AgentTurn, AnyToolDef, CompactionPolicy, Conversation, DeadlinesSub, type DefineAgentCompaction, type DefineAgentConfig, type DefinedAgent, type DefinedAgentCmd, type DefinedAgentCtx, type DefinedAgentEvent, type DefinedAgentInterpret, type DefinedAgentMachine, type DefinedAgentModel, type DefinedAgentMsg, type DefinedAgentOverlay, type DefinedAgentResolvedState, type DefinedAgentRunOptions, type DefinedAgentState, type DefinedAgentWired, EndedRun, type InterpretOverlay, type LidPurpose, PlainModel, StreamingModel, ToolCall, ToolCmd, type ToolErrorContext, ToolFailureOf, ToolOutcome, ToolResult, ToolsCtx, type Transcript, type TranscriptOutcome, type TranscriptSeed, type TranscriptSnapshot, type TranscriptToolResult, TurnChunk, WiredToolMsg, createAgent, defineAgent, renderPrompt, transcript };
+export { AgentCmd, AgentConfigCore, AgentEndedStatus, AgentEvent, AgentKnob, AgentMachineMsg, type AgentMessage, type AgentPrompt, AgentState, AgentTerminalFailure, type AgentToolError, type AgentToolSpec, AgentTurn, AnyToolDef, type ChildFailureReason, CompactionPolicy, ContentPart, Conversation, DeadlinesSub, type DefineAgentCompaction, type DefineAgentConfig, type DefinedAgent, type DefinedAgentCmd, type DefinedAgentCtx, type DefinedAgentEvent, type DefinedAgentInterpret, type DefinedAgentMachine, type DefinedAgentModel, type DefinedAgentMsg, type DefinedAgentOverlay, type DefinedAgentResolvedState, type DefinedAgentRunOptions, type DefinedAgentState, type DefinedAgentWired, EndedRun, type InterpretOverlay, type LidPurpose, MessageContent, PlainModel, StreamingModel, ToolCall, ToolCmd, ToolDef, type ToolErrorContext, ToolFailureOf, ToolOutcome, type ToolPartsOf, ToolResult, ToolThrown, ToolsCtx, type Transcript, type TranscriptOutcome, type TranscriptSeed, type TranscriptSnapshot, type TranscriptToolResult, TurnChunk, WiredToolMsg, agentTool, createAgent, defineAgent, renderPrompt, transcript };

package/dist/agent/index.js

@@ -1,16 +1,16 @@
-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 } from '../chunk-XBZQT2TD.js';
-import '../chunk-G5E74IJB.js';
-import '../chunk-4PXNZ5UY.js';
-import '../chunk-4NTCPTNQ.js';
+export { AGENT_EVENT_TYPES, COMPACTION_PURPOSE, FILE_OMITTED, IMAGE_OMITTED, PLAIN_MODEL_MISROUTE_REASON, TOOL_RETRY_EXHAUSTED_TAG, TOOL_TIMEOUT_TAG, agentBootMsg, agentCancelMsg, agentEvents, agentTool, agentTurnSchema, compactionSummarySchema, contentParts, createAgent, defineAgent, fanOutInterpret, isAgentTurn, isCompactionSummary, isReservedToolName, isStreamingModel, isTurnUsage, liftAgent, mergeInterpret, omitMedia, plainModel, renderPrompt, status, tool, toolErrorReason, toolRouter, transcript } from '../chunk-PCJA2HTZ.js';
+import '../chunk-XVIKSRCK.js';
+import '../chunk-YIMOFXST.js';
 import '../chunk-QNGYQMZB.js';
-import '../chunk-TXN2KFHF.js';
-import '../chunk-6XBEYZME.js';
+import '../chunk-WTSOW2MD.js';
+export { deadlineSub, deadlinesSub, subscribeDeadline } from '../chunk-C3G2QFEZ.js';
 import '../chunk-VBDU4JL6.js';
 import '../chunk-4LPY67E4.js';
-export { deadlineSub, deadlinesSub, subscribeDeadline } from '../chunk-GWWCCSDH.js';
-import '../chunk-QWIPH4YH.js';
-import '../chunk-KWNCM6XM.js';
-import '../chunk-C4U5D5HP.js';
-import '../chunk-K4ETBNKS.js';
+import '../chunk-TXN2KFHF.js';
+import '../chunk-H2ELKHI6.js';
+import '../chunk-AHW2CLPT.js';
+import '../chunk-JVE2LBFJ.js';
+import '../chunk-FNGZMVIT.js';
+import '../chunk-AIIXV4XB.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{chunk-KWNCM6XM.js → chunk-AHW2CLPT.js}

@@ -1,13 +1,15 @@
-import { detachWork, DispatchDiscardedError, QuiescenceTimeoutError, RuntimeDiscardedError, IdentityDropNotice, checkedStep, cmdContractOver, Outcome, cmdEdge, isFencedStore, RuntimeDiscardNotice, DisposeTimeoutNotice, structuralHash, desiredSub } from './chunk-K4ETBNKS.js';
+import { restore } from './chunk-JVE2LBFJ.js';
+import { RuntimeDiscardNotice, detachWork, DispatchDiscardedError, QuiescenceTimeoutError, RuntimeDiscardedError, IdentityDropNotice, checkedStep, cmdContractOver, Outcome, cmdEdge, isFencedStore, DisposeTimeoutNotice, NoCellError, lookupCell, structuralHash, desiredSub, followUps } from './chunk-AIIXV4XB.js';
 
 // src/internal/engine/builtins.ts
-function supervision(declared) {
+function supervision(declared, machine) {
   const policy = declared === void 0 ? { strategy: "stop" } : typeof declared === "string" ? { strategy: declared } : declared;
   return (loop) => ({
     update: (next) => (state, msg) => {
       try {
         return next(state, msg);
       } catch (reduceError) {
+        if (isRefusal(machine, reduceError, state, msg)) throw reduceError;
         loop.report(reduceError, "reduce");
         switch (policy.strategy) {
           case "restart":
@@ -22,6 +24,9 @@ function supervision(declared) {
     }
   });
 }
+function isRefusal(machine, error, state, msg) {
+  return error instanceof NoCellError && lookupCell(machine, state, msg).cell === void 0;
+}
 function identityFilter(identity) {
   return (loop) => {
     if (identity === void 0) return {};
@@ -246,7 +251,7 @@ function telemetry(sink, clock) {
 function builtinExtensions(machine, opts) {
   const clock = opts.clock ?? Date.now;
   return [
-    supervision(opts.supervision),
+    supervision(opts.supervision, machine),
     identityFilter(machine.identity),
     devChecks(),
     cmdDefinitions(machine.cmds ?? [], clock),
@@ -270,6 +275,22 @@ function defaultOnError(error, _context) {
     throw error;
   }, 0);
 }
+var RuntimeStoppedError = class extends Error {
+  constructor(msgType) {
+    super("@demlik/tea: runtime stopped");
+    this.msgType = msgType;
+  }
+  msgType;
+};
+var RunningSub = class {
+  constructor(type) {
+    this.type = type;
+  }
+  type;
+  dispose = () => {
+  };
+  failed = false;
+};
 function startLoop(config) {
   const { idleCap, disposeTimeoutMs } = config;
   const onError = config.onError ?? defaultOnError;
@@ -387,7 +408,8 @@ function startLoop(config) {
         ([id, running]) => desired.has(id) || unreadTypes.has(running.type) ? [] : [id]
       )
     );
-    for (const [id, sub] of desired) {
+    const starting = gate === "open" ? desired : /* @__PURE__ */ new Map();
+    for (const [id, sub] of starting) {
       if (subRegistry.has(id)) continue;
       const runner = config.runnerFor(sub.type);
       if (runner === void 0) {
@@ -398,15 +420,40 @@ function startLoop(config) {
         );
         continue;
       }
+      const running = new RunningSub(sub.type);
       try {
-        const dispose = runner(sub, config.ctx, dispatchUnawaited);
-        subRegistry.set(id, { type: sub.type, dispose });
+        running.dispose = runner(
+          sub,
+          config.ctx,
+          dispatchUnawaited,
+          (error) => subFailed(id, running, error)
+        );
       } catch (err) {
         remember(err);
+        subFailed(id, running, err);
+        continue;
+      }
+      if (!running.failed) {
+        subRegistry.set(id, running);
+        continue;
+      }
+      try {
+        trackDisposal(running.dispose());
+      } catch (err) {
+        report(err, "sub-cleanup");
       }
     }
     if (firstError !== null) throw firstError;
   }
+  function subFailed(id, running, error) {
+    if (running.failed) return;
+    running.failed = true;
+    if (subRegistry.get(id) === running) subRegistry.delete(id);
+    report(error, "sub");
+    if (gate !== "open") return;
+    gate = "draining";
+    config.stopOnSubFailure(error);
+  }
   function dispatchUnawaited(msg) {
     enqueueDispatch(msg).catch(reportUndelivered);
   }
@@ -437,8 +484,8 @@ function startLoop(config) {
   }
   async function runCmds(cmds) {
     for (const cmd of cmds) {
-      const follow = await interpret(cmd, dispatchUnawaited);
-      if (follow !== void 0 && follow !== null) {
+      const returned = await interpret(cmd, dispatchUnawaited);
+      for (const follow of followUps(returned)) {
         enqueueDispatch(follow).catch(reportUndelivered);
       }
     }
@@ -447,8 +494,11 @@ function startLoop(config) {
     state = next;
     if (store) await store.save(next);
     reconcileSubs();
-    await runCmds(cmds);
-    for (const callback of commitCallbacks) callback(msg, next);
+    try {
+      await runCmds(cmds);
+    } finally {
+      for (const callback of commitCallbacks) callback(msg, next);
+    }
   }
   async function stepDispatch(msg) {
     if (state === void 0) {
@@ -461,16 +511,13 @@ function startLoop(config) {
   const storeless = store === void 0 ? config.init(null, config.ctx) : null;
   if (storeless !== null) state = storeless[0];
   async function boot() {
-    const [initial, cmds] = storeless ?? config.init(
-      store.migrate(await store.load()),
-      config.ctx
-    );
+    const [initial, cmds] = storeless ?? config.init(await restore(store), config.ctx);
     await commit(initial, void 0, cmds);
   }
   function enqueueDispatch(msg) {
     if (gate !== "open") {
       return Promise.reject(
-        gate === "draining" ? new DispatchDiscardedError(msg.type) : new Error("@demlik/tea: runtime stopped")
+        gate === "draining" ? new DispatchDiscardedError(msg.type) : new RuntimeStoppedError(msg.type)
       );
     }
     const next = tail.then(() => {
@@ -534,6 +581,6 @@ function startLoop(config) {
   return handle;
 }
 
-export { builtinExtensions, liveWork, startLoop };
-//# sourceMappingURL=chunk-KWNCM6XM.js.map
-//# sourceMappingURL=chunk-KWNCM6XM.js.map
+export { RuntimeStoppedError, builtinExtensions, defaultOnError, liveWork, startLoop };
+//# sourceMappingURL=chunk-AHW2CLPT.js.map
+//# sourceMappingURL=chunk-AHW2CLPT.js.map