@demlik/tea 0.1.0 → 0.1.1

package/dist/chunk-TAO4YOLO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/llm-call/index.ts"],"names":["msg"],"mappings":"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","file":"chunk-TAO4YOLO.js","sourcesContent":["/**\n * @demlik/tea/llm-call — `resilient-call` + structured-output parse + a typed\n * failure variant, around a purpose-discriminated LLM invocation.\n *\n * This is the ~60-line `call_llm` handler from the audit-agent seed\n * (`interpret.ts` / `effects.ts`) collapsed into the uniform L2 knob: a config\n * object, the resilient-call slice it inherits, and one interpret handler that\n * assembles messages, binds the structured-output schema for the call's\n * `purpose`, invokes the model (retry composed from `../resilient-call`, NOT\n * reinvented), parses the output, and RETURNS the enriched resilient settle Msg\n * (`resilient_ok` / `resilient_err`) so it re-enters the host reducer and drives\n * the inherited succeed/fail → backoff → onTimer loop.\n *\n * ## What it adds over `../resilient-call`\n *\n *   - **Two DI ports** (the seed's two seams):\n *       1. `model: (modelId) => LLM` — the model factory. Tests pass a fake so\n *          the handler runs end-to-end without touching a real provider; the\n *          production worker wires `createChatModel(env, …)`.\n *       2. `loadMessages: Loader` — the SDK / message loader. The seed lazy-\n *          imports `@langchain/core/messages` (a top-level `import type` blows\n *          up the workers test runner); the loader keeps that import lazy and\n *          stubbable. It produces the `BaseMessage[]` for a given call.\n *   - **Structured-output parse** — each `purpose` maps to a `Schema` in\n *     `config.schemas`. The handler binds `model.withStructuredOutput(schema)`\n *     so the invoke resolves to a typed object; a `Schema.parse` that throws\n *     becomes a `resilient_err` carrying an `LlmErr` (a parse failure is a\n *     failure, not a stall — \"errors are data\"). `withStructuredOutput` is the\n *     seed's brain-only path; the fake model in tests returns the typed object\n *     directly.\n *   - **A typed failure variant** — every failure (model throw, timeout-via-\n *     retry-exhaustion, schema parse) is surfaced as the `LlmErr` carried on the\n *     enriched `resilient_err` settle Msg, tagged with the `purpose` so the\n *     consumer's reducer routes per-stage. The seed dispatched\n *     `llm_failed{purpose}`; the consumer rebuilds that shape in its reducer arm\n *     from `m.error: LlmErr`.\n *\n * ## Inheriting resilient-call by composition (not reinvention)\n *\n * The retry / backoff lives in `../resilient-call`: `createLlmCall` builds a\n * `createResilientCall` knob over the model-invoke port and DELEGATES `init`,\n * `attempt`, `succeed`, `fail`, `onTimer`, `subs` to it verbatim — the slice is\n * literally resilient-call's slice (the spec's \"retry lives here\"). There is no\n * second backoff implementation here. The handler runs the invoke through the\n * resilient-call handler so a transient model failure backs off exactly as a\n * resilient HTTP call would; the `purpose`-branch + structured parse wrap the\n * port the resilient handler drives.\n *\n * ## The two non-negotiables (canon, inherited)\n *\n *   - **Durable** — the slice is resilient-call's plain-data slice (a Model\n *     field). Input carried on the `resilient_run` Cmd is the plain\n *     `LlmCall` request (purpose + modelId + payload) — no closures.\n *   - **Replayable** — every transition is a resilient-call verb; the handler\n *     is the only impurity, and the one clock read is `Date.now()` at the\n *     effect boundary (inside the handler), exactly as the seed stamped its\n *     `llm_responded` / `llm_failed` Msgs.\n *\n * ## Typical wiring\n *\n *   const llm = createLlmCall<MyPurpose, MyOutputs>({\n *     model: (id) => createChatModel(env, id),\n *     schemas: { plan: planSchema, report: reportSchema },\n *     retry: defaultRetryPolicy,\n *     loadMessages: defaultMessagesLoader,\n *   });\n *\n *   // in the machine:\n *   init: () => [{ resilience: llm.init() }, []],\n *   update: {\n *     call_llm:  (s, m) => lift(s, llm.attempt(s.resilience, m.input, m.at)),\n *     // `resilient_ok` / `resilient_err` RE-ENTER from `handlers` (the settle\n *     // Msg the interpret handler returns). Run the inherited verb FIRST so the\n *     // succeed/fail → backoff → onTimer loop advances, THEN fold the enriched\n *     // payload (`m.result: LlmOk` / `m.error: LlmErr`) into the host's own\n *     // state — the enrichment lives in the reducer arm, not the handler.\n *     resilient_ok:  (s, m) => {\n *       const [slice, cmds] = llm.succeed(s.resilience, m.key, m);\n *       return [{ ...s, resilience: slice, output: m.result.output }, cmds];\n *     },\n *     resilient_err: (s, m) => {\n *       const [slice, cmds] = llm.fail(s.resilience, m.key, m);\n *       return [{ ...s, resilience: slice, failure: m.error }, cmds];\n *     },\n *     deadline_exceeded: (s, m) => lift(s, llm.onTimer(s.resilience, m)),\n *   },\n *   subscriptions: (s) => llm.subs(s.resilience),\n *   subscribe: { deadline: subscribeDeadline },\n *   interpret: llm.handlers(),\n */\n\nimport type { Cmd } from \"../index\";\nimport { MsgType } from \"../protocol\";\nimport {\n  createResilientCall,\n  type DeadlineExceeded,\n  type DeadlineSub,\n  deadlineSub,\n  type FailMsg,\n  liftResilience,\n  type ResilientConfig,\n  type ResilientState,\n  type RunCmd,\n  type SucceedMsg,\n  subscribeDeadline,\n} from \"../resilient-call\";\nimport type { RetryPolicy } from \"../retry-backoff\";\n\n// ===========================================================================\n// The DI port surfaces — model factory + structured output + message loader.\n// ===========================================================================\n\n/**\n * The minimal structured-output schema contract: `parse(unknown) => T`, the\n * zod-style call the handler uses to validate the model's output before it\n * settles `resilient_ok`. A throwing `parse` (the zod contract on invalid\n * input) propagates out of `invokeOne` and is caught by the resilient handler,\n * which settles `resilient_err` (enriched to `LlmErr`) — a parse failure is a\n * failure, never a silent pass. Structural so a real `z.ZodType<T>` satisfies\n * it without an import.\n */\nexport interface Schema<T> {\n  /** Validate + narrow `value` to `T`, or throw on mismatch (the zod contract). */\n  parse(value: unknown): T;\n}\n\n/**\n * The minimal chat-model contract every model the handler talks to must\n * satisfy — the seed's `InjectableChatModel`, trimmed to the one operation\n * llm-call drives for brain-only stages:\n *\n *   `withStructuredOutput(schema)` → a runnable whose `invoke(messages)`\n *   resolves to a typed object matching `schema`.\n *\n * `BaseChatModel` from `@langchain/core` is the runtime type; this surface\n * names only what llm-call calls so a test fake can ignore the rest. Generic\n * over the message shape `Msg` so a consumer's loader and model agree on it\n * without llm-call inspecting messages.\n */\nexport interface Llm<Msg> {\n  withStructuredOutput<T>(schema: Schema<T>): {\n    invoke(messages: readonly Msg[]): Promise<T>;\n  };\n}\n\n/**\n * Build the `Msg[]` the handler hands to the bound model for a given call. The\n * SDK / message-assembly seam — the seed's `buildBaseMessages` + the lazy\n * `loadMessages` loader rolled into one injected port. Async because the seed\n * lazy-imports the SDK (a top-level `import type` of the langchain messages\n * package explodes the workers test runner). Receives the full `LlmCall` so it\n * can branch on `purpose` exactly as the seed's `buildBaseMessages` did.\n */\nexport type MessageLoader<P extends string, Msg> = (\n  call: LlmCall<P>,\n) => Promise<readonly Msg[]>;\n\n/**\n * The model factory — the first DI port. `(modelId) => Llm`. Tests pass a fake\n * builder; production wires `createChatModel(env, getModelConfig(id))`. `null`\n * means \"the host's default model\" (the seed's `string | null`).\n */\nexport type ModelFactory<Msg> = (modelId: string | null) => Llm<Msg>;\n\n// ===========================================================================\n// Config — the knob. `model` + `schemas` required (the two DI ports + the\n// per-purpose parse target); `retry` + `loadMessages` optional.\n// ===========================================================================\n\n/**\n * The llm-call knob. `model` and `schemas` are the load-bearing pair — the\n * model factory DI port and the per-purpose structured-output targets; the\n * rest is optional, exactly the resilient-call \"omit a brick → omit its gate\"\n * story for `retry`:\n *\n *   - `model`        — DI port 1: the model factory.\n *   - `schemas`      — one `Schema` per `Purpose`. The handler binds\n *                      `schemas[call.purpose]` as the structured-output target.\n *   - `retry`        — backoff policy, composed straight into `../resilient-\n *                      call`. Omit it and a model failure is terminal (no\n *                      backoff), exactly as resilient-call with no retry brick.\n *   - `loadMessages` — DI port 2: the SDK / message loader. Omit it and the\n *                      handler invokes the bound model with `[]` (a degenerate\n *                      but valid call) — provide it to assemble real messages.\n *\n * `P` is the purpose union (e.g. `\"plan\" | \"report\"`); `O` maps each purpose to\n * its parsed output type; `Msg` is the model's message shape (threaded through\n * the loader + model so llm-call never inspects a message).\n */\nexport interface LlmCallConfig<\n  P extends string,\n  O extends Record<P, unknown>,\n  Msg = unknown,\n> {\n  /** DI port 1 — the model factory. `(modelId) => Llm`. */\n  readonly model: ModelFactory<Msg>;\n  /** One structured-output schema per purpose; the parse target the handler binds. */\n  readonly schemas: { readonly [K in P]: Schema<O[K]> };\n  /** Backoff policy, composed into `../resilient-call`. Omit → no backoff. */\n  readonly retry?: RetryPolicy;\n  /** DI port 2 — the SDK / message loader. Omit → the handler invokes with `[]`. */\n  readonly loadMessages?: MessageLoader<P, Msg>;\n}\n\n// ===========================================================================\n// The request / response shapes the knob speaks.\n// ===========================================================================\n\n/**\n * One LLM call request — the resilient-call `input` for this knob, carried on\n * the `resilient_run` Cmd as plain data (no closures, invariant 3). Mirrors the\n * seed's purpose-discriminated `CallLlmCmd`: a `purpose` selecting the schema +\n * prompt assembly, the `model` id, and the opaque per-purpose `payload` the\n * loader consumes.\n *\n * `key` defaults to `purpose` when the consumer calls `attempt(s, purpose, …)`,\n * so one in-flight call per purpose is tracked under the resilient-call slice —\n * the common single-call-per-stage shape. A consumer that fans out many calls\n * of one purpose passes a distinct `key`.\n */\nexport interface LlmCall<P extends string> {\n  /** The stage / schema selector — drives both `schemas[purpose]` and message assembly. */\n  readonly purpose: P;\n  /** The model id to invoke; `null` = the host's default model. */\n  readonly model: string | null;\n  /** The per-purpose prompt payload the `MessageLoader` consumes. Opaque to the knob. */\n  readonly payload: unknown;\n}\n\n/** The parsed, typed success carried on the `resilient_ok` settle Msg, tagged with its purpose. */\nexport interface LlmOk<P extends string, O extends Record<P, unknown>> {\n  readonly key: string;\n  readonly purpose: P;\n  readonly output: O[P];\n}\n\n/** The typed failure variant — every failure path surfaces this, tagged by purpose. */\nexport interface LlmErr<P extends string> {\n  readonly key: string;\n  readonly purpose: P;\n  /** A human-readable cause (model throw, retry-exhaustion, or schema parse). */\n  readonly reason: string;\n  /** The original error, carried untouched for the consumer to inspect. */\n  readonly error: unknown;\n}\n\n/**\n * The settle Msgs llm-call's handler RETURNS from `interpret` so the substrate\n * enqueues them as follow-up Msgs (re-entry) into the host reducer — exactly as\n * `../resilient-call` does. They are the resilient-call settle Msgs with the\n * payloads ENRICHED to llm-call's typed variants: `result` is the parsed,\n * purpose-tagged `LlmOk`; `error` is the typed `LlmErr` (purpose + reason +\n * raw). The host wires `resilient_ok` → `succeed` and `resilient_err` → `fail`\n * reducer arms (the doc-comment wiring), and folds the enriched payload into its\n * own state there — llm-call never forces a Msg vocabulary on the host, and the\n * settle Msg drives the inherited succeed/fail → backoff → onTimer loop instead\n * of bypassing it.\n */\n//\n// The success Msg is `../resilient-call`'s `SucceedMsg` specialized to the parsed\n// `LlmOk` result — NOT a re-declared shape — so the verb returns (`succeed`'s\n// argument, the handler's resolve) thread through with no cast. The failure Msg\n// is the resilient `FailMsg` with its `error: unknown` NARROWED to the typed\n// `LlmErr`: every value the handler enriches is an `LlmErr`, and `LlmErr` is\n// assignable to `unknown`, so `LlmFailMsg` flows into `rc.fail` (which takes the\n// wide `FailMsg`) directly while the host reducer reads the narrow `error` type.\nexport type LlmSucceedMsg<\n  P extends string,\n  O extends Record<P, unknown>,\n> = SucceedMsg<LlmOk<P, O>>;\nexport type LlmFailMsg<P extends string> = Omit<FailMsg, \"error\"> & {\n  readonly error: LlmErr<P>;\n};\n\n/** The retry / deadline timer Msg — `DeadlineExceeded`, inherited from resilient-call. */\nexport type LlmTimerMsg = DeadlineExceeded;\n\n/**\n * The ports the LEGACY detached `handlers(ports)` form takes. Two outbound Msg\n * builders the handler hands the typed Ok / Err; the consumer returns its own\n * Msg (or `undefined`). KEPT only for `../agent`, which still inherits the\n * detached shape; that path does NOT drive the retry loop (it dispatches the\n * consumer's Msg directly and never re-enters the resilient settle Msg). New\n * consumers use the no-arg `handlers()` form, which RETURNS the settle Msg for\n * re-entry and drives the inherited succeed/fail → backoff → onTimer loop.\n * `../agent` carries the same retry-loop gap and is fixed separately.\n *\n * The builders return `M | undefined` — `undefined` is the \"dispatch nothing\"\n * sentinel the detached form checks (`!== undefined`), spelled as `undefined`\n * rather than `void` so the union is unambiguous (a `void` member of a union is\n * confusing and reads as \"may return anything\").\n */\nexport interface LlmCallPorts<\n  P extends string,\n  O extends Record<P, unknown>,\n  M,\n> {\n  /** Build the Msg dispatched on a parsed success. Return `undefined` to dispatch nothing. */\n  readonly onOk: (ok: LlmOk<P, O>) => M | undefined;\n  /** Build the Msg dispatched on any failure (throw / retry-exhausted / parse). */\n  readonly onErr: (err: LlmErr<P>) => M | undefined;\n}\n\n/**\n * The effect Cmd the knob emits: run the LLM call for `key` with `input`. The\n * `input` is the plain `LlmCall` request — the handler reads `purpose` /\n * `model` / `payload` off it (invariant 3: Cmds are data).\n *\n * It is `../resilient-call`'s `RunCmd` specialized to the `LlmCall` input — NOT a\n * re-declared shape — so the resilient verbs' return tuples (`[State, RunCmd[]]`)\n * are this exact type and thread through `attempt` / `succeed` / `fail` /\n * `onTimer` with no cast.\n */\nexport type LlmRunCmd<P extends string> = RunCmd<LlmCall<P>>;\n\n// ===========================================================================\n// The knob factory.\n// ===========================================================================\n\n/**\n * Build an llm-call knob from `config`. `rng` is injected for the inherited\n * retry jitter (pass a fixed `() => 0.5` in tests to pin backoff; defaults to\n * `Math.random`, read only at the resilient-call verb boundary).\n *\n * Returns the uniform L2 knob contract. The slice + verbs (`init`, `attempt`,\n * `succeed`, `fail`, `onTimer`, `subs`) are DELEGATED to a `../resilient-call`\n * knob built over the structured-output model-invoke port — no second backoff\n * here. `handlers` is the one new piece: the purpose-branching, schema-parsing\n * wrapper that returns the enriched resilient settle Msg for re-entry.\n *\n * `P` is the purpose union, `O` the purpose→output map, `Msg` the model's\n * message shape.\n */\nexport function createLlmCall<\n  P extends string,\n  O extends Record<P, unknown>,\n  Msg = unknown,\n>(config: LlmCallConfig<P, O, Msg>, rng: () => number = Math.random) {\n  // ---- The composed resilient-call knob ----------------------------------\n  //\n  // The resilient-call input is the full `LlmCall` request; its result is the\n  // PARSED, typed `LlmOk`. Only the `retry` brick is forwarded — llm-call does\n  // not expose circuit / rate-limit / cache / deadline knobs (a stage call is\n  // a single brain invocation, not a keyed downstream target). Omitting those\n  // bricks omits their gates, exactly as resilient-call documents.\n  const resilientConfig: ResilientConfig = {\n    ...(config.retry === undefined ? {} : { retry: config.retry }),\n  };\n  const rc = createResilientCall<LlmCall<P>, LlmOk<P, O>>(resilientConfig, rng);\n\n  /** The slice this knob owns — resilient-call's slice verbatim. */\n  type State = ResilientState<LlmCall<P>, LlmOk<P, O>>;\n\n  /** The starting slice — resilient-call's. */\n  function init(): State {\n    return rc.init();\n  }\n\n  /**\n   * Start (or restart) an LLM call. `keyOrPurpose` defaults the resilient-call\n   * `key` to the call's `purpose` so one in-flight call per stage is tracked\n   * under the slice (the common shape); pass a distinct key to fan out. PURE —\n   * delegates straight to resilient-call's gate.\n   */\n  function attempt(\n    s: State,\n    input: LlmCall<P>,\n    at: number,\n    key: string = input.purpose,\n  ): readonly [State, readonly LlmRunCmd<P>[]] {\n    return rc.attempt(s, key, input, at);\n  }\n\n  /** Record a parsed success for `key`. PURE — resilient-call's `succeed`. */\n  function succeed(\n    s: State,\n    key: string,\n    msg: LlmSucceedMsg<P, O>,\n  ): readonly [State, readonly LlmRunCmd<P>[]] {\n    return rc.succeed(s, key, msg);\n  }\n\n  /**\n   * Record a failure for `key`: back off via the inherited retry, or settle\n   * `failed`. PURE — resilient-call's `fail`. The `error` is the typed\n   * `LlmErr`, carried on the call's `failed` phase for the consumer to read.\n   */\n  function fail(\n    s: State,\n    key: string,\n    msg: LlmFailMsg<P>,\n  ): readonly [State, readonly LlmRunCmd<P>[]] {\n    return rc.fail(s, key, msg);\n  }\n\n  /** A retry / deadline timer fired. PURE — resilient-call's `onTimer`. */\n  function onTimer(\n    s: State,\n    msg: LlmTimerMsg,\n  ): readonly [State, readonly LlmRunCmd<P>[]] {\n    return rc.onTimer(s, msg);\n  }\n\n  /** Pre-wired subs — resilient-call's retry-timer subscriptions. */\n  function subs(s: State): readonly DeadlineSub[] {\n    return rc.subs(s);\n  }\n\n  // ---- The model-invoke port the resilient handler drives ----------------\n\n  /**\n   * Run ONE LLM call: assemble messages via the loader, bind the purpose's\n   * structured-output schema, invoke, and parse. Returns the typed `LlmOk` on\n   * success; throws on any failure (model throw OR schema parse) so the\n   * resilient-call handler routes it to a failure Msg + backoff. This is the\n   * single port resilient-call wraps — the retry / timeout machinery lives in\n   * resilient-call, never here (\"do NOT reinvent backoff\").\n   *\n   * The seed's two paths collapse to one: every brain-only purpose goes through\n   * `withStructuredOutput(schema)`. The `parse` re-validates the output (a fake\n   * model might skip validation, and a real provider can drift) so a malformed\n   * structured response is a failure, not a corrupt success.\n   */\n  async function invokeOne(input: LlmCall<P>): Promise<LlmOk<P, O>> {\n    const model = config.model(input.model);\n    const messages = config.loadMessages\n      ? await config.loadMessages(input)\n      : [];\n    const schema = config.schemas[input.purpose];\n    const structured = model.withStructuredOutput(schema);\n    const raw = await structured.invoke(messages);\n    // Re-validate at the boundary — a parse throw becomes a `resilient_err`\n    // (enriched to `LlmErr`) settle Msg upstream, never a corrupt success.\n    const output = schema.parse(raw);\n    return { key: input.purpose, purpose: input.purpose, output };\n  }\n\n  // ---- Handlers — the one new piece, composed onto resilient-call --------\n\n  /**\n   * Pre-wired interpret handler for `resilient_run`. Composes\n   * `../resilient-call`'s `resilient_run` handler over the `invokeOne` port and\n   * RETURNS the resilient settle Msg — it does NOT dispatch the consumer's Msg\n   * itself. Returning the settle Msg is the whole point: the substrate enqueues\n   * an interpret handler's returned Msg as a FOLLOW-UP (re-entry) onto the\n   * dispatch tail, so the host reducer's `resilient_ok` / `resilient_err` arms\n   * run `succeed` / `fail`, which advances the inherited retry loop\n   * (succeed/fail → backoff → onTimer → re-issue). A handler that instead\n   * `dispatch`ed an enriched Msg directly would settle ONE invoke and bypass\n   * that loop entirely — the slice would never leave `running`, the breaker\n   * would never trip/close, and the retry counter would never reset.\n   *\n   * Resilience is composed, not reimplemented: the body delegates to the\n   * resilient-call handler's Railway-routed invoke (Ok → `resilient_ok`, Err →\n   * `resilient_err`), so a transient model failure backs off via the inherited\n   * retry exactly as resilient-call decides. The ONE enrichment llm-call adds is\n   * mapping the settle PAYLOADS into its typed variants:\n   *\n   *   - success → `result` is already the parsed `LlmOk` (`invokeOne` returns\n   *     it), so the resilient `resilient_ok` Msg is the llm-call `LlmSucceedMsg`\n   *     as-is.\n   *   - failure → the resilient `resilient_err` carries the RAW throw (a model\n   *     503 or a `schema.parse` throw). We rebuild it into the typed `LlmErr`\n   *     (purpose + reason + raw) so the host reducer routes per-stage.\n   *\n   * The host folds the enriched payload into its own state in the reducer arm\n   * (the doc-comment wiring), NOT here — the handler stays the one impurity\n   * (the `invokeOne` await + the `Date.now()` stamp the resilient handler makes)\n   * and the reducer stays pure.\n   */\n  // The resilient-call `resilient_run` handler over `invokeOne` — the shared\n  // Railway-routed invoke (Ok → resilient_ok Msg, Err → resilient_err Msg). Both\n  // handler forms below build on it; the settle shape is composed, not reinvented.\n  const resilientRunHandler = rc.handlers({\n    run: (input) => invokeOne(input),\n  }).resilient_run;\n\n  /**\n   * Await one composed invoke and resolve to the ENRICHED resilient settle Msg\n   * (`resilient_ok` carrying the parsed `LlmOk`, or `resilient_err` carrying the\n   * typed `LlmErr`). The shared core both handler forms reuse.\n   */\n  async function settleOf(\n    cmd: LlmRunCmd<P>,\n  ): Promise<LlmSucceedMsg<P, O> | LlmFailMsg<P>> {\n    // `resilientRunHandler` never rejects (tryInterpret contract) — it resolves\n    // to a `resilient_ok` / `resilient_err` settle Msg stamped with `Date.now()`.\n    // Its `ctx` slot is `NoCtx` (the resilient-call work fn reads no ctx — a\n    // DELIBERATE context-free seam, not accidental `unknown`), so the empty\n    // record satisfies it without a cast.\n    const settle = await resilientRunHandler(cmd, {});\n    if (settle.type === MsgType.ResilientOk) {\n      // `result` is the parsed `LlmOk` from `invokeOne`, and the narrowed\n      // `SucceedMsg<LlmOk>` IS `LlmSucceedMsg` — returned as-is, no cast.\n      return settle;\n    }\n    // resilient_err — enrich the raw throw into the typed `LlmErr`, keeping the\n    // resilient Msg's `key` / `at` so the host reducer's `fail` verb re-issues\n    // from the remembered input and backs off on schedule.\n    const rawError: unknown = settle.error;\n    const err: LlmErr<P> = {\n      key: cmd.key,\n      purpose: cmd.input.purpose,\n      reason: rawError instanceof Error ? rawError.message : String(rawError),\n      error: rawError,\n    };\n    return {\n      type: MsgType.ResilientErr,\n      key: settle.key,\n      error: err,\n      at: settle.at,\n    };\n  }\n\n  /**\n   * Pre-wired interpret handler for `resilient_run`. TWO forms:\n   *\n   *   - `handlers()` (no args, the FIXED primary) — RETURNS the enriched\n   *     resilient settle Msg. The substrate enqueues an interpret handler's\n   *     returned Msg as a FOLLOW-UP (re-entry) onto the dispatch tail, so the\n   *     host reducer's `resilient_ok` / `resilient_err` arms run `succeed` /\n   *     `fail`, advancing the inherited retry loop (succeed/fail → backoff →\n   *     onTimer → re-issue). This is the correct wiring; the module doc shows it.\n   *\n   *   - `handlers(ports)` (LEGACY, detached) — runs the invoke inside\n   *     `ctx.waitUntil` and dispatches the consumer's `onOk` / `onErr` Msg\n   *     directly. KEPT only for `../agent`, which still inherits this shape. It\n   *     does NOT drive the retry loop (it never re-enters the settle Msg, so\n   *     `succeed` / `fail` never run) — `../agent` carries the same gap and is\n   *     fixed in its own pass. New consumers MUST use the no-arg form.\n   *\n   * Resilience is composed, not reimplemented: both forms delegate to the\n   * resilient-call handler's Railway-routed invoke and add only the typed\n   * `LlmOk` / `LlmErr` enrichment. The ONE impurity is the `invokeOne` await +\n   * the `Date.now()` stamp the resilient handler makes; the reducer stays pure.\n   */\n  function handlers(): {\n    resilient_run: (\n      cmd: LlmRunCmd<P>,\n    ) => Promise<LlmSucceedMsg<P, O> | LlmFailMsg<P>>;\n  };\n  function handlers<M>(ports: LlmCallPorts<P, O, M>): {\n    resilient_run: (\n      cmd: LlmRunCmd<P>,\n      ctx: { waitUntil(p: Promise<unknown>): void; dispatch(msg: M): unknown },\n    ) => void;\n  };\n  function handlers<M>(ports?: LlmCallPorts<P, O, M>) {\n    if (ports === undefined) {\n      // FIXED primary: return the settle Msg for re-entry — drives the loop.\n      return { resilient_run: (cmd: LlmRunCmd<P>) => settleOf(cmd) };\n    }\n    // LEGACY detached form — kept for `../agent` (see doc above). Dispatches the\n    // consumer's Msg directly; does not re-enter the settle Msg.\n    return {\n      resilient_run: (\n        cmd: LlmRunCmd<P>,\n        ctx: {\n          waitUntil(p: Promise<unknown>): void;\n          dispatch(msg: M): unknown;\n        },\n      ): void => {\n        const fired = (async () => {\n          const settle = await settleOf(cmd);\n          if (settle.type === MsgType.ResilientOk) {\n            const msg = ports.onOk(settle.result);\n            if (msg !== undefined) await ctx.dispatch(msg);\n            return;\n          }\n          const msg = ports.onErr(settle.error);\n          if (msg !== undefined) await ctx.dispatch(msg);\n        })();\n        ctx.waitUntil(fired);\n      },\n    };\n  }\n\n  return { init, attempt, succeed, fail, onTimer, subs, handlers, invokeOne };\n}\n\n/**\n * Lift a knob result `[slice, cmds]` into a host `[State, cmds]` where the\n * slice lives at `state.resilience` — the same convenience `../resilient-call`\n * ships, re-typed for the llm-call slice so consumers wire one import. Pure.\n */\nexport function liftLlmCall<\n  S extends { resilience: ResilientState<LlmCall<P>, LlmOk<P, O>> },\n  P extends string,\n  O extends Record<P, unknown>,\n  C extends Cmd,\n>(\n  state: S,\n  result: readonly [ResilientState<LlmCall<P>, LlmOk<P, O>>, readonly C[]],\n): readonly [S, readonly C[]] {\n  return liftResilience(state, result);\n}\n\n/**\n * Re-export the deadline Sub primitives (inherited from resilient-call) so\n * consumers wire one import: `subscribeDeadline` is the `subscribe` cell,\n * `deadlineSub` builds the Sub literal `subs` emits.\n */\nexport { subscribeDeadline, deadlineSub };\nexport type { DeadlineSub, DeadlineExceeded, ResilientState };\n"]}

package/dist/chunk-TC4HWABA.js

@@ -0,0 +1,506 @@
+import { createLlmCall } from './chunk-TAO4YOLO.js';
+import { createMonitoredRun } from './chunk-D5EQDLDV.js';
+import { createResilientCall } from './chunk-RVJFGRGK.js';
+import { MsgType } from './chunk-JELSZN25.js';
+import { createFanOut, initFanOut } from './chunk-UV6UWGEO.js';
+import { subscribeDeadline } from './chunk-QGZW4W3E.js';
+import { defineMachine } from './chunk-2WZHS4P2.js';
+
+// src/agent/index.ts
+function isAgentTurn(value) {
+  if (value === null || typeof value !== "object") return false;
+  const t = value;
+  return typeof t.content === "string" && Array.isArray(t.toolCalls);
+}
+var agentTurnSchema = {
+  parse: (value) => {
+    if (!isAgentTurn(value)) {
+      throw new Error("structured-output parse failed: not an AgentTurn");
+    }
+    return value;
+  }
+};
+var COMPACTION_PURPOSE = "$compact";
+function isCompactionSummary(value) {
+  if (value === null || typeof value !== "object") return false;
+  return typeof value.summary === "string";
+}
+var compactionSummarySchema = {
+  parse: (value) => {
+    if (!isCompactionSummary(value)) {
+      throw new Error(
+        "structured-output parse failed: not a CompactionSummary"
+      );
+    }
+    return value;
+  }
+};
+function status(s) {
+  if (s.failure !== null) {
+    return { kind: "failed", failure: s.failure };
+  }
+  if (s.run.phase === "failed" && s.run.failure !== null) {
+    return { kind: "failed", failure: s.run.failure };
+  }
+  if (s.run.phase === "done") {
+    return { kind: "done", output: s.output };
+  }
+  if (s.conversation !== null && s.conversation.awaiting.kind === "tools") {
+    return { kind: "suspended", pending: s.tools.running };
+  }
+  return { kind: "running" };
+}
+function createAgent(config) {
+  const rng = config.rng ?? Math.random;
+  const run = 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)
+  });
+  function init() {
+    return {
+      run: run.init(),
+      resilience: llm.init(),
+      tools: initFanOut(),
+      conversation: null,
+      compaction: compactRc.init(),
+      failure: null,
+      output: null
+    };
+  }
+  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 brainCall(s) {
+    const stage = currentStage(s);
+    const conversation = s.conversation ?? freshConversation();
+    return {
+      purpose: config.turnOf(stage),
+      model: config.modelId ?? null,
+      payload: config.payloadOf ? config.payloadOf(stage, conversation) : null
+    };
+  }
+  function start(s, runId, at) {
+    const [runSlice] = run.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()
+    };
+    const call = brainCall(withRun);
+    const [resilience, cmds] = llm.attempt(withRun.resilience, call, at);
+    return [{ ...withRun, resilience }, cmds];
+  }
+  function turn(s, result, at) {
+    if (isSettled(s)) return [s, []];
+    const conv = s.conversation;
+    if (conv === null || conv.awaiting.kind !== "llm") 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, launchCmds] = fan.scatter(
+      initFanOut(),
+      batch
+    );
+    const nextConv = {
+      ...withTurn,
+      awaiting: { kind: "tools", batchTurn: withTurn.turnCount }
+    };
+    const [runSlice] = run.progress(s.run, void 0, at);
+    return [{ ...s, run: runSlice, tools, conversation: nextConv }, launchCmds];
+  }
+  function advanceStage(s, terminatingTurn, at) {
+    const [runSlice, runCmds] = run.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 call = brainCall(moved);
+    const [resilience, llmCmds] = llm.attempt(moved.resilience, call, at);
+    return [{ ...moved, resilience }, [...runCmds, ...llmCmds]];
+  }
+  function toolOk(s, callId, result, at) {
+    return settleTool(s, callId, { kind: "ok", result }, at);
+  }
+  function toolErr(s, callId, reason, at) {
+    return settleTool(s, callId, { kind: "error", reason }, at);
+  }
+  function settleTool(s, callId, outcome, at) {
+    if (isSettled(s)) return [s, []];
+    const conv = s.conversation;
+    if (conv === null || conv.awaiting.kind !== "tools") return [s, []];
+    const call = s.tools.running.find((c) => c.callId === callId);
+    if (call === void 0) return [s, []];
+    const [tools, launchCmds] = outcome.kind === "ok" ? fan.itemOk(s.tools, callId, outcome) : fan.itemErr(s.tools, callId, outcome);
+    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] = run.progress(s.run, void 0, at);
+      return [
+        { ...s, run: runSlice2, tools, conversation: foldedConv },
+        launchCmds
+      ];
+    }
+    const turnedConv = {
+      ...foldedConv,
+      turnCount: foldedConv.turnCount + 1,
+      awaiting: { kind: "llm" }
+    };
+    if (config.maxTurns !== void 0 && turnedConv.turnCount >= config.maxTurns) {
+      return failTurnLimit({ ...s, tools, conversation: turnedConv }, at);
+    }
+    const drained = {
+      ...s,
+      tools: initFanOut(),
+      conversation: turnedConv
+    };
+    const compacting = maybeCompact(drained, at);
+    if (compacting !== null) return compacting;
+    const [runSlice] = run.progress(drained.run, void 0, at);
+    const fired = { ...drained, run: runSlice };
+    const nextCall = brainCall(fired);
+    const [resilience, llmCmds] = llm.attempt(fired.resilience, nextCall, at);
+    return [{ ...fired, resilience }, [...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] = run.progress(s.run, void 0, at);
+    const input = {
+      purpose: COMPACTION_PURPOSE,
+      model: config.modelId ?? null,
+      payload: policy.payloadOf ? policy.payloadOf(conv, folding) : null
+    };
+    const [compaction, runCmds] = compactRc.attempt(
+      s.compaction,
+      COMPACTION_PURPOSE,
+      input,
+      at
+    );
+    const cmds = runCmds.map(toCompactRunCmd);
+    return [
+      { ...s, run: runSlice, conversation: compactConv, compaction },
+      cmds
+    ];
+  }
+  function toCompactRunCmd(cmd) {
+    return {
+      type: MsgType.CompactRun,
+      key: COMPACTION_PURPOSE,
+      input: cmd.input
+    };
+  }
+  function failTurnLimit(s, at) {
+    return [{ ...s, failure: { reason: "turn_limit", at } }, []];
+  }
+  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] = compactRc.succeed(s.compaction, key, {
+      type: MsgType.ResilientOk,
+      key: msg.key,
+      result: msg.result,
+      at: msg.at
+    });
+    const settledRetry = { ...s, compaction };
+    if (isSettled(settledRetry)) return [settledRetry, []];
+    const conv = settledRetry.conversation;
+    if (conv === null || conv.awaiting.kind !== "compacting") {
+      return [settledRetry, retryCmds.map(toCompactRunCmd)];
+    }
+    const folding = conv.awaiting.folding;
+    const summaryTurn = {
+      content: msg.result.output.summary,
+      toolCalls: []
+    };
+    const foldedConv = foldSummary(conv, folding, summaryTurn);
+    const fired = { ...settledRetry, conversation: foldedConv };
+    const nextCall = brainCall(fired);
+    const [resilience, llmCmds] = llm.attempt(fired.resilience, nextCall, at);
+    return [
+      { ...fired, resilience },
+      [...retryCmds.map(toCompactRunCmd), ...llmCmds]
+    ];
+  }
+  function compactErr(s, key, msg, at) {
+    const [compaction, cmds] = compactRc.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.map(toCompactRunCmd)];
+    }
+    if (isSettled(settledRetry)) return [settledRetry, []];
+    const conv = settledRetry.conversation;
+    if (conv === null || conv.awaiting.kind !== "compacting") {
+      return [settledRetry, cmds.map(toCompactRunCmd)];
+    }
+    const resumedConv = { ...conv, awaiting: { kind: "llm" } };
+    const fired = { ...settledRetry, conversation: resumedConv };
+    const nextCall = brainCall(fired);
+    const [resilience, llmCmds] = llm.attempt(fired.resilience, nextCall, at);
+    return [
+      { ...fired, resilience },
+      [...cmds.map(toCompactRunCmd), ...llmCmds]
+    ];
+  }
+  function onTimer(s, msg) {
+    if (msg.id.startsWith("monitored:")) {
+      const [runSlice] = run.onDeadline(s.run, msg);
+      return [{ ...s, run: runSlice }, []];
+    }
+    if (msg.id.endsWith(`:${COMPACTION_PURPOSE}`)) {
+      const [compaction, cmds2] = compactRc.onTimer(s.compaction, msg);
+      return [{ ...s, compaction }, cmds2.map(toCompactRunCmd)];
+    }
+    const [resilience, cmds] = llm.onTimer(s.resilience, msg);
+    return [{ ...s, resilience }, cmds];
+  }
+  function boot(s, at) {
+    const [runSlice] = run.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") {
+      const call = brainCall(rebooted);
+      const [resilience, cmds2] = llm.attempt(rebooted.resilience, call, at);
+      return [{ ...rebooted, resilience }, cmds2];
+    }
+    if (conv.awaiting.kind === "compacting") {
+      const input = {
+        purpose: COMPACTION_PURPOSE,
+        model: config.modelId ?? null,
+        payload: config.compaction?.payloadOf ? config.compaction.payloadOf(conv, conv.awaiting.folding) : null
+      };
+      const [compaction, cmds2] = compactRc.attempt(
+        rebooted.compaction,
+        COMPACTION_PURPOSE,
+        input,
+        at
+      );
+      return [{ ...rebooted, compaction }, cmds2.map(toCompactRunCmd)];
+    }
+    const cmds = rebooted.tools.running.map((call) => config.toolOf(call));
+    return [rebooted, cmds];
+  }
+  function isSettled(s) {
+    return s.run.phase === "done" || s.run.phase === "failed" || s.failure !== null;
+  }
+  function subs(s) {
+    return [
+      ...llm.subs(s.resilience),
+      ...compactRc.subs(s.compaction),
+      ...run.subs(s.run)
+    ];
+  }
+  function unsafeDetachedHandlers(ports) {
+    return llm.handlers(ports);
+  }
+  function brainHandlers() {
+    return llm.handlers();
+  }
+  function toMachine(opts) {
+    const consumerInterpret = opts?.toolInterpret ?? {};
+    const interpret = mergeInterpret(consumerInterpret, brainHandlers());
+    const update = {
+      [MsgType.AgentStart]: (s, m) => start(s, m.runId, m.at),
+      [MsgType.AgentToolOk]: (s, m) => toolOk(s, m.callId, m.result, m.at),
+      [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)
+    };
+    const machine = {
+      init: (loaded) => loaded !== null ? [loaded, []] : [init(), []],
+      update,
+      subscriptions: (s) => subs(s),
+      subscribe: { deadline: subscribeDeadline },
+      interpret
+    };
+    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
+  };
+}
+function agentBootMsg(at) {
+  return { type: MsgType.AgentBoot, at };
+}
+function agentEvents() {
+  return (msg, state) => {
+    const events = [];
+    switch (msg.type) {
+      case MsgType.ResilientOk:
+        events.push({ type: "TurnSettled", turn: msg.result.output });
+        break;
+      case MsgType.AgentToolOk:
+        events.push({
+          type: "ToolSettled",
+          callId: msg.callId,
+          result: msg.result
+        });
+        break;
+      // start / boot / timer / the *_err arms / the compaction settles carry no
+      // public event — return []. (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.
+      case MsgType.AgentStart:
+      case MsgType.AgentToolErr:
+      case MsgType.ResilientErr:
+      case MsgType.CompactOk:
+      case MsgType.CompactErr:
+      case "deadline_exceeded":
+      case MsgType.AgentBoot:
+        break;
+    }
+    if (state.run.phase === "done") {
+      events.push({ type: "RunDone", output: state.output });
+    }
+    return events;
+  };
+}
+function mergeInterpret(a, b) {
+  return { ...a ?? {}, ...b };
+}
+function liftAgent(state, [slice, cmds]) {
+  return [{ ...state, agent: slice }, cmds];
+}
+
+export { COMPACTION_PURPOSE, agentBootMsg, agentEvents, agentTurnSchema, compactionSummarySchema, createAgent, isAgentTurn, isCompactionSummary, liftAgent, mergeInterpret, status };
+//# sourceMappingURL=chunk-TC4HWABA.js.map
+//# sourceMappingURL=chunk-TC4HWABA.js.map