@effect-uai/core 0.18.0 → 0.19.0-dev-20261110065930

package/dist/loop/Loop.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Loop.mjs","names":["Arr"],"sources":["../../src/loop/Loop.ts"],"sourcesContent":["/**\n * Pull-based `loop` for state-threaded sub-streams.\n *\n * Each iteration runs a body that returns a `Stream<Step<A, S>>`. The body\n * emits values via `Loop.value(a)` and signals iteration control via\n * `Loop.next(state)` (continue with new state) or `Loop.stop()` (terminate).\n * The loop unwraps `Value` steps back to `A` for downstream consumers, so\n * the resulting stream is a plain `Stream<A>`.\n *\n * The next body stream is only pulled when downstream pulls the outer\n * stream - no producer fiber, no queue buffering. Cancellation, failures,\n * scoped resources, and backpressure stay aligned with normal Stream\n * semantics.\n *\n * Convention: a `Next` or `Stop` step is the terminal element of a body's\n * iteration. Values emitted in the same chunk after one are discarded\n * (their producing side effects may already have run). The `Loop.next` /\n * `Loop.stop` helpers each emit a single terminal step, so concatenate\n * your values before them (`values.pipe(Stream.concat(Loop.next(state)))`).\n */\nimport {\n  Array as Arr,\n  Cause,\n  Channel,\n  Data,\n  Effect,\n  Exit,\n  Function,\n  Match,\n  Option,\n  Ref,\n  Scope,\n  Stream,\n  SubscriptionRef,\n} from \"effect\"\nimport { IncompleteTurn } from \"../domain/AiError.js\"\nimport { isTurnComplete, type Turn, type TurnEvent } from \"../domain/Turn.js\"\n\n// ---------------------------------------------------------------------------\n// Step type - the body's emit shape\n// ---------------------------------------------------------------------------\n\n/**\n * The tagged union a body emits per pull. `Value` carries a payload that\n * flows downstream. `Next` ends the current iteration and continues with a\n * new state. `Stop` ends the loop entirely with no carried state.\n * `StopWith` also ends the loop but carries a final state that `loopOver`\n * will thread to the next input and `loopWithState` will write to its\n * `SubscriptionRef` before the loop ends. Plain `loop` has no next\n * iteration to apply it to and treats `StopWith` like `Stop`.\n *\n * `Stop` is intentionally `{}` so the bare `stop()` helper doesn't\n * constrain `S` from a body's stream type — every body has a `Stop`\n * variant in its union, and forcing `S` to flow through it would break\n * inference whenever the body never uses `next` / `stop(state)`.\n */\nexport type Step<A, S> = Data.TaggedEnum<{\n  Value: { readonly value: A }\n  Next: { readonly state: S }\n  Stop: {}\n  StopWith: { readonly state: S }\n}>\n\ninterface StepDef extends Data.TaggedEnum.WithGenerics<2> {\n  readonly taggedEnum: Step<this[\"A\"], this[\"B\"]>\n}\n\nconst Step = Data.taggedEnum<StepDef>()\n\n/**\n * Bare step constructors, so a loop body can emit `Value(...)`, `Next(...)`,\n * `Stop()`, `StopWith(...)` directly inside a `Stream.make(...)` without the\n * `Step.` prefix. (The `Step` object itself can't be exported under that name\n * because it collides with the exported `Step` type.) For the common cases\n * prefer the `value` / `next` / `stop` helpers, which also handle the\n * single-element-stream wrapping for `next` / `stop`.\n */\nexport const { Value, Next, Stop, StopWith } = Step\n\n/** Wrap a value so it flows through the loop to downstream consumers. */\nexport const value = <A>(a: A): Step<A, never> => Step.Value({ value: a })\n\n/**\n * End the current iteration and continue with a new state. Emits a single\n * terminal `Next` step as a one-element stream, so it slots directly into a\n * loop body or after a run of values: `values.pipe(Stream.concat(next(s)))`.\n */\nexport const next = <S>(state: S): Stream.Stream<Step<never, S>> =>\n  Stream.succeed(Step.Next({ state }))\n\n/**\n * End the loop. Called with no argument it emits a bare `Stop`; called with\n * a state it emits `StopWith(state)` — `loopOver` threads that final state\n * to the next input and `loopWithState` writes it to its `SubscriptionRef`\n * before the loop ends. Either way it returns a single-element stream, so\n * return it directly from a loop body.\n */\nexport const stop = <S = never>(state?: S): Stream.Stream<Step<never, S>> =>\n  Stream.succeed<Step<never, S>>(state === undefined ? Step.Stop() : Step.StopWith({ state }))\n\n// ---------------------------------------------------------------------------\n// onTurnComplete - turn-aware stream operator for loop bodies\n// ---------------------------------------------------------------------------\n\n/**\n * Lift a provider's `Stream<TurnEvent>` into a loop body's `Stream<Step<TurnEvent | A, S>>`.\n * Each delta passes through as `value(delta)` (including the terminal\n * `TurnComplete`, so the consumer sees turn boundaries naturally). Once\n * the terminal arrives, `then(turn)` runs and its returned stream of loop\n * steps (typically tool outputs followed by `next(state)` or `stop()`) is\n * concatenated.\n *\n * Pre-pipe transforms (`Stream.tap` / `Stream.map` / `Stream.filter`) on\n * the raw delta stream cover anything an `emit`-style callback would do.\n *\n * `then` may return the step stream directly, or an `Effect` that produces\n * it (for branches that need to read a `Ref`, decode tool args, log, etc.).\n * Mirrors `loop`'s body: return a bare `stop()` / `next(s)` where no effect\n * is needed, lift to `Effect` only where one is.\n *\n * If the upstream ends without a `TurnComplete`, the resulting stream\n * fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if\n * you want to recover.\n *\n * Dual: data-first `onTurnComplete(deltas, then)` and data-last\n * `deltas.pipe(onTurnComplete(then))` both work.\n */\ntype TurnContinuation<S, A, E2, R2> =\n  | Stream.Stream<Step<A, S>, E2, R2>\n  | Effect.Effect<Stream.Stream<Step<A, S>, E2, R2>, E2, R2>\n\nexport const onTurnComplete: {\n  <S, A, E2 = never, R2 = never>(\n    then: (turn: Turn) => TurnContinuation<S, A, E2, R2>,\n  ): <E, R>(\n    deltas: Stream.Stream<TurnEvent, E, R>,\n  ) => Stream.Stream<Step<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>\n  <S, A, E, R, E2 = never, R2 = never>(\n    deltas: Stream.Stream<TurnEvent, E, R>,\n    then: (turn: Turn) => TurnContinuation<S, A, E2, R2>,\n  ): Stream.Stream<Step<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>\n} = Function.dual(\n  2,\n  <S, A, E, R, E2, R2>(\n    deltas: Stream.Stream<TurnEvent, E, R>,\n    then: (turn: Turn) => TurnContinuation<S, A, E2, R2>,\n  ): Stream.Stream<Step<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const turnRef = yield* Ref.make<Option.Option<Turn>>(Option.none())\n\n        const events: Stream.Stream<Step<TurnEvent, S>, E, R> = deltas.pipe(\n          Stream.tap((delta) =>\n            isTurnComplete(delta) ? Ref.set(turnRef, Option.some(delta.turn)) : Effect.void,\n          ),\n          Stream.map(value),\n        )\n\n        const continuation = Stream.unwrap(\n          Effect.gen(function* () {\n            const opt = yield* Ref.get(turnRef)\n            if (Option.isNone(opt)) return yield* new IncompleteTurn({})\n            const result = then(opt.value)\n            return Effect.isEffect(result) ? yield* result : result\n          }),\n        )\n\n        return Stream.concat(events, continuation)\n      }),\n    ),\n)\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nconst isNonEmpty = <A>(array: ReadonlyArray<A>): array is readonly [A, ...Array<A>] =>\n  array.length > 0\n\ntype CurrentBody<S, A, E, R> = {\n  readonly scope: Scope.Closeable\n  readonly pull: Effect.Effect<ReadonlyArray<Step<A, S>>, E | Cause.Done<void>, R>\n}\n\nconst closeBody = <S, A, E, R>(\n  current: CurrentBody<S, A, E, R>,\n  exit: Exit.Exit<unknown, unknown>,\n) => Scope.close(current.scope, exit)\n\n/**\n * Walk a chunk of `Step<A, S>` until a terminal `Next` or `Stop` is found.\n * Returns the unwrapped values seen so far and (optionally) the terminal\n * step. Anything in the chunk after the terminal is discarded - its\n * producing side effects may have run, but downstream never sees it.\n */\nconst partitionChunk = <A, S>(\n  chunk: ReadonlyArray<Step<A, S>>,\n): {\n  readonly values: ReadonlyArray<A>\n  readonly decision: Option.Option<Step<A, S>>\n} => {\n  const [valueSteps, rest] = Arr.span(\n    chunk,\n    (e): e is Step<A, S> & { _tag: \"Value\" } => e._tag === \"Value\",\n  )\n  return {\n    values: valueSteps.map((e) => e.value),\n    decision: Arr.head(rest),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\ntype LoopBody<S, A, E, R> = (\n  state: S,\n) => Stream.Stream<Step<A, S>, E, R> | Effect.Effect<Stream.Stream<Step<A, S>, E, R>, E, R>\n\n/**\n * Drive a state-threaded loop body. Each iteration runs `body(state)` to get\n * a `Stream<Step<A, S>>`; values flow downstream, `next(s)` continues with\n * a new state, `stop()` ends the loop. See the file header for the full\n * pull-based execution model.\n *\n * Dual: data-first `loop(initial, body)` and data-last `loop(body)(initial)`\n * (or `pipe(initial, loop(body))`) both work.\n */\nexport const loop: {\n  <S, A, E, R>(body: LoopBody<S, A, E, R>): (initial: S) => Stream.Stream<A, E, R>\n  <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R>\n} = Function.dual(2, <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R> =>\n  Stream.scoped(\n    Stream.fromPull(\n      Effect.gen(function* () {\n        const outerScope = yield* Effect.scope\n        let state = initial\n        let current: CurrentBody<S, A, E, R> | undefined\n        let done = false\n\n        const closeActive = (\n          active: CurrentBody<S, A, E, R>,\n          exit: Exit.Exit<unknown, unknown>,\n        ) => {\n          const isActive = current === active\n          if (isActive) current = undefined\n          // Scope.close is idempotent. Multiple paths can race to close the\n          // active body during cancellation/failure, so closing twice is safe.\n          return closeBody(active, exit)\n        }\n\n        yield* Scope.addFinalizerExit(outerScope, (exit) =>\n          current === undefined ? Effect.void : closeActive(current, exit),\n        )\n\n        const pull = Effect.gen(function* () {\n          while (true) {\n            if (done) return yield* Cause.done()\n\n            if (current === undefined) {\n              const result = body(state)\n              const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result\n              const bodyScope = yield* Scope.fork(outerScope)\n              const bodyPull = yield* Channel.toPullScoped(\n                Stream.toChannel(stream),\n                bodyScope,\n              ).pipe(Effect.onError((cause) => Scope.close(bodyScope, Exit.failCause(cause))))\n              current = { scope: bodyScope, pull: bodyPull }\n            }\n\n            const active = current\n            const chunk = yield* active.pull.pipe(\n              Effect.catchIf(Cause.isDone, () =>\n                closeActive(active, Exit.void).pipe(\n                  Effect.as(undefined as ReadonlyArray<Step<A, S>> | undefined),\n                ),\n              ),\n              Effect.onError((cause) => closeActive(active, Exit.failCause(cause))),\n            )\n\n            if (chunk === undefined) {\n              done = true\n              return yield* Cause.done()\n            }\n\n            const { values, decision } = partitionChunk(chunk)\n\n            if (Option.isSome(decision)) {\n              yield* closeActive(active, Exit.void)\n              if (decision.value._tag === \"Stop\" || decision.value._tag === \"StopWith\") {\n                // `loop` has no next iteration to apply StopWith's state to;\n                // the state lands in `loopOver`'s outer ref or\n                // `loopWithState`'s SubscriptionRef via their taps.\n                done = true\n              } else if (decision.value._tag === \"Next\") {\n                state = decision.value.state\n              }\n            }\n\n            // Emit the values seen so far if any. Chunks from a Stream pull\n            // are non-empty, so when `decision` is `None` every step was\n            // a `Value` and `values` is non-empty here. With a decision and\n            // no preceding values, fall through to the next iteration.\n            if (isNonEmpty(values)) return values\n          }\n        })\n\n        // `Stream.fromPull` expects the generator to RETURN the pull effect,\n        // not run it; `return yield* pull` would execute a pull and break it.\n        // @effect-diagnostics-next-line returnEffectInGen:off\n        return pull\n      }),\n    ),\n  ),\n)\n\n// ---------------------------------------------------------------------------\n// loopOver - stream-driven sibling of loop. One input item runs a full\n// multi-turn inner loop.\n// ---------------------------------------------------------------------------\n\ntype LoopOverBody<S, I, A, E, R> = (\n  state: S,\n  input: I,\n) => Stream.Stream<Step<A, S>, E, R> | Effect.Effect<Stream.Stream<Step<A, S>, E, R>, E, R>\n\n/**\n * Input-driven sibling of `loop`. For each item pulled from the input\n * stream, runs an inner seed-driven `loop` whose body is\n * `(s) => body(s, item)`. State is threaded across input items.\n *\n * **Per-input semantics — the body emits standard `Step<A, S>`:**\n *   - `value(a)`: emit `a` downstream\n *   - `next(s)`: re-run the body with the SAME input and new state `s`\n *     (multi-turn within one input — e.g. multiple model turns + tool\n *     calls for one document)\n *   - `stop()`: end this input's inner loop, advance to the next input\n *     (state preserved)\n *   - body stream ending without a decision: same as `stop()` (advance)\n *\n * **Outer termination:** the input stream ending. To halt programmatically\n * from within, end the input stream upstream (`Stream.takeWhile`, a\n * `SubscriptionRef` gate, etc.). Reserving `stop()` for per-item\n * advancement is what makes the common \"stream of documents, multi-turn\n * conversation per document\" shape readable.\n *\n * Dual: data-first `loopOver(input, initial, body)` and data-last\n * `input.pipe(loopOver(initial, body))` both work.\n */\nexport const loopOver: {\n  <S, I, A, E, R>(\n    initial: S,\n    body: LoopOverBody<S, I, A, E, R>,\n  ): <EI, RI>(input: Stream.Stream<I, EI, RI>) => Stream.Stream<A, E | EI, R | RI>\n  <S, I, A, E, R, EI, RI>(\n    input: Stream.Stream<I, EI, RI>,\n    initial: S,\n    body: LoopOverBody<S, I, A, E, R>,\n  ): Stream.Stream<A, E | EI, R | RI>\n} = Function.dual(\n  3,\n  <S, I, A, E, R, EI, RI>(\n    input: Stream.Stream<I, EI, RI>,\n    initial: S,\n    body: LoopOverBody<S, I, A, E, R>,\n  ): Stream.Stream<A, E | EI, R | RI> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const stateRef = yield* Ref.make<S>(initial)\n        return input.pipe(\n          Stream.flatMap((item) =>\n            Stream.unwrap(\n              Effect.gen(function* () {\n                const state = yield* Ref.get(stateRef)\n                // Capture Next states (and stop(state)'s final state) into the\n                // outer ref so the LAST state seen in this input's inner\n                // loop is what the next input starts from.\n                const wrappedBody = (s: S) => {\n                  const result = body(s, item)\n                  const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result\n                  return stream.pipe(\n                    Stream.tap((step) =>\n                      Match.value(step).pipe(\n                        Match.tags({\n                          Next: (e) => Ref.set(stateRef, e.state),\n                          StopWith: (e) => Ref.set(stateRef, e.state),\n                        }),\n                        Match.orElse(() => Effect.void),\n                      ),\n                    ),\n                  )\n                }\n                return loop(state, wrappedBody)\n              }),\n            ),\n          ),\n        )\n      }),\n    ),\n)\n\n// ---------------------------------------------------------------------------\n// loopWithState - same body protocol, plus a live state observable.\n// ---------------------------------------------------------------------------\n\n/**\n * Like `loop`, but exposes the current loop state as a `SubscriptionRef`\n * alongside the value stream.\n *\n * Allocates one `SubscriptionRef<S>` seeded with `initial`, then runs the\n * loop with a wrapped body that taps every `Next(s)` step into the ref\n * before forwarding it. The caller decides how to consume both channels:\n *\n *   - **Final state**: drain the stream, then `SubscriptionRef.get(state)`\n *     - the ref holds the state from the last `Next` (or `initial` if the\n *     loop ended without advancing).\n *   - **Live transitions**: `SubscriptionRef.changes(state)` is a\n *     `Stream<S>` of every state observed; subscribe alongside the value\n *     stream.\n *   - **Mid-iteration peek**: `SubscriptionRef.get(state)` at any time.\n *\n * The returned stream and ref are independent of each other - the ref\n * lives outside the stream's scope, so reading it after the stream\n * completes is safe.\n */\nexport const loopWithState = <S, A, E, R>(\n  initial: S,\n  body: LoopBody<S, A, E, R>,\n): Effect.Effect<{\n  readonly stream: Stream.Stream<A, E, R>\n  readonly state: SubscriptionRef.SubscriptionRef<S>\n}> =>\n  Effect.gen(function* () {\n    const stateRef = yield* SubscriptionRef.make(initial)\n\n    const tap = (stream: Stream.Stream<Step<A, S>, E, R>): Stream.Stream<Step<A, S>, E, R> =>\n      stream.pipe(\n        Stream.tap((step) =>\n          Match.value(step).pipe(\n            Match.tags({\n              Next: (e) => SubscriptionRef.set(stateRef, e.state),\n              StopWith: (e) => SubscriptionRef.set(stateRef, e.state),\n            }),\n            Match.orElse(() => Effect.void),\n          ),\n        ),\n      )\n\n    const wrappedBody: LoopBody<S, A, E, R> = (s) => {\n      const result = body(s)\n      return Effect.isEffect(result) ? Effect.map(result, tap) : tap(result)\n    }\n\n    return {\n      stream: loop(initial, wrappedBody),\n      state: stateRef,\n    }\n  })\n"],"mappings":"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"}
+{"version":3,"file":"Loop.mjs","names":["Arr"],"sources":["../../src/loop/Loop.ts"],"sourcesContent":["/**\n * Pull-based `loop` for state-threaded sub-streams.\n *\n * Each iteration runs a body that returns a `Stream<Step<A, S>>`. The body\n * emits values via `Loop.value(a)` and signals iteration control via\n * `Loop.next(state)` (continue with new state) or `Loop.stop()` (terminate).\n * The loop unwraps `Value` steps back to `A` for downstream consumers, so\n * the resulting stream is a plain `Stream<A>`.\n *\n * The next body stream is only pulled when downstream pulls the outer\n * stream - no producer fiber, no queue buffering. Cancellation, failures,\n * scoped resources, and backpressure stay aligned with normal Stream\n * semantics.\n *\n * Convention: a `Next` or `Stop` step is the terminal element of a body's\n * iteration. Values emitted in the same chunk after one are discarded\n * (their producing side effects may already have run). The `Loop.next` /\n * `Loop.stop` helpers each emit a single terminal step, so concatenate\n * your values before them (`values.pipe(Stream.concat(Loop.next(state)))`).\n */\nimport {\n  Array as Arr,\n  Cause,\n  Channel,\n  Data,\n  Effect,\n  Exit,\n  Function,\n  Match,\n  Option,\n  Ref,\n  Scope,\n  Stream,\n  SubscriptionRef,\n} from \"effect\"\nimport { IncompleteTurn } from \"../domain/AiError.js\"\nimport { isTurnComplete, type Turn, type TurnEvent } from \"../domain/Turn.js\"\n\n// ---------------------------------------------------------------------------\n// Step type - the body's emit shape\n// ---------------------------------------------------------------------------\n\n/**\n * The tagged union a body emits per pull. `Value` carries a payload that\n * flows downstream. `Next` ends the current iteration and continues with a\n * new state. `Stop` ends the loop entirely with no carried state.\n * `StopWith` also ends the loop but carries a final state that `loopOver`\n * will thread to the next input and `loopWithState` will write to its\n * `SubscriptionRef` before the loop ends. Plain `loop` has no next\n * iteration to apply it to and treats `StopWith` like `Stop`.\n *\n * `Stop` is intentionally `{}` so the bare `stop()` helper doesn't\n * constrain `S` from a body's stream type — every body has a `Stop`\n * variant in its union, and forcing `S` to flow through it would break\n * inference whenever the body never uses `next` / `stop(state)`.\n */\nexport type Step<A, S> = Data.TaggedEnum<{\n  Value: { readonly value: A }\n  Next: { readonly state: S }\n  Stop: {}\n  StopWith: { readonly state: S }\n}>\n\ninterface StepDef extends Data.TaggedEnum.WithGenerics<2> {\n  readonly taggedEnum: Step<this[\"A\"], this[\"B\"]>\n}\n\nconst Step = Data.taggedEnum<StepDef>()\n\n/**\n * Bare step constructors, so a loop body can emit `Value(...)`, `Next(...)`,\n * `Stop()`, `StopWith(...)` directly inside a `Stream.make(...)` without the\n * `Step.` prefix. (The `Step` object itself can't be exported under that name\n * because it collides with the exported `Step` type.) For the common cases\n * prefer the `value` / `next` / `stop` helpers, which also handle the\n * single-element-stream wrapping for `next` / `stop`.\n */\nexport const { Value, Next, Stop, StopWith } = Step\n\n/** Wrap a value so it flows through the loop to downstream consumers. */\nexport const value = <A>(a: A): Step<A, never> => Step.Value({ value: a })\n\n/**\n * End the current iteration and continue with a new state. Emits a single\n * terminal `Next` step as a one-element stream, so it slots directly into a\n * loop body or after a run of values: `values.pipe(Stream.concat(next(s)))`.\n */\nexport const next = <S>(state: S): Stream.Stream<Step<never, S>> =>\n  Stream.succeed(Step.Next({ state }))\n\n/**\n * End the loop. Called with no argument it emits a bare `Stop`; called with\n * a state it emits `StopWith(state)` — `loopOver` threads that final state\n * to the next input and `loopWithState` writes it to its `SubscriptionRef`\n * before the loop ends. Either way it returns a single-element stream, so\n * return it directly from a loop body.\n */\nexport const stop = <S = never>(state?: S): Stream.Stream<Step<never, S>> =>\n  Stream.succeed<Step<never, S>>(state === undefined ? Step.Stop() : Step.StopWith({ state }))\n\n// ---------------------------------------------------------------------------\n// onTurnComplete - turn-aware stream operator for loop bodies\n// ---------------------------------------------------------------------------\n\n/**\n * Lift a provider's `Stream<TurnEvent>` into a loop body's `Stream<Step<TurnEvent | A, S>>`.\n * Each delta passes through as `value(delta)` (including the terminal\n * `TurnComplete`, so the consumer sees turn boundaries naturally). Once\n * the terminal arrives, `then(turn)` runs and its returned stream of loop\n * steps (typically tool outputs followed by `next(state)` or `stop()`) is\n * concatenated.\n *\n * Pre-pipe transforms (`Stream.tap` / `Stream.map` / `Stream.filter`) on\n * the raw delta stream cover anything an `emit`-style callback would do.\n *\n * `then` may return the step stream directly, or an `Effect` that produces\n * it (for branches that need to read a `Ref`, decode tool args, log, etc.).\n * Mirrors `loop`'s body: return a bare `stop()` / `next(s)` where no effect\n * is needed, lift to `Effect` only where one is.\n *\n * If the upstream ends without a `TurnComplete`, the resulting stream\n * fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if\n * you want to recover.\n *\n * Dual: data-first `onTurnComplete(deltas, then)` and data-last\n * `deltas.pipe(onTurnComplete(then))` both work.\n */\n// The Effect and the stream it returns infer their errors separately.\ntype TurnContinuation<S, A, E2, R2, E3, R3> =\n  | Stream.Stream<Step<A, S>, E2, R2>\n  | Effect.Effect<Stream.Stream<Step<A, S>, E2, R2>, E3, R3>\n\nexport const onTurnComplete: {\n  <S, A, E2 = never, R2 = never, E3 = never, R3 = never>(\n    then: (turn: Turn) => TurnContinuation<S, A, E2, R2, E3, R3>,\n  ): <E, R>(\n    deltas: Stream.Stream<TurnEvent, E, R>,\n  ) => Stream.Stream<Step<TurnEvent | A, S>, E | E2 | E3 | IncompleteTurn, R | R2 | R3>\n  <S, A, E, R, E2 = never, R2 = never, E3 = never, R3 = never>(\n    deltas: Stream.Stream<TurnEvent, E, R>,\n    then: (turn: Turn) => TurnContinuation<S, A, E2, R2, E3, R3>,\n  ): Stream.Stream<Step<TurnEvent | A, S>, E | E2 | E3 | IncompleteTurn, R | R2 | R3>\n} = Function.dual(\n  2,\n  <S, A, E, R, E2, R2, E3, R3>(\n    deltas: Stream.Stream<TurnEvent, E, R>,\n    then: (turn: Turn) => TurnContinuation<S, A, E2, R2, E3, R3>,\n  ): Stream.Stream<Step<TurnEvent | A, S>, E | E2 | E3 | IncompleteTurn, R | R2 | R3> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const turnRef = yield* Ref.make<Option.Option<Turn>>(Option.none())\n\n        const events: Stream.Stream<Step<TurnEvent, S>, E, R> = deltas.pipe(\n          Stream.tap((delta) =>\n            isTurnComplete(delta) ? Ref.set(turnRef, Option.some(delta.turn)) : Effect.void,\n          ),\n          Stream.map(value),\n        )\n\n        const continuation = Stream.unwrap(\n          Effect.gen(function* () {\n            const opt = yield* Ref.get(turnRef)\n            if (Option.isNone(opt)) return yield* new IncompleteTurn({})\n            const result = then(opt.value)\n            return Effect.isEffect(result) ? yield* result : result\n          }),\n        )\n\n        return Stream.concat(events, continuation)\n      }),\n    ),\n)\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nconst isNonEmpty = <A>(array: ReadonlyArray<A>): array is readonly [A, ...Array<A>] =>\n  array.length > 0\n\ntype CurrentBody<S, A, E, R> = {\n  readonly scope: Scope.Closeable\n  readonly pull: Effect.Effect<ReadonlyArray<Step<A, S>>, E | Cause.Done<void>, R>\n}\n\nconst closeBody = <S, A, E, R>(\n  current: CurrentBody<S, A, E, R>,\n  exit: Exit.Exit<unknown, unknown>,\n) => Scope.close(current.scope, exit)\n\n/**\n * Walk a chunk of `Step<A, S>` until a terminal `Next` or `Stop` is found.\n * Returns the unwrapped values seen so far and (optionally) the terminal\n * step. Anything in the chunk after the terminal is discarded - its\n * producing side effects may have run, but downstream never sees it.\n */\nconst partitionChunk = <A, S>(\n  chunk: ReadonlyArray<Step<A, S>>,\n): {\n  readonly values: ReadonlyArray<A>\n  readonly decision: Option.Option<Step<A, S>>\n} => {\n  const [valueSteps, rest] = Arr.span(\n    chunk,\n    (e): e is Step<A, S> & { _tag: \"Value\" } => e._tag === \"Value\",\n  )\n  return {\n    values: valueSteps.map((e) => e.value),\n    decision: Arr.head(rest),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\ntype LoopBody<S, A, E, R> = (\n  state: S,\n) => Stream.Stream<Step<A, S>, E, R> | Effect.Effect<Stream.Stream<Step<A, S>, E, R>, E, R>\n\n// What callers pass: the Effect and its stream infer errors and requirements separately.\ntype LoopBodyIn<S, A, E, R, E2, R2> = (\n  state: S,\n) => Stream.Stream<Step<A, S>, E, R> | Effect.Effect<Stream.Stream<Step<A, S>, E, R>, E2, R2>\n\n/**\n * Drive a state-threaded loop body. Each iteration runs `body(state)` to get\n * a `Stream<Step<A, S>>`; values flow downstream, `next(s)` continues with\n * a new state, `stop()` ends the loop. See the file header for the full\n * pull-based execution model.\n *\n * Dual: data-first `loop(initial, body)` and data-last `loop(body)(initial)`\n * (or `pipe(initial, loop(body))`) both work.\n */\nexport const loop: {\n  <S, A, E, R, E2 = never, R2 = never>(\n    body: LoopBodyIn<S, A, E, R, E2, R2>,\n  ): (initial: S) => Stream.Stream<A, E | E2, R | R2>\n  <S, A, E, R, E2 = never, R2 = never>(\n    initial: S,\n    body: LoopBodyIn<S, A, E, R, E2, R2>,\n  ): Stream.Stream<A, E | E2, R | R2>\n} = Function.dual(2, <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R> =>\n  Stream.scoped(\n    Stream.fromPull(\n      Effect.gen(function* () {\n        const outerScope = yield* Effect.scope\n        let state = initial\n        let current: CurrentBody<S, A, E, R> | undefined\n        let done = false\n\n        const closeActive = (\n          active: CurrentBody<S, A, E, R>,\n          exit: Exit.Exit<unknown, unknown>,\n        ) => {\n          const isActive = current === active\n          if (isActive) current = undefined\n          // Scope.close is idempotent. Multiple paths can race to close the\n          // active body during cancellation/failure, so closing twice is safe.\n          return closeBody(active, exit)\n        }\n\n        yield* Scope.addFinalizerExit(outerScope, (exit) =>\n          current === undefined ? Effect.void : closeActive(current, exit),\n        )\n\n        const pull = Effect.gen(function* () {\n          while (true) {\n            if (done) return yield* Cause.done()\n\n            if (current === undefined) {\n              const result = body(state)\n              const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result\n              const bodyScope = yield* Scope.fork(outerScope)\n              const bodyPull = yield* Channel.toPullScoped(\n                Stream.toChannel(stream),\n                bodyScope,\n              ).pipe(Effect.onError((cause) => Scope.close(bodyScope, Exit.failCause(cause))))\n              current = { scope: bodyScope, pull: bodyPull }\n            }\n\n            const active = current\n            const chunk = yield* active.pull.pipe(\n              Effect.catchIf(Cause.isDone, () =>\n                closeActive(active, Exit.void).pipe(\n                  Effect.as(undefined as ReadonlyArray<Step<A, S>> | undefined),\n                ),\n              ),\n              Effect.onError((cause) => closeActive(active, Exit.failCause(cause))),\n            )\n\n            if (chunk === undefined) {\n              done = true\n              return yield* Cause.done()\n            }\n\n            const { values, decision } = partitionChunk(chunk)\n\n            if (Option.isSome(decision)) {\n              yield* closeActive(active, Exit.void)\n              if (decision.value._tag === \"Stop\" || decision.value._tag === \"StopWith\") {\n                // `loop` has no next iteration to apply StopWith's state to;\n                // the state lands in `loopOver`'s outer ref or\n                // `loopWithState`'s SubscriptionRef via their taps.\n                done = true\n              } else if (decision.value._tag === \"Next\") {\n                state = decision.value.state\n              }\n            }\n\n            // Emit the values seen so far if any. Chunks from a Stream pull\n            // are non-empty, so when `decision` is `None` every step was\n            // a `Value` and `values` is non-empty here. With a decision and\n            // no preceding values, fall through to the next iteration.\n            if (isNonEmpty(values)) return values\n          }\n        })\n\n        // `Stream.fromPull` expects the generator to RETURN the pull effect,\n        // not run it; `return yield* pull` would execute a pull and break it.\n        // @effect-diagnostics-next-line returnEffectInGen:off\n        return pull\n      }),\n    ),\n  ),\n)\n\n// ---------------------------------------------------------------------------\n// loopOver - stream-driven sibling of loop. One input item runs a full\n// multi-turn inner loop.\n// ---------------------------------------------------------------------------\n\ntype LoopOverBody<S, I, A, E, R> = (\n  state: S,\n  input: I,\n) => Stream.Stream<Step<A, S>, E, R> | Effect.Effect<Stream.Stream<Step<A, S>, E, R>, E, R>\n\n/**\n * Input-driven sibling of `loop`. For each item pulled from the input\n * stream, runs an inner seed-driven `loop` whose body is\n * `(s) => body(s, item)`. State is threaded across input items.\n *\n * **Per-input semantics — the body emits standard `Step<A, S>`:**\n *   - `value(a)`: emit `a` downstream\n *   - `next(s)`: re-run the body with the SAME input and new state `s`\n *     (multi-turn within one input — e.g. multiple model turns + tool\n *     calls for one document)\n *   - `stop()`: end this input's inner loop, advance to the next input\n *     (state preserved)\n *   - body stream ending without a decision: same as `stop()` (advance)\n *\n * **Outer termination:** the input stream ending. To halt programmatically\n * from within, end the input stream upstream (`Stream.takeWhile`, a\n * `SubscriptionRef` gate, etc.). Reserving `stop()` for per-item\n * advancement is what makes the common \"stream of documents, multi-turn\n * conversation per document\" shape readable.\n *\n * Dual: data-first `loopOver(input, initial, body)` and data-last\n * `input.pipe(loopOver(initial, body))` both work.\n */\nexport const loopOver: {\n  <S, I, A, E, R>(\n    initial: S,\n    body: LoopOverBody<S, I, A, E, R>,\n  ): <EI, RI>(input: Stream.Stream<I, EI, RI>) => Stream.Stream<A, E | EI, R | RI>\n  <S, I, A, E, R, EI, RI>(\n    input: Stream.Stream<I, EI, RI>,\n    initial: S,\n    body: LoopOverBody<S, I, A, E, R>,\n  ): Stream.Stream<A, E | EI, R | RI>\n} = Function.dual(\n  3,\n  <S, I, A, E, R, EI, RI>(\n    input: Stream.Stream<I, EI, RI>,\n    initial: S,\n    body: LoopOverBody<S, I, A, E, R>,\n  ): Stream.Stream<A, E | EI, R | RI> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const stateRef = yield* Ref.make<S>(initial)\n        return input.pipe(\n          Stream.flatMap((item) =>\n            Stream.unwrap(\n              Effect.gen(function* () {\n                const state = yield* Ref.get(stateRef)\n                // Capture Next states (and stop(state)'s final state) into the\n                // outer ref so the LAST state seen in this input's inner\n                // loop is what the next input starts from.\n                const wrappedBody = (s: S) => {\n                  const result = body(s, item)\n                  const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result\n                  return stream.pipe(\n                    Stream.tap((step) =>\n                      Match.value(step).pipe(\n                        Match.tags({\n                          Next: (e) => Ref.set(stateRef, e.state),\n                          StopWith: (e) => Ref.set(stateRef, e.state),\n                        }),\n                        Match.orElse(() => Effect.void),\n                      ),\n                    ),\n                  )\n                }\n                return loop(state, wrappedBody)\n              }),\n            ),\n          ),\n        )\n      }),\n    ),\n)\n\n// ---------------------------------------------------------------------------\n// loopWithState - same body protocol, plus a live state observable.\n// ---------------------------------------------------------------------------\n\n/**\n * Like `loop`, but exposes the current loop state as a `SubscriptionRef`\n * alongside the value stream.\n *\n * Allocates one `SubscriptionRef<S>` seeded with `initial`, then runs the\n * loop with a wrapped body that taps every `Next(s)` step into the ref\n * before forwarding it. The caller decides how to consume both channels:\n *\n *   - **Final state**: drain the stream, then `SubscriptionRef.get(state)`\n *     - the ref holds the state from the last `Next` (or `initial` if the\n *     loop ended without advancing).\n *   - **Live transitions**: `SubscriptionRef.changes(state)` is a\n *     `Stream<S>` of every state observed; subscribe alongside the value\n *     stream.\n *   - **Mid-iteration peek**: `SubscriptionRef.get(state)` at any time.\n *\n * The returned stream and ref are independent of each other - the ref\n * lives outside the stream's scope, so reading it after the stream\n * completes is safe.\n */\nexport const loopWithState = <S, A, E, R>(\n  initial: S,\n  body: LoopBody<S, A, E, R>,\n): Effect.Effect<{\n  readonly stream: Stream.Stream<A, E, R>\n  readonly state: SubscriptionRef.SubscriptionRef<S>\n}> =>\n  Effect.gen(function* () {\n    const stateRef = yield* SubscriptionRef.make(initial)\n\n    const tap = (stream: Stream.Stream<Step<A, S>, E, R>): Stream.Stream<Step<A, S>, E, R> =>\n      stream.pipe(\n        Stream.tap((step) =>\n          Match.value(step).pipe(\n            Match.tags({\n              Next: (e) => SubscriptionRef.set(stateRef, e.state),\n              StopWith: (e) => SubscriptionRef.set(stateRef, e.state),\n            }),\n            Match.orElse(() => Effect.void),\n          ),\n        ),\n      )\n\n    const wrappedBody: LoopBody<S, A, E, R> = (s) => {\n      const result = body(s)\n      return Effect.isEffect(result) ? Effect.map(result, tap) : tap(result)\n    }\n\n    return {\n      stream: loop(initial, wrappedBody),\n      state: stateRef,\n    }\n  })\n"],"mappings":"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"}

package/dist/messenger/Messenger.d.mts

@@ -76,209 +76,37 @@ type InboundEvent = Data.TaggedEnum<{
     readonly raw: unknown;
   };
 }>;
-declare const InboundEvent: {
-  readonly $is: <Tag extends "Action" | "Command" | "Message" | "Reaction">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Action";
-    readonly conversation: ConversationRef;
-    readonly actionId: string;
-    readonly value?: string;
-    readonly author: UserId;
-    readonly raw: unknown;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Command";
-    readonly conversation: ConversationRef;
-    readonly name: string;
-    readonly args: string;
-    readonly author: UserId;
-    readonly raw: unknown;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Message";
-    readonly conversation: ConversationRef;
-    readonly id: MessageId;
-    readonly author: UserId;
-    readonly text: string;
-    readonly addressed: boolean;
-    readonly replyTo?: MessageId;
-    readonly raw: unknown;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Reaction";
-    readonly conversation: ConversationRef;
-    readonly message: MessageId;
-    readonly emoji: string;
-    readonly author: UserId;
-    readonly raw: unknown;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Action" | "Command" | "Message" | "Reaction"]: (args: Extract<{
-      readonly _tag: "Action";
-      readonly conversation: ConversationRef;
-      readonly actionId: string;
-      readonly value?: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Command";
-      readonly conversation: ConversationRef;
-      readonly name: string;
-      readonly args: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Message";
-      readonly conversation: ConversationRef;
-      readonly id: MessageId;
-      readonly author: UserId;
-      readonly text: string;
-      readonly addressed: boolean;
-      readonly replyTo?: MessageId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Reaction";
-      readonly conversation: ConversationRef;
-      readonly message: MessageId;
-      readonly emoji: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Action";
-      readonly conversation: ConversationRef;
-      readonly actionId: string;
-      readonly value?: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Command";
-      readonly conversation: ConversationRef;
-      readonly name: string;
-      readonly args: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Message";
-      readonly conversation: ConversationRef;
-      readonly id: MessageId;
-      readonly author: UserId;
-      readonly text: string;
-      readonly addressed: boolean;
-      readonly replyTo?: MessageId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Reaction";
-      readonly conversation: ConversationRef;
-      readonly message: MessageId;
-      readonly emoji: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Action" | "Command" | "Message" | "Reaction"]>>;
-    <Cases extends { readonly [Tag in "Action" | "Command" | "Message" | "Reaction"]: (args: Extract<{
-      readonly _tag: "Action";
-      readonly conversation: ConversationRef;
-      readonly actionId: string;
-      readonly value?: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Command";
-      readonly conversation: ConversationRef;
-      readonly name: string;
-      readonly args: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Message";
-      readonly conversation: ConversationRef;
-      readonly id: MessageId;
-      readonly author: UserId;
-      readonly text: string;
-      readonly addressed: boolean;
-      readonly replyTo?: MessageId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Reaction";
-      readonly conversation: ConversationRef;
-      readonly message: MessageId;
-      readonly emoji: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Action";
-      readonly conversation: ConversationRef;
-      readonly actionId: string;
-      readonly value?: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Command";
-      readonly conversation: ConversationRef;
-      readonly name: string;
-      readonly args: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Message";
-      readonly conversation: ConversationRef;
-      readonly id: MessageId;
-      readonly author: UserId;
-      readonly text: string;
-      readonly addressed: boolean;
-      readonly replyTo?: MessageId;
-      readonly raw: unknown;
-    } | {
-      readonly _tag: "Reaction";
-      readonly conversation: ConversationRef;
-      readonly message: MessageId;
-      readonly emoji: string;
-      readonly author: UserId;
-      readonly raw: unknown;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Action" | "Command" | "Message" | "Reaction"]>>;
-  };
-  readonly Action: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Action";
-    readonly conversation: ConversationRef;
-    readonly actionId: string;
-    readonly value?: string;
-    readonly author: UserId;
-    readonly raw: unknown;
-  }, "_tag">;
-  readonly Command: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Command";
-    readonly conversation: ConversationRef;
-    readonly name: string;
-    readonly args: string;
-    readonly author: UserId;
-    readonly raw: unknown;
-  }, "_tag">;
-  readonly Message: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Message";
-    readonly conversation: ConversationRef;
-    readonly id: MessageId;
-    readonly author: UserId;
-    readonly text: string;
-    readonly addressed: boolean;
-    readonly replyTo?: MessageId;
-    readonly raw: unknown;
-  }, "_tag">;
-  readonly Reaction: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Reaction";
-    readonly conversation: ConversationRef;
-    readonly message: MessageId;
-    readonly emoji: string;
-    readonly author: UserId;
-    readonly raw: unknown;
-  }, "_tag">;
-};
+declare const InboundEvent: Data.TaggedEnum.Constructor<{
+  readonly _tag: "Action";
+  readonly conversation: ConversationRef;
+  readonly actionId: string;
+  readonly value?: string;
+  readonly author: UserId;
+  readonly raw: unknown;
+} | {
+  readonly _tag: "Command";
+  readonly conversation: ConversationRef;
+  readonly name: string;
+  readonly args: string;
+  readonly author: UserId;
+  readonly raw: unknown;
+} | {
+  readonly _tag: "Message";
+  readonly conversation: ConversationRef;
+  readonly id: MessageId;
+  readonly author: UserId;
+  readonly text: string;
+  readonly addressed: boolean;
+  readonly replyTo?: MessageId;
+  readonly raw: unknown;
+} | {
+  readonly _tag: "Reaction";
+  readonly conversation: ConversationRef;
+  readonly message: MessageId;
+  readonly emoji: string;
+  readonly author: UserId;
+  readonly raw: unknown;
+}>;
 /**
  * What the agent says. `Text` is sent verbatim: each provider layer says
  * which markup it expects (Telegram HTML, Slack markdown), and the prompt is
@@ -303,92 +131,18 @@ type OutboundBody = Data.TaggedEnum<{
     readonly payload: unknown;
   };
 }>;
-declare const OutboundBody: {
-  readonly $is: <Tag extends "Media" | "Raw" | "Text">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Media";
-    readonly media: MediaSource;
-    readonly caption?: string;
-    readonly filename?: string;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Raw";
-    readonly payload: unknown;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Text";
-    readonly text: string;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Media" | "Raw" | "Text"]: (args: Extract<{
-      readonly _tag: "Media";
-      readonly media: MediaSource;
-      readonly caption?: string;
-      readonly filename?: string;
-    } | {
-      readonly _tag: "Raw";
-      readonly payload: unknown;
-    } | {
-      readonly _tag: "Text";
-      readonly text: string;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Media";
-      readonly media: MediaSource;
-      readonly caption?: string;
-      readonly filename?: string;
-    } | {
-      readonly _tag: "Raw";
-      readonly payload: unknown;
-    } | {
-      readonly _tag: "Text";
-      readonly text: string;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Media" | "Raw" | "Text"]>>;
-    <Cases extends { readonly [Tag in "Media" | "Raw" | "Text"]: (args: Extract<{
-      readonly _tag: "Media";
-      readonly media: MediaSource;
-      readonly caption?: string;
-      readonly filename?: string;
-    } | {
-      readonly _tag: "Raw";
-      readonly payload: unknown;
-    } | {
-      readonly _tag: "Text";
-      readonly text: string;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Media";
-      readonly media: MediaSource;
-      readonly caption?: string;
-      readonly filename?: string;
-    } | {
-      readonly _tag: "Raw";
-      readonly payload: unknown;
-    } | {
-      readonly _tag: "Text";
-      readonly text: string;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Media" | "Raw" | "Text"]>>;
-  };
-  readonly Media: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Media";
-    readonly media: MediaSource;
-    readonly caption?: string;
-    readonly filename?: string;
-  }, "_tag">;
-  readonly Raw: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Raw";
-    readonly payload: unknown;
-  }, "_tag">;
-  readonly Text: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Text";
-    readonly text: string;
-  }, "_tag">;
-};
+declare const OutboundBody: Data.TaggedEnum.Constructor<{
+  readonly _tag: "Media";
+  readonly media: MediaSource;
+  readonly caption?: string;
+  readonly filename?: string;
+} | {
+  readonly _tag: "Raw";
+  readonly payload: unknown;
+} | {
+  readonly _tag: "Text";
+  readonly text: string;
+}>;
 /**
  * A body plus the envelope fields true of any message. `replyTo` is ignored
  * for a `Raw` body, which names its own wire fields.

package/dist/messenger/Messenger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Messenger.d.mts","names":[],"sources":["../../src/messenger/Messenger.ts"],"mappings":"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"}
+{"version":3,"file":"Messenger.d.mts","names":[],"sources":["../../src/messenger/Messenger.ts"],"mappings":";;;;;;;KASY,YAAY,MAAM;cACjB,WAAS,MAAA,YAAA;;KAGV,YAAY,MAAM;cACjB,WAAS,MAAA,YAAA;;KAGV,SAAS,MAAM;cACd,QAAM,MAAA,YAAA;;KAGP,WAAW,MAAM;cAChB,UAAQ,MAAA,YAAA;;;;;;KAOT;WACD,SAAS;WACT,SAAS;;KAGR;WACD,cAAc;WACd,IAAI;;;cAIF,kBAAe,KAAS;;;;;;;;;;;;;;KAoBzB,eAAe,KAAK;EAC9B;aACW,cAAc;aACd,IAAI;aACJ,QAAQ;aACR;aACA;aACA,UAAU;aACV;;EAEX;aACW,cAAc;aACd,SAAS;aACT;aACA,QAAQ;aACR;;EAEX;aACW,cAAc;aACd;aACA;aACA,QAAQ;aACR;;EAEX;aACW,cAAc;aACd;aACA;aACA,QAAQ;aACR;;;cAIA,cAAY,KAAA,WAAA;;WARE,cAAA;WACJ;WACF;WACA,QAAA;WACH;;;WAXS,cAAA;WACR;WACA;WACE,QAAA;WACH;;;WApBS,cAAA;WACV,IAAA;WACI,QAAA;WACF;WACK;WACD,UAAA;WACL;;;WAGS,cAAA;WACL,SAAA;WACF;WACC,QAAA;WACH;;;;;;;;;;;;;KAmCN,eAAe,KAAK;EAC9B;aAAiB;;EACjB;aACW,OAAO;aACP;aACA;;EAEX;aAAgB;;;cAGL,cAAY,KAAA,WAAA;;WAPL,OAAA;WACG;WACC;;;WAEG;;;WANF;;;;;;KAeb;WACD,MAAM;WACN,UAAU;;KAGT;WAA6B,UAAU;;;cAQtC,OAAI,cAAgB,UAAY,oBAAkB;;cAIlD,QAAK,QACR,aAAW,UACT;WAA6B;WAA2B;MACjE;;cAWU,MAAG,qBAAuB;;;;;;;;cAY1B,4BAA4B;;cAK5B,iBAAc,KACnB,qBACL,GAAG,GAAG,GAAC,QAAU,OAAO,OAAO,GAAG,GAAG,OAAK,OAAO,OAAO,GAAG,GAAG,QAAQ,GAAG;;KAQhE,gBAAgB;;KAGhB;;WAED;;WAEA;;;;;;;;;;;;;KAcC;WACD,QAAQ,OAAO,OAAO,cAAc;;WAGpC,OACP,KAAK,aACF,OAAO,OAAO,WAAW,gBAA+B;WAEpD,OACP,KAAK,YACL,MAAM,aACH,OAAO,aAAa;;;;;;WAOhB,QACP,KAAK,YACL,kBACG,OAAO,aAAa;;WAGhB,QAAQ,OAAO,aAEtB,gBACA,sBAAsB,MAAM;;;;;WAOrB,SAAS,GAAG,GACnB,QAAQ,OAAO,eAAe,GAAG,IACjC,UAAU,kBACP,OAAO,OACV,OAAO,OAAO,YACd,iBAAgC,GAChC,IAAI;WAGG,QAAQ;;;cAGN,kBAAkB;cAQlB,QAAQ,OAAO,OAAO,cAAc,gBAA+B;cAGnE,OAAI,KACV,aACJ,OAAO,OAAO,WAAW,gBAA+B,YAAY;cAG1D,OAAI,KACV,YAAU,MACT,aACL,OAAO,aAAa,gBAA+B;cAGzC,QAAK,KACX,YAAU,kBAEd,OAAO,aAAa,gBAA+B;cAGzC,QAAQ,OAAO,aAE1B,gBACA,YAAY,sBAAsB,MAAM;cAG7B,SAAU,GAAG,GAAC,QACjB,OAAO,eAAe,GAAG,IAAE,UACzB,kBACT,OAAO,OACR,OAAO,OAAO,YACd,iBAAgC,GAChC,IAAI,YAAY"}

package/dist/messenger/MessengerAdapter.test.mjs

@@ -3,7 +3,7 @@ import { splitForLimit } from "./MessengerAdapter.mjs";
 import { MessengerRateLimited } from "./MessengerError.mjs";
 import { m as describe } from "../dist-DzeSyeYF.mjs";
 import { n as globalExpect } from "../index.C4tKZ0yW-LuFnBtmu.mjs";
-import { t as it } from "../dist-C8RmtoR8.mjs";
+import { t as it } from "../dist-B5K-y4Be.mjs";
 import { make } from "../testing/MockMessenger.mjs";
 import { Array, Duration, Effect, Option, Result, Stream } from "effect";
 import { TestClock } from "effect/testing";

package/dist/observability/Metrics.d.mts

@@ -1,4 +1,4 @@
-import { S as Usage } from "../Items-C7MyrYPX.mjs";
+import { T as Usage } from "../Items-Bvx8s9QH.mjs";
 import { TurnEvent } from "../domain/Turn.mjs";
 import { Duration, Effect, Option, Stream } from "effect";
 declare namespace Metrics_d_exports {

package/dist/observability/Metrics.test.mjs

@@ -2,7 +2,7 @@ import { TurnEvent } from "../domain/Turn.mjs";
 import { computeThroughputTick, isMetricEvent, makeEvent, metricEvents, throughput, timeToCompletion, timeToFirstToken, tokenTotals } from "./Metrics.mjs";
 import { m as describe } from "../dist-DzeSyeYF.mjs";
 import { n as globalExpect } from "../index.C4tKZ0yW-LuFnBtmu.mjs";
-import { t as it } from "../dist-C8RmtoR8.mjs";
+import { t as it } from "../dist-B5K-y4Be.mjs";
 import { Array, Duration, Effect, Fiber, Option, Stream } from "effect";
 import * as TestClock from "effect/testing/TestClock";
 //#region src/observability/Metrics.test.ts

package/dist/observability/Telemetry.test.mjs

@@ -2,7 +2,7 @@ import { makeEvent } from "./Metrics.mjs";
 import { layerOtlp, record } from "./Telemetry.mjs";
 import { m as describe } from "../dist-DzeSyeYF.mjs";
 import { n as globalExpect } from "../index.C4tKZ0yW-LuFnBtmu.mjs";
-import { t as it } from "../dist-C8RmtoR8.mjs";
+import { t as it } from "../dist-B5K-y4Be.mjs";
 import { Array, Duration, Effect, Layer, Metric, Option, Ref, Stream } from "effect";
 import { HttpClient, HttpClientResponse } from "effect/http";
 //#region src/observability/Telemetry.test.ts

package/dist/realtime/RealtimeSession.d.mts

@@ -1,4 +1,4 @@
-import { o as ImageSource } from "../Image-Cv6iBLTy.mjs";
+import { o as ImageSource } from "../Image-Bzc1H_UK.mjs";
 import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { CommonSessionRequest, RealtimeEvent, RealtimeInput } from "../domain/Realtime.mjs";
 import { Context, Effect, Scope, Stream } from "effect";

package/dist/realtime/RealtimeSession.test.mjs

@@ -4,7 +4,7 @@ import { open, sendVideoFrame, toolCalls } from "./RealtimeSession.mjs";
 import { m as describe } from "../dist-DzeSyeYF.mjs";
 import { n as globalExpect } from "../index.C4tKZ0yW-LuFnBtmu.mjs";
 import { t as import_dist } from "../dist-DNeuh84d.mjs";
-import { t as it } from "../dist-C8RmtoR8.mjs";
+import { t as it } from "../dist-B5K-y4Be.mjs";
 import { layer, layerAudioOnly } from "../testing/MockRealtimeSession.mjs";
 import { Effect, Stream } from "effect";
 //#region src/realtime/RealtimeSession.test.ts