@effect-uai/core 0.15.0 → 0.17.0

package/src/streaming/WebSocketSession.ts

@@ -0,0 +1,132 @@
+/**
+ * One JSON-over-WebSocket session: connect, read decoded frames off a queue,
+ * write frames back.
+ *
+ * For duplex protocols where the caller drives the conversation frame by
+ * frame. The stream-shaped adapters (realtime STT and TTS) still carry their
+ * own copies of this.
+ */
+import {
+  Cause,
+  type Duration,
+  Effect,
+  Match,
+  Option,
+  Predicate,
+  Queue,
+  Schema,
+  type Scope,
+} from "effect"
+import * as Socket from "effect/unstable/socket/Socket"
+import * as AiError from "../domain/AiError.js"
+import * as JSONL from "./JSONL.js"
+
+export type WebSocketSession<A> = {
+  /** Fails `Unavailable` once the socket is closed. */
+  readonly send: (frame: string) => Effect.Effect<void, AiError.AiError>
+  /** Ends when the socket closes cleanly, fails when it does not. */
+  readonly frames: Queue.Dequeue<A, AiError.AiError | Cause.Done>
+}
+
+export type OpenOptions<A, I> = {
+  readonly url: string
+  readonly provider: string
+  /** Frames that do not decode are dropped, and logged at debug level. */
+  readonly schema: Schema.Codec<A, I>
+  readonly openTimeout?: Duration.Input
+  readonly capacity?: number
+}
+
+/**
+ * The cause of a failed open is a DOM `ErrorEvent`, not an `Error`, and its
+ * `message` is a prototype getter, so a structural decode does not see it.
+ */
+const describeCause = (cause: unknown): string =>
+  Predicate.hasProperty(cause, "message") && Predicate.isString(cause.message)
+    ? cause.message
+    : String(cause)
+
+/**
+ * Some wires authenticate with a key in the query string, and some runtimes
+ * name the socket URL in their open error (Bun does). Everything taken off a
+ * socket error goes through this.
+ */
+export const redactUrl = (text: string): string =>
+  text.replace(/(\b(?:wss?|https?):\/\/[^\s"']*?)\?[^\s"']*/gi, "$1?<redacted>")
+
+const detailOf = Match.type<Socket.SocketError["reason"]>().pipe(
+  Match.tag("SocketCloseError", (reason) => reason.message),
+  Match.orElse((reason) => describeCause(reason.cause)),
+)
+
+/** Never the `SocketError` itself: callers print `raw` with `Cause.pretty`. */
+const rawOf = (error: Socket.SocketError): string =>
+  redactUrl(`${error.reason._tag}: ${detailOf(error.reason)}`)
+
+/** A rejected WS upgrade surfaces only as prose, so the status is read from it. */
+const isAuthRejection = (text: string): boolean => /\b40[13]\b/.test(text)
+
+export const toAiError =
+  (provider: string) =>
+  (error: Socket.SocketError): AiError.AiError => {
+    const raw = rawOf(error)
+    return Match.value(error.reason).pipe(
+      Match.tag("SocketOpenError", (reason) =>
+        Match.value(reason.kind).pipe(
+          Match.when("Timeout", (): AiError.AiError => new AiError.Timeout({ provider, raw })),
+          Match.orElse((): AiError.AiError =>
+            isAuthRejection(describeCause(reason.cause))
+              ? new AiError.AuthFailed({ provider, subtype: "auth", raw })
+              : new AiError.Unavailable({ provider, raw }),
+          ),
+        ),
+      ),
+      Match.orElse((): AiError.AiError => new AiError.Unavailable({ provider, raw })),
+    )
+  }
+
+/**
+ * Connect for the lifetime of the surrounding `Scope`. The reader runs in a
+ * forked fiber; a dirty close reaches the consumer as a failed queue rather
+ * than a clean end.
+ */
+export const open = <A, I>(
+  options: OpenOptions<A, I>,
+): Effect.Effect<WebSocketSession<A>, AiError.AiError, Scope.Scope | Socket.WebSocketConstructor> =>
+  Effect.gen(function* () {
+    const asAiError = toAiError(options.provider)
+    const decode = Schema.decodeUnknownEffect(options.schema)
+    const socket = yield* Socket.makeWebSocket(options.url, {
+      // Effect's Socket treats every close code as an error by default.
+      closeCodeIsError: (code) => code !== 1000 && code !== 1001 && code !== 1005,
+      ...(options.openTimeout !== undefined && { openTimeout: options.openTimeout }),
+    })
+    const frames = yield* Queue.bounded<A, AiError.AiError | Cause.Done>(options.capacity ?? 64)
+    const write = yield* socket.writer
+
+    const onFrame = (raw: string) =>
+      Effect.gen(function* () {
+        const json = yield* JSONL.parseSafe(raw)
+        if (json === undefined) return
+        const decoded = yield* decode(json).pipe(Effect.option)
+        if (Option.isNone(decoded)) {
+          yield* Effect.logDebug(`[${options.provider}] dropped frame`, { frame: json })
+          return
+        }
+        yield* Queue.offer(frames, decoded.value)
+      })
+
+    yield* socket.runString(onFrame).pipe(
+      Effect.mapError(asAiError),
+      // `Queue.end` on a clean close so the consumer drains what is queued;
+      // a failure must not arrive looking like the end of the conversation.
+      Effect.matchCauseEffect({
+        onFailure: (cause) =>
+          Cause.hasFails(cause) ? Queue.failCause(frames, cause) : Queue.end(frames),
+        onSuccess: () => Queue.end(frames),
+      }),
+      Effect.forkScoped,
+    )
+
+    return { send: (frame: string) => write(frame).pipe(Effect.mapError(asAiError)), frames }
+  })

package/src/testing/FakeWebSocket.ts

@@ -0,0 +1,120 @@
+/**
+ * An in-memory WebSocket for testing socket adapters without a server.
+ *
+ * Provide `layer` in place of the real `Socket.WebSocketConstructor` and the
+ * adapter runs end to end: its own connect, handshake, decode and teardown.
+ * The test plays the other end with `reply`, `push`, `close` and `sent`.
+ *
+ * Client frames land on a queue, so the scripted server is a forked fiber and
+ * `reply` is a real Effect. What stays imperative is the listener table the
+ * shim registers, since `Socket.makeWebSocket` drives it with plain callbacks.
+ * The shim is a plain object, so nothing here touches a platform global.
+ */
+import { Effect, Layer, Queue, Ref, type Scope, Stream } from "effect"
+import * as Socket from "effect/unstable/socket/Socket"
+
+export type FakeWebSocketServer = {
+  /** Every frame the client has sent, JSON-parsed, oldest first. */
+  readonly sent: Effect.Effect<ReadonlyArray<unknown>>
+  /** Deliver one frame to the client. */
+  readonly push: (frame: unknown) => Effect.Effect<void>
+  /** Close the socket. 1000, 1001 and 1005 are the clean codes. */
+  readonly close: (code?: number) => Effect.Effect<void>
+  /** Hand this to an adapter that takes a socket constructor directly. */
+  readonly connect: Socket.WebSocketConstructor["Service"]
+  /** Provide this in place of the real constructor. */
+  readonly layer: Layer.Layer<Socket.WebSocketConstructor>
+}
+
+export type FakeWebSocketOptions = {
+  /** Pushed once the client subscribes, for a protocol whose server speaks first. */
+  readonly greeting?: ReadonlyArray<unknown>
+  /** How the server answers each client frame. */
+  readonly reply?: (frame: unknown) => Effect.Effect<ReadonlyArray<unknown>>
+}
+
+type Listener = (event: any) => void
+
+const OPEN = 1
+const CLOSED = 3
+
+/** Run after the current call unwinds, so the client is never re-entered. */
+const soon = (run: () => void): void => void Promise.resolve().then(run)
+
+export const make = (
+  options?: FakeWebSocketOptions,
+): Effect.Effect<FakeWebSocketServer, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const inbound = yield* Queue.unbounded<unknown>()
+    const sent = yield* Ref.make<ReadonlyArray<unknown>>([])
+
+    const wiring = {
+      listeners: {} as Record<string, ReadonlyArray<Listener>>,
+      readyState: OPEN,
+      greeted: false,
+    }
+
+    const emit = (type: string, event: unknown): void =>
+      (wiring.listeners[type] ?? []).forEach((listener) => listener(event))
+
+    const deliverSync = (frames: ReadonlyArray<unknown>): void =>
+      frames.forEach((f) => emit("message", { data: JSON.stringify(f) }))
+
+    const deliver = (frames: ReadonlyArray<unknown>): Effect.Effect<void> =>
+      Effect.sync(() => deliverSync(frames))
+
+    const shutdown = (code: number): void => {
+      if (wiring.readyState === CLOSED) return
+      wiring.readyState = CLOSED
+      emit("close", { code, reason: "" })
+    }
+
+    // The scripted server. Answers land on their own turn, like a real one.
+    yield* Stream.fromQueue(inbound).pipe(
+      Stream.runForEach((frame) =>
+        Effect.gen(function* () {
+          yield* Ref.update(sent, (frames) => [...frames, frame])
+          const answer = yield* options?.reply?.(frame) ?? Effect.succeed([])
+          yield* deliver(answer)
+        }),
+      ),
+      Effect.forkScoped,
+    )
+
+    const socket = {
+      get readyState() {
+        return wiring.readyState
+      },
+      addEventListener: (type: string, fn: Listener): void => {
+        wiring.listeners = {
+          ...wiring.listeners,
+          [type]: [...(wiring.listeners[type] ?? []), fn],
+        }
+        // The greeting waits for a subscriber before it lands.
+        if (type === "message" && !wiring.greeted) {
+          wiring.greeted = true
+          soon(() => deliverSync(options?.greeting ?? []))
+        }
+      },
+      removeEventListener: (type: string, fn: Listener): void => {
+        wiring.listeners = {
+          ...wiring.listeners,
+          [type]: (wiring.listeners[type] ?? []).filter((l) => l !== fn),
+        }
+      },
+      // Safe from a synchronous callback, and no runtime needed.
+      send: (data: string): void => void Queue.offerUnsafe(inbound, JSON.parse(data)),
+      close: (code = 1000): void => shutdown(code),
+    }
+
+    const connect: Socket.WebSocketConstructor["Service"] = () =>
+      socket as unknown as globalThis.WebSocket
+
+    return {
+      sent: Ref.get(sent),
+      push: (frame) => deliver([frame]),
+      close: (code = 1000) => Effect.sync(() => shutdown(code)),
+      connect,
+      layer: Layer.succeed(Socket.WebSocketConstructor, connect),
+    }
+  })

package/src/testing/MockRealtimeSession.ts

@@ -0,0 +1,92 @@
+import { Cause, Effect, Layer, Queue, Ref, Stream } from "effect"
+import type { CommonSessionRequest, RealtimeEvent, RealtimeInput } from "../domain/Realtime.js"
+import {
+  RealtimeSession,
+  RealtimeVideoInput,
+  type RealtimeSessionHandle,
+  type RealtimeSessionService,
+} from "../realtime/RealtimeSession.js"
+
+export type MockRealtimeSessionRecorder = {
+  readonly openCalls: ReadonlyArray<CommonSessionRequest>
+  readonly sent: ReadonlyArray<RealtimeInput>
+}
+
+export type MockRealtimeSessionScript = {
+  /** Emitted as soon as the session opens. */
+  readonly initial?: ReadonlyArray<RealtimeEvent>
+  /** The server's answer to each input. */
+  readonly onInput?: (input: RealtimeInput) => ReadonlyArray<RealtimeEvent>
+}
+
+type Recorders = {
+  readonly open: (request: CommonSessionRequest) => Effect.Effect<void>
+  readonly send: (input: RealtimeInput) => Effect.Effect<void>
+}
+
+const makeService = (
+  script: MockRealtimeSessionScript,
+  record: Recorders,
+): RealtimeSessionService => ({
+  open: (request) =>
+    Effect.gen(function* () {
+      yield* record.open(request)
+      const queue = yield* Queue.unbounded<RealtimeEvent, Cause.Done>()
+      // Closing the scope ends `events`, leaving anything already queued to drain.
+      yield* Effect.addFinalizer(() => Queue.end(queue))
+      yield* Queue.offerAll(queue, script.initial ?? [])
+      const handle: RealtimeSessionHandle = {
+        send: (input) =>
+          Effect.andThen(
+            record.send(input),
+            Queue.offerAll(queue, script.onInput?.(input) ?? []),
+          ).pipe(Effect.asVoid),
+        events: Stream.fromQueue(queue),
+      }
+      return handle
+    }),
+})
+
+const build = (script: MockRealtimeSessionScript) => {
+  const openCalls = Ref.makeUnsafe<ReadonlyArray<CommonSessionRequest>>([])
+  const sent = Ref.makeUnsafe<ReadonlyArray<RealtimeInput>>([])
+  const sessionLayer = Layer.succeed(
+    RealtimeSession,
+    makeService(script, {
+      open: (request) => Ref.update(openCalls, (xs) => [...xs, request]),
+      send: (input) => Ref.update(sent, (xs) => [...xs, input]),
+    }),
+  )
+  const recorder: Effect.Effect<MockRealtimeSessionRecorder> = Effect.gen(function* () {
+    return { openCalls: yield* Ref.get(openCalls), sent: yield* Ref.get(sent) }
+  })
+  return { sessionLayer, recorder }
+}
+
+/** Scripted session that also ships the `RealtimeVideoInput` marker. */
+export const layer = (
+  script: MockRealtimeSessionScript,
+): {
+  readonly layer: Layer.Layer<RealtimeSession | RealtimeVideoInput>
+  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>
+} => {
+  const { sessionLayer, recorder } = build(script)
+  return {
+    layer: Layer.merge(sessionLayer, Layer.succeed(RealtimeVideoInput, undefined)),
+    recorder,
+  }
+}
+
+/**
+ * The same without the marker, to test that a caller sending video against an
+ * audio-only provider fails to compile.
+ */
+export const layerAudioOnly = (
+  script: MockRealtimeSessionScript,
+): {
+  readonly layer: Layer.Layer<RealtimeSession>
+  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>
+} => {
+  const { sessionLayer, recorder } = build(script)
+  return { layer: sessionLayer, recorder }
+}

package/dist/inbox/Inbox.d.mts

@@ -1,16 +0,0 @@
-import { Array, Duration, Effect, Queue } from "effect";
-declare namespace Inbox_d_exports {
-  export { drainBurst };
-}
-/**
- * Block for the first item, then keep taking while the next one lands within
- * `settle` of the previous. The window resets on every arrival, so a burst
- * becomes one batch and a lone message followed by silence returns at once.
- *
- * A take that loses to the window is interrupted before it removes anything,
- * so late arrivals stay queued for the next drain.
- */
-declare const drainBurst: <A, E>(queue: Queue.Dequeue<A, E>, settle: Duration.Input) => Effect.Effect<Array.NonEmptyReadonlyArray<A>, E>;
-//#endregion
-export { drainBurst, Inbox_d_exports as t };
-//# sourceMappingURL=Inbox.d.mts.map

package/dist/inbox/Inbox.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Inbox.d.mts","names":[],"sources":["../../src/inbox/Inbox.ts"],"mappings":";;;;;;;;;;;;cAea,aAAc,GAAG,GAAC,OACtB,MAAM,QAAQ,GAAG,IAAE,QAClB,SAAS,UAChB,OAAO,OAAO,MAAI,sBAAsB,IAAI"}

package/dist/inbox/Inbox.mjs

@@ -1,28 +0,0 @@
-import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
-import { Array, Effect, Option, Queue } from "effect";
-//#region src/inbox/Inbox.ts
-/**
-* Input a long-lived agent reads between turns. A chat user rarely sends one
-* tidy message: they type three lines in a row, then go quiet. The loop wants
-* that as one batch, taken at a clean turn boundary.
-*/
-var Inbox_exports = /* @__PURE__ */ __exportAll({ drainBurst: () => drainBurst });
-/**
-* Block for the first item, then keep taking while the next one lands within
-* `settle` of the previous. The window resets on every arrival, so a burst
-* becomes one batch and a lone message followed by silence returns at once.
-*
-* A take that loses to the window is interrupted before it removes anything,
-* so late arrivals stay queued for the next drain.
-*/
-const drainBurst = (queue, settle) => {
-	const settled = (batch) => Queue.take(queue).pipe(Effect.timeoutOption(settle), Effect.flatMap(Option.match({
-		onNone: () => Effect.succeed(batch),
-		onSome: (item) => settled(Array.append(batch, item))
-	})));
-	return Effect.flatMap(Queue.take(queue), (first) => settled([first]));
-};
-//#endregion
-export { drainBurst, Inbox_exports as t };
-
-//# sourceMappingURL=Inbox.mjs.map

package/dist/inbox/Inbox.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Inbox.mjs","names":["Arr"],"sources":["../../src/inbox/Inbox.ts"],"sourcesContent":["/**\n * Input a long-lived agent reads between turns. A chat user rarely sends one\n * tidy message: they type three lines in a row, then go quiet. The loop wants\n * that as one batch, taken at a clean turn boundary.\n */\nimport { Array as Arr, type Duration, Effect, Option, Queue } from \"effect\"\n\n/**\n * Block for the first item, then keep taking while the next one lands within\n * `settle` of the previous. The window resets on every arrival, so a burst\n * becomes one batch and a lone message followed by silence returns at once.\n *\n * A take that loses to the window is interrupted before it removes anything,\n * so late arrivals stay queued for the next drain.\n */\nexport const drainBurst = <A, E>(\n  queue: Queue.Dequeue<A, E>,\n  settle: Duration.Input,\n): Effect.Effect<Arr.NonEmptyReadonlyArray<A>, E> => {\n  const settled = (\n    batch: Arr.NonEmptyReadonlyArray<A>,\n  ): Effect.Effect<Arr.NonEmptyReadonlyArray<A>, E> =>\n    Queue.take(queue).pipe(\n      Effect.timeoutOption(settle),\n      Effect.flatMap(\n        Option.match({\n          onNone: () => Effect.succeed(batch),\n          onSome: (item) => settled(Arr.append(batch, item)),\n        }),\n      ),\n    )\n  return Effect.flatMap(Queue.take(queue), (first) => settled([first]))\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,MAAa,cACX,OACA,WACmD;CACnD,MAAM,WACJ,UAEA,MAAM,KAAK,KAAK,CAAC,CAAC,KAChB,OAAO,cAAc,MAAM,GAC3B,OAAO,QACL,OAAO,MAAM;EACX,cAAc,OAAO,QAAQ,KAAK;EAClC,SAAS,SAAS,QAAQA,MAAI,OAAO,OAAO,IAAI,CAAC;CACnD,CAAC,CACH,CACF;CACF,OAAO,OAAO,QAAQ,MAAM,KAAK,KAAK,IAAI,UAAU,QAAQ,CAAC,KAAK,CAAC,CAAC;AACtE"}

package/dist/inbox/Inbox.test.mjs

@@ -1,42 +0,0 @@
-import { drainBurst } from "./Inbox.mjs";
-import { o as describe } from "../utils-CiH_DjFW.mjs";
-import { n as globalExpect } from "../test.DNmyFkvJ-YPzDR0Co.mjs";
-import { t as it } from "../dist-nohcnkD6.mjs";
-import { Effect, Fiber, Option, Queue } from "effect";
-import { TestClock } from "effect/testing";
-//#region src/inbox/Inbox.test.ts
-describe("drainBurst", () => {
-	it.effect("resets the window on every arrival, so a burst outlives one settle", () => Effect.gen(function* () {
-		const queue = yield* Queue.unbounded();
-		const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"));
-		yield* Queue.offer(queue, "a");
-		yield* TestClock.adjust("900 millis");
-		yield* Queue.offer(queue, "b");
-		yield* TestClock.adjust("900 millis");
-		globalExpect(burst.pollUnsafe()).toBeUndefined();
-		yield* TestClock.adjust("1 second");
-		globalExpect(yield* Fiber.join(burst)).toEqual(["a", "b"]);
-	}));
-	it.effect("waits for the first item without a deadline", () => Effect.gen(function* () {
-		const queue = yield* Queue.unbounded();
-		const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"));
-		yield* TestClock.adjust("1 hour");
-		globalExpect(burst.pollUnsafe()).toBeUndefined();
-		yield* Queue.offer(queue, "late");
-		yield* TestClock.adjust("1 second");
-		globalExpect(yield* Fiber.join(burst)).toEqual(["late"]);
-	}));
-	it.effect("ends on the first quiet gap and leaves later items for the next drain", () => Effect.gen(function* () {
-		const queue = yield* Queue.unbounded();
-		const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"));
-		yield* Queue.offer(queue, "first");
-		yield* TestClock.adjust("1 second");
-		globalExpect(yield* Fiber.join(burst)).toEqual(["first"]);
-		yield* Queue.offer(queue, "second");
-		globalExpect(yield* Queue.poll(queue)).toEqual(Option.some("second"));
-	}));
-});
-//#endregion
-export {};
-
-//# sourceMappingURL=Inbox.test.mjs.map

package/dist/inbox/Inbox.test.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Inbox.test.mjs","names":[],"sources":["../../src/inbox/Inbox.test.ts"],"sourcesContent":["import { describe, it } from \"@effect/vitest\"\nimport { Effect, Fiber, Option, Queue } from \"effect\"\nimport { TestClock } from \"effect/testing\"\nimport { expect } from \"vitest\"\nimport { drainBurst } from \"./Inbox.js\"\n\ndescribe(\"drainBurst\", () => {\n  it.effect(\"resets the window on every arrival, so a burst outlives one settle\", () =>\n    Effect.gen(function* () {\n      const queue = yield* Queue.unbounded<string>()\n      const burst = yield* Effect.forkChild(drainBurst(queue, \"1 second\"))\n\n      yield* Queue.offer(queue, \"a\")\n      yield* TestClock.adjust(\"900 millis\")\n      yield* Queue.offer(queue, \"b\")\n      yield* TestClock.adjust(\"900 millis\")\n      // 1.8s elapsed, more than one settle, and the burst is still open.\n      expect(burst.pollUnsafe()).toBeUndefined()\n\n      yield* TestClock.adjust(\"1 second\")\n      expect(yield* Fiber.join(burst)).toEqual([\"a\", \"b\"])\n    }),\n  )\n\n  it.effect(\"waits for the first item without a deadline\", () =>\n    Effect.gen(function* () {\n      const queue = yield* Queue.unbounded<string>()\n      const burst = yield* Effect.forkChild(drainBurst(queue, \"1 second\"))\n\n      yield* TestClock.adjust(\"1 hour\")\n      expect(burst.pollUnsafe()).toBeUndefined()\n\n      yield* Queue.offer(queue, \"late\")\n      yield* TestClock.adjust(\"1 second\")\n      expect(yield* Fiber.join(burst)).toEqual([\"late\"])\n    }),\n  )\n\n  it.effect(\"ends on the first quiet gap and leaves later items for the next drain\", () =>\n    Effect.gen(function* () {\n      const queue = yield* Queue.unbounded<string>()\n      const burst = yield* Effect.forkChild(drainBurst(queue, \"1 second\"))\n\n      yield* Queue.offer(queue, \"first\")\n      yield* TestClock.adjust(\"1 second\")\n      expect(yield* Fiber.join(burst)).toEqual([\"first\"])\n\n      yield* Queue.offer(queue, \"second\")\n      expect(yield* Queue.poll(queue)).toEqual(Option.some(\"second\"))\n    }),\n  )\n})\n"],"mappings":";;;;;;;AAMA,SAAS,oBAAoB;CAC3B,GAAG,OAAO,4EACR,OAAO,IAAI,aAAa;EACtB,MAAM,QAAQ,OAAO,MAAM,UAAkB;EAC7C,MAAM,QAAQ,OAAO,OAAO,UAAU,WAAW,OAAO,UAAU,CAAC;EAEnE,OAAO,MAAM,MAAM,OAAO,GAAG;EAC7B,OAAO,UAAU,OAAO,YAAY;EACpC,OAAO,MAAM,MAAM,OAAO,GAAG;EAC7B,OAAO,UAAU,OAAO,YAAY;EAEpC,aAAO,MAAM,WAAW,CAAC,CAAC,CAAC,cAAc;EAEzC,OAAO,UAAU,OAAO,UAAU;EAClC,aAAO,OAAO,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC;CACrD,CAAC,CACH;CAEA,GAAG,OAAO,qDACR,OAAO,IAAI,aAAa;EACtB,MAAM,QAAQ,OAAO,MAAM,UAAkB;EAC7C,MAAM,QAAQ,OAAO,OAAO,UAAU,WAAW,OAAO,UAAU,CAAC;EAEnE,OAAO,UAAU,OAAO,QAAQ;EAChC,aAAO,MAAM,WAAW,CAAC,CAAC,CAAC,cAAc;EAEzC,OAAO,MAAM,MAAM,OAAO,MAAM;EAChC,OAAO,UAAU,OAAO,UAAU;EAClC,aAAO,OAAO,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;CACnD,CAAC,CACH;CAEA,GAAG,OAAO,+EACR,OAAO,IAAI,aAAa;EACtB,MAAM,QAAQ,OAAO,MAAM,UAAkB;EAC7C,MAAM,QAAQ,OAAO,OAAO,UAAU,WAAW,OAAO,UAAU,CAAC;EAEnE,OAAO,MAAM,MAAM,OAAO,OAAO;EACjC,OAAO,UAAU,OAAO,UAAU;EAClC,aAAO,OAAO,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;EAElD,OAAO,MAAM,MAAM,OAAO,QAAQ;EAClC,aAAO,OAAO,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,OAAO,KAAK,QAAQ,CAAC;CAChE,CAAC,CACH;AACF,CAAC"}

package/src/inbox/Inbox.test.ts

@@ -1,52 +0,0 @@
-import { describe, it } from "@effect/vitest"
-import { Effect, Fiber, Option, Queue } from "effect"
-import { TestClock } from "effect/testing"
-import { expect } from "vitest"
-import { drainBurst } from "./Inbox.js"
-
-describe("drainBurst", () => {
-  it.effect("resets the window on every arrival, so a burst outlives one settle", () =>
-    Effect.gen(function* () {
-      const queue = yield* Queue.unbounded<string>()
-      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
-
-      yield* Queue.offer(queue, "a")
-      yield* TestClock.adjust("900 millis")
-      yield* Queue.offer(queue, "b")
-      yield* TestClock.adjust("900 millis")
-      // 1.8s elapsed, more than one settle, and the burst is still open.
-      expect(burst.pollUnsafe()).toBeUndefined()
-
-      yield* TestClock.adjust("1 second")
-      expect(yield* Fiber.join(burst)).toEqual(["a", "b"])
-    }),
-  )
-
-  it.effect("waits for the first item without a deadline", () =>
-    Effect.gen(function* () {
-      const queue = yield* Queue.unbounded<string>()
-      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
-
-      yield* TestClock.adjust("1 hour")
-      expect(burst.pollUnsafe()).toBeUndefined()
-
-      yield* Queue.offer(queue, "late")
-      yield* TestClock.adjust("1 second")
-      expect(yield* Fiber.join(burst)).toEqual(["late"])
-    }),
-  )
-
-  it.effect("ends on the first quiet gap and leaves later items for the next drain", () =>
-    Effect.gen(function* () {
-      const queue = yield* Queue.unbounded<string>()
-      const burst = yield* Effect.forkChild(drainBurst(queue, "1 second"))
-
-      yield* Queue.offer(queue, "first")
-      yield* TestClock.adjust("1 second")
-      expect(yield* Fiber.join(burst)).toEqual(["first"])
-
-      yield* Queue.offer(queue, "second")
-      expect(yield* Queue.poll(queue)).toEqual(Option.some("second"))
-    }),
-  )
-})

package/src/inbox/Inbox.ts

@@ -1,33 +0,0 @@
-/**
- * Input a long-lived agent reads between turns. A chat user rarely sends one
- * tidy message: they type three lines in a row, then go quiet. The loop wants
- * that as one batch, taken at a clean turn boundary.
- */
-import { Array as Arr, type Duration, Effect, Option, Queue } from "effect"
-
-/**
- * Block for the first item, then keep taking while the next one lands within
- * `settle` of the previous. The window resets on every arrival, so a burst
- * becomes one batch and a lone message followed by silence returns at once.
- *
- * A take that loses to the window is interrupted before it removes anything,
- * so late arrivals stay queued for the next drain.
- */
-export const drainBurst = <A, E>(
-  queue: Queue.Dequeue<A, E>,
-  settle: Duration.Input,
-): Effect.Effect<Arr.NonEmptyReadonlyArray<A>, E> => {
-  const settled = (
-    batch: Arr.NonEmptyReadonlyArray<A>,
-  ): Effect.Effect<Arr.NonEmptyReadonlyArray<A>, E> =>
-    Queue.take(queue).pipe(
-      Effect.timeoutOption(settle),
-      Effect.flatMap(
-        Option.match({
-          onNone: () => Effect.succeed(batch),
-          onSome: (item) => settled(Arr.append(batch, item)),
-        }),
-      ),
-    )
-  return Effect.flatMap(Queue.take(queue), (first) => settled([first]))
-}