@effect-uai/core 0.9.0 → 0.11.0

package/src/job/Job.ts

@@ -0,0 +1,125 @@
+import { Duration, Effect, Schedule } from "effect"
+import * as AiError from "../domain/AiError.js"
+
+// ---------------------------------------------------------------------------
+// Status + handle
+// ---------------------------------------------------------------------------
+
+/**
+ * Normalized state of a provider-hosted background job. Implementors map their
+ * provider's status vocabulary onto these four states. The terminal states
+ * carry their payload: `Succeeded` the collected result, `Failed` an optional
+ * reason and the raw provider error. This mirrors the wire, where a single
+ * poll response returns both status and (when done) the result.
+ */
+export type JobState<A> =
+  | { readonly _tag: "Pending" }
+  | { readonly _tag: "Running" }
+  | { readonly _tag: "Succeeded"; readonly result: A }
+  | { readonly _tag: "Failed"; readonly reason?: string; readonly raw?: unknown }
+
+/** The two states that end a poll loop. */
+export const isSettled = <A>(
+  state: JobState<A>,
+): state is Extract<JobState<A>, { _tag: "Succeeded" | "Failed" }> =>
+  state._tag === "Succeeded" || state._tag === "Failed"
+
+declare const ResultType: unique symbol
+
+/**
+ * Opaque, provider-tagged handle to a running background job. Jobs can run for
+ * minutes and outlive a single process, so the handle is detachable: submit
+ * now, collect later. `provider` tags who owns `id`.
+ *
+ * Parameterized by the result type `A` it collects to, so a ref cannot be
+ * crossed between capabilities (a `JobRef<Turn>` is not a `JobRef<VideoResult>`).
+ * The brand is phantom: the runtime value is just `{ _tag, provider, id }`, so
+ * a ref stays plain serializable data for persistence across restarts.
+ */
+export type JobRef<A = unknown> = {
+  readonly _tag: "JobRef"
+  readonly provider: string
+  readonly id: string
+  readonly [ResultType]?: A
+}
+
+export const jobRef = <A = unknown>(provider: string, id: string): JobRef<A> => ({
+  _tag: "JobRef",
+  provider,
+  id,
+})
+
+// ---------------------------------------------------------------------------
+// Poll driver
+// ---------------------------------------------------------------------------
+
+/**
+ * The three wire operations a poll-based async job supplies. `run` / `collect`
+ * drive the submit -> poll -> settle cadence around them, so an implementor
+ * states only its provider calls, not the loop. `poll` returns the current
+ * `JobState`, carrying the result in `Succeeded`. Generic over the collected
+ * `Result`.
+ */
+export type JobOps<Result> = {
+  readonly submit: Effect.Effect<JobRef<Result>, AiError.AiError>
+  readonly poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError.AiError>
+  readonly cancel: (ref: JobRef<Result>) => Effect.Effect<void, AiError.AiError>
+}
+
+export type JobConfig = {
+  /** Cadence between status fetches. Default 10 seconds, jittered. */
+  readonly pollInterval?: Duration.Input
+  /** Overall wait cap; exceeding it fails `Timeout`. Default 45 minutes. */
+  readonly timeout?: Duration.Input
+}
+
+const DEFAULT_POLL_INTERVAL: Duration.Input = "10 seconds"
+const DEFAULT_TIMEOUT: Duration.Input = "45 minutes"
+
+/**
+ * Poll `poll(ref)` on a jittered fixed cadence until the job settles, then
+ * return the result or fail `GenerationFailed`. Bounded by `timeout`, which
+ * fails `Timeout` if the job never settles. Takes the poll op alone (not the
+ * full `JobOps`) so a detached `collect(ref)` needs no submit-bound request.
+ */
+export const collect = <Result>(
+  poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError.AiError>,
+  ref: JobRef<Result>,
+  config?: JobConfig,
+): Effect.Effect<Result, AiError.AiError> =>
+  poll(ref).pipe(
+    Effect.repeat({
+      schedule: Schedule.jittered(Schedule.spaced(config?.pollInterval ?? DEFAULT_POLL_INTERVAL)),
+      until: isSettled,
+    }),
+    Effect.flatMap((state) =>
+      state._tag === "Succeeded"
+        ? Effect.succeed(state.result)
+        : Effect.fail(
+            new AiError.GenerationFailed({
+              provider: ref.provider,
+              message: state._tag === "Failed" ? (state.reason ?? "job failed") : "job failed",
+              raw: state._tag === "Failed" ? (state.raw ?? ref) : ref,
+            }),
+          ),
+    ),
+    Effect.timeoutOrElse({
+      duration: config?.timeout ?? DEFAULT_TIMEOUT,
+      orElse: () => Effect.fail(new AiError.Timeout({ provider: ref.provider, raw: ref })),
+    }),
+  )
+
+/**
+ * Submit, then poll to completion. Best-effort cancels the server job if the
+ * caller interrupts (where the provider supports it). The one-call path; use
+ * `ops.submit` + `collect` directly for the detached case.
+ */
+export const run = <Result>(
+  ops: JobOps<Result>,
+  config?: JobConfig,
+): Effect.Effect<Result, AiError.AiError> =>
+  ops.submit.pipe(
+    Effect.flatMap((ref) =>
+      collect(ops.poll, ref, config).pipe(Effect.onInterrupt(() => Effect.ignore(ops.cancel(ref)))),
+    ),
+  )

package/src/language-model/LanguageModel.ts

@@ -65,7 +65,7 @@ export class LanguageModel extends Context.Service<LanguageModel, LanguageModelS
 export const streamTurn = (
   request: CommonRequest,
 ): Stream.Stream<TurnEvent, AiError.AiError, LanguageModel> =>
-  Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)))
+  Stream.unwrap(Effect.map(LanguageModel, (m) => m.streamTurn(request)))
 
 /**
  * Drain a single turn and return the assembled `Turn`. Delegates to the
@@ -74,7 +74,7 @@ export const streamTurn = (
  * {@link turnFromStream}.
  */
 export const turn = (request: CommonRequest): Effect.Effect<Turn, AiError.AiError, LanguageModel> =>
-  Effect.flatMap(LanguageModel.asEffect(), (m) => m.turn(request))
+  Effect.flatMap(LanguageModel, (m) => m.turn(request))
 
 /**
  * Build a `turn` implementation from a `streamTurn` implementation.

package/src/music-generator/MusicGenerator.ts

@@ -94,13 +94,13 @@ export class MusicInteractiveSession extends Context.Service<MusicInteractiveSes
 export const generate = (
   request: CommonGenerateMusicRequest,
 ): Effect.Effect<GenerateResult, AiError.AiError, MusicGenerator> =>
-  Effect.flatMap(MusicGenerator.asEffect(), (s) => s.generate(request))
+  Effect.flatMap(MusicGenerator, (s) => s.generate(request))
 
 /** Prompt in, audio chunks out. */
 export const streamGeneration = (
   request: CommonStreamGenerateMusicRequest,
 ): Stream.Stream<AudioChunk, AiError.AiError, MusicGenerator> =>
-  Stream.unwrap(Effect.map(MusicGenerator.asEffect(), (s) => s.streamGeneration(request)))
+  Stream.unwrap(Effect.map(MusicGenerator, (s) => s.streamGeneration(request)))
 
 /**
  * Bidirectional generation. Dual-arity: pipeable (data-last) and
@@ -156,8 +156,8 @@ export const streamGenerationFrom: {
   > =>
     Stream.unwrap(
       Effect.gen(function* () {
-        const s = yield* MusicGenerator.asEffect()
-        yield* MusicInteractiveSession.asEffect()
+        const s = yield* MusicGenerator
+        yield* MusicInteractiveSession
         return s.streamGenerationFrom(input, request)
       }),
     ),

package/src/research/DeepResearch.ts

@@ -0,0 +1,137 @@
+import { Context, Effect, Stream } from "effect"
+import * as AiError from "../domain/AiError.js"
+import * as Job from "../job/Job.js"
+import type { ResearchJobRef, ResearchRequest, ResearchState } from "../domain/Research.js"
+import type { Turn } from "../domain/Turn.js"
+import { TurnEvent } from "../domain/Turn.js"
+
+export type { ResearchJobRef, ResearchRequest, ResearchState } from "../domain/Research.js"
+
+/**
+ * Deep research: submit a question, watch a long-running background job, collect
+ * one cited report. Every provider is modeled as a job (`submit` / `poll` /
+ * `cancel`), so the surface is uniform. The convenience derivations
+ * (`research` / `researchStream` / `collect` / `status`) are the same for every
+ * provider and are built once by {@link fromJob}, so an implementor states only
+ * its wire calls, never the poll loop.
+ *
+ * `research` is the blocking one-liner (submit then poll to the terminal `Turn`);
+ * `researchStream` forwards live progress as `TurnEvent`s, terminating in
+ * `TurnComplete` whose `turn` is the value `research` / `collect` return. The job
+ * ref is plain serializable data, so it can be persisted and collected from a
+ * later process where the provider's job is server-backed.
+ */
+export type DeepResearchServiceShape<Req> = {
+  readonly submit: (request: Req) => Effect.Effect<ResearchJobRef, AiError.AiError>
+  readonly status: (ref: ResearchJobRef) => Effect.Effect<ResearchState, AiError.AiError>
+  readonly collect: (ref: ResearchJobRef) => Effect.Effect<Turn, AiError.AiError>
+  readonly streamFrom: (ref: ResearchJobRef) => Stream.Stream<TurnEvent, AiError.AiError>
+  readonly cancel: (ref: ResearchJobRef) => Effect.Effect<void, AiError.AiError>
+  readonly research: (request: Req) => Effect.Effect<Turn, AiError.AiError>
+  readonly researchStream: (request: Req) => Stream.Stream<TurnEvent, AiError.AiError>
+}
+
+export type DeepResearchService = DeepResearchServiceShape<ResearchRequest>
+
+export class DeepResearch extends Context.Service<DeepResearch, DeepResearchService>()(
+  "@betalyra/effect-uai/DeepResearch",
+) {}
+
+// ---------------------------------------------------------------------------
+// fromJob: build the whole service from the three job ops (+ an optional real
+// live stream). The derivations are identical for every provider.
+// ---------------------------------------------------------------------------
+
+/** The wire ops a provider supplies. `streamFrom` is optional: poll-only jobs
+ *  get a synthesized stream ({@link synthesizedStream}) in its place. */
+export type ResearchJobOps<Req> = {
+  readonly submit: (request: Req) => Effect.Effect<ResearchJobRef, AiError.AiError>
+  readonly poll: (ref: ResearchJobRef) => Effect.Effect<ResearchState, AiError.AiError>
+  readonly cancel: (ref: ResearchJobRef) => Effect.Effect<void, AiError.AiError>
+  readonly streamFrom?: (ref: ResearchJobRef) => Stream.Stream<TurnEvent, AiError.AiError>
+}
+
+// A poll-only job has no event stream, so synthesize one: a leading "searching"
+// progress event, then the terminal `TurnComplete` off the poll loop. Honest
+// low-fidelity progress, not a fabricated per-search feed.
+const synthesizedStream = <Req>(
+  ops: ResearchJobOps<Req>,
+  ref: ResearchJobRef,
+  config?: Job.JobConfig,
+): Stream.Stream<TurnEvent, AiError.AiError> =>
+  Stream.concat(
+    Stream.make(TurnEvent.WebSearchCall({ status: "searching" })),
+    Stream.map(Stream.fromEffect(Job.collect(ops.poll, ref, config)), (turn) =>
+      TurnEvent.TurnComplete({ turn }),
+    ),
+  )
+
+/**
+ * Assemble a {@link DeepResearchServiceShape} from the job ops. `research` is
+ * `submit` then poll-to-settle (best-effort cancel on interrupt, via
+ * {@link Job.run}); `collect` / `status` are the detached equivalents;
+ * `researchStream` submits then attaches. Generic over the request type so a
+ * provider-typed tag keeps its narrowed `submit`. `config` tunes the poll
+ * cadence and overall timeout of every derived poll loop (see
+ * {@link Job.JobConfig} for the defaults).
+ */
+export const fromJob = <Req extends ResearchRequest>(
+  ops: ResearchJobOps<Req>,
+  config?: Job.JobConfig,
+): DeepResearchServiceShape<Req> => {
+  const streamFrom =
+    ops.streamFrom ?? ((ref: ResearchJobRef) => synthesizedStream(ops, ref, config))
+  return {
+    submit: ops.submit,
+    status: ops.poll,
+    collect: (ref) => Job.collect(ops.poll, ref, config),
+    cancel: ops.cancel,
+    streamFrom,
+    research: (request) =>
+      Job.run({ submit: ops.submit(request), poll: ops.poll, cancel: ops.cancel }, config),
+    researchStream: (request) => Stream.unwrap(Effect.map(ops.submit(request), streamFrom)),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Top-level accessors over the generic tag. Portable code uses these; they
+// require only `DeepResearch` in `R`.
+// ---------------------------------------------------------------------------
+
+/** Submit and poll to the terminal `Turn`. Cancels the job on interrupt. */
+export const research = (
+  request: ResearchRequest,
+): Effect.Effect<Turn, AiError.AiError, DeepResearch> =>
+  Effect.flatMap(DeepResearch, (s) => s.research(request))
+
+/** Submit and forward live progress, terminating in `TurnComplete`. */
+export const researchStream = (
+  request: ResearchRequest,
+): Stream.Stream<TurnEvent, AiError.AiError, DeepResearch> =>
+  Stream.unwrap(Effect.map(DeepResearch, (s) => s.researchStream(request)))
+
+/** Submit a detached job and return its ref. */
+export const submit = (
+  request: ResearchRequest,
+): Effect.Effect<ResearchJobRef, AiError.AiError, DeepResearch> =>
+  Effect.flatMap(DeepResearch, (s) => s.submit(request))
+
+/** Current state of a job. */
+export const status = (
+  ref: ResearchJobRef,
+): Effect.Effect<ResearchState, AiError.AiError, DeepResearch> =>
+  Effect.flatMap(DeepResearch, (s) => s.status(ref))
+
+/** Poll a detached job to completion. */
+export const collect = (ref: ResearchJobRef): Effect.Effect<Turn, AiError.AiError, DeepResearch> =>
+  Effect.flatMap(DeepResearch, (s) => s.collect(ref))
+
+/** Attach a live progress stream to a job (call again to re-attach). */
+export const streamFrom = (
+  ref: ResearchJobRef,
+): Stream.Stream<TurnEvent, AiError.AiError, DeepResearch> =>
+  Stream.unwrap(Effect.map(DeepResearch, (s) => s.streamFrom(ref)))
+
+/** Cancel a running job. */
+export const cancel = (ref: ResearchJobRef): Effect.Effect<void, AiError.AiError, DeepResearch> =>
+  Effect.flatMap(DeepResearch, (s) => s.cancel(ref))

package/src/sandbox/Sandbox.ts

@@ -520,7 +520,7 @@ export class SandboxPortExposure extends Context.Service<SandboxPortExposure, vo
 export const create = (
   request: CommonCreateRequest,
 ): Effect.Effect<SandboxInstance, SandboxError.SandboxError, Sandbox | Scope.Scope> =>
-  Effect.flatMap(Sandbox.asEffect(), (s) => s.create(request))
+  Effect.flatMap(Sandbox, (s) => s.create(request))
 
 /**
  * Re-acquire an existing sandbox by id. Same scope semantics as
@@ -529,14 +529,14 @@ export const create = (
 export const attach = (
   id: SandboxId,
 ): Effect.Effect<SandboxInstance, SandboxError.SandboxError, Sandbox | Scope.Scope> =>
-  Effect.flatMap(Sandbox.asEffect(), (s) => s.attach(id))
+  Effect.flatMap(Sandbox, (s) => s.attach(id))
 
 /** Enumerate sandboxes for the configured account / project. */
 export const list: Effect.Effect<
   ReadonlyArray<SandboxRef>,
   SandboxError.SandboxError,
   Sandbox
-> = Effect.flatMap(Sandbox.asEffect(), (s) => s.list)
+> = Effect.flatMap(Sandbox, (s) => s.list)
 
 /**
  * Escape hatch for destroying a sandbox from outside its owning
@@ -544,7 +544,7 @@ export const list: Effect.Effect<
  * automatically.
  */
 export const destroy = (id: SandboxId): Effect.Effect<void, SandboxError.SandboxError, Sandbox> =>
-  Effect.flatMap(Sandbox.asEffect(), (s) => s.destroy(id))
+  Effect.flatMap(Sandbox, (s) => s.destroy(id))
 
 /**
  * Create a snapshot of a live sandbox. Requires
@@ -557,8 +557,8 @@ export const snapshot = (
   name?: string,
 ): Effect.Effect<SnapshotId, SandboxError.SandboxError, Sandbox | SandboxSnapshots> =>
   Effect.gen(function* () {
-    const s = yield* Sandbox.asEffect()
-    yield* SandboxSnapshots.asEffect()
+    const s = yield* Sandbox
+    yield* SandboxSnapshots
     return yield* s.snapshots.create(from, name)
   })
 
@@ -570,8 +570,8 @@ export const createVolume = (
   options?: { readonly quotaBytes?: number },
 ): Effect.Effect<VolumeId, SandboxError.SandboxError, Sandbox | SandboxVolumes> =>
   Effect.gen(function* () {
-    const s = yield* Sandbox.asEffect()
-    yield* SandboxVolumes.asEffect()
+    const s = yield* Sandbox
+    yield* SandboxVolumes
     return yield* s.volumes.create(name, options)
   })
 
@@ -580,8 +580,8 @@ export const destroyVolume = (
   id: VolumeId,
 ): Effect.Effect<void, SandboxError.SandboxError, Sandbox | SandboxVolumes> =>
   Effect.gen(function* () {
-    const s = yield* Sandbox.asEffect()
-    yield* SandboxVolumes.asEffect()
+    const s = yield* Sandbox
+    yield* SandboxVolumes
     return yield* s.volumes.destroy(id)
   })
 
@@ -591,8 +591,8 @@ export const listVolumes: Effect.Effect<
   SandboxError.SandboxError,
   Sandbox | SandboxVolumes
 > = Effect.gen(function* () {
-  const s = yield* Sandbox.asEffect()
-  yield* SandboxVolumes.asEffect()
+  const s = yield* Sandbox
+  yield* SandboxVolumes
   return yield* s.volumes.list
 })
 
@@ -601,8 +601,8 @@ export const destroySnapshot = (
   id: SnapshotId,
 ): Effect.Effect<void, SandboxError.SandboxError, Sandbox | SandboxSnapshots> =>
   Effect.gen(function* () {
-    const s = yield* Sandbox.asEffect()
-    yield* SandboxSnapshots.asEffect()
+    const s = yield* Sandbox
+    yield* SandboxSnapshots
     return yield* s.snapshots.destroy(id)
   })
 
@@ -612,8 +612,8 @@ export const listSnapshots: Effect.Effect<
   SandboxError.SandboxError,
   Sandbox | SandboxSnapshots
 > = Effect.gen(function* () {
-  const s = yield* Sandbox.asEffect()
-  yield* SandboxSnapshots.asEffect()
+  const s = yield* Sandbox
+  yield* SandboxSnapshots
   return yield* s.snapshots.list
 })
 
@@ -633,7 +633,7 @@ export const exposePort = (
   Sandbox | SandboxPortExposure
 > =>
   Effect.gen(function* () {
-    const s = yield* Sandbox.asEffect()
-    yield* SandboxPortExposure.asEffect()
+    const s = yield* Sandbox
+    yield* SandboxPortExposure
     return yield* s.ports.expose(instance, port)
   })

package/src/speech-synthesizer/SpeechSynthesizer.ts

@@ -169,13 +169,13 @@ export class MultiSpeakerTts extends Context.Service<MultiSpeakerTts, void>()(
 export const synthesize = (
   request: CommonSynthesizeRequest,
 ): Effect.Effect<AudioBlob, AiError.AiError, SpeechSynthesizer> =>
-  Effect.flatMap(SpeechSynthesizer.asEffect(), (s) => s.synthesize(request))
+  Effect.flatMap(SpeechSynthesizer, (s) => s.synthesize(request))
 
 /** Full text in, audio chunks out. */
 export const streamSynthesis = (
   request: CommonSynthesizeRequest,
 ): Stream.Stream<AudioChunk, AiError.AiError, SpeechSynthesizer> =>
-  Stream.unwrap(Effect.map(SpeechSynthesizer.asEffect(), (s) => s.streamSynthesis(request)))
+  Stream.unwrap(Effect.map(SpeechSynthesizer, (s) => s.streamSynthesis(request)))
 
 /**
  * Incremental synthesis. Dual-arity: pipeable (data-last) and direct
@@ -205,8 +205,8 @@ export const streamSynthesisFrom: {
   <E, R>(textIn: Stream.Stream<string, E, R>, request: CommonStreamSynthesizeRequest) =>
     Stream.unwrap(
       Effect.gen(function* () {
-        const s = yield* SpeechSynthesizer.asEffect()
-        yield* TtsIncrementalText.asEffect()
+        const s = yield* SpeechSynthesizer
+        yield* TtsIncrementalText
         return s.streamSynthesisFrom(textIn, request)
       }),
     ),
@@ -220,8 +220,8 @@ export const synthesizeDialogue = (
   request: CommonSynthesizeDialogueRequest,
 ): Effect.Effect<AudioBlob, AiError.AiError, SpeechSynthesizer | MultiSpeakerTts> =>
   Effect.gen(function* () {
-    const s = yield* SpeechSynthesizer.asEffect()
-    yield* MultiSpeakerTts.asEffect()
+    const s = yield* SpeechSynthesizer
+    yield* MultiSpeakerTts
     return yield* s.synthesizeDialogue(request)
   })
 
@@ -233,8 +233,8 @@ export const streamSynthesizeDialogue = (
 ): Stream.Stream<AudioChunk, AiError.AiError, SpeechSynthesizer | MultiSpeakerTts> =>
   Stream.unwrap(
     Effect.gen(function* () {
-      const s = yield* SpeechSynthesizer.asEffect()
-      yield* MultiSpeakerTts.asEffect()
+      const s = yield* SpeechSynthesizer
+      yield* MultiSpeakerTts
       return s.streamSynthesizeDialogue(request)
     }),
   )

package/src/streaming/JSONL.test.ts

@@ -8,6 +8,18 @@ const bytesOf = (...chunks: ReadonlyArray<string>) =>
 
 const collect = <A, E>(s: Stream.Stream<A, E>) => Effect.runPromise(Stream.runCollect(s))
 
+const runUntilEnd = <A, E>(s: Stream.Stream<A, E>) =>
+  Effect.runPromise(
+    s.pipe(
+      Stream.result,
+      Stream.runCollect,
+      Effect.map((results) => ({
+        seen: results.filter(Result.isSuccess).map((r) => r.success),
+        failures: results.filter(Result.isFailure).map((r) => r.failure),
+      })),
+    ),
+  )
+
 const collectResult = <A, E>(s: Stream.Stream<A, E>) =>
   Effect.runPromise(Effect.result(Stream.runCollect(s)))
 
@@ -33,6 +45,13 @@ describe("JSONL.fromBytes", () => {
     const out = await collect(JSONL.fromBytes(bytesOf("a\n\n\nb\n")))
     expect(out).toEqual(["a", "b"])
   })
+
+  it("discards a buffered partial line when the upstream fails mid-stream", async () => {
+    const failing = Stream.concat(bytesOf('{"n":1}\n{"n":2'), Stream.fail("boom" as const))
+    const { seen, failures } = await runUntilEnd(JSONL.fromBytes(failing))
+    expect(seen).toEqual(['{"n":1}'])
+    expect(failures).toEqual(["boom"])
+  })
 })
 
 describe("JSONL.parse", () => {

package/src/streaming/JSONL.ts

@@ -1,58 +1,26 @@
-import { Data, Effect, Schema, Stream } from "effect"
+import { Channel, Data, Effect, Schema, Stream } from "effect"
 
 export class JsonParseError extends Data.TaggedError("JsonParseError")<{
   readonly line: string
   readonly cause: unknown
 }> {}
 
-// ---------------------------------------------------------------------------
-// Generic stream helpers (kept module-local; see SSE.ts for the same shape).
-// ---------------------------------------------------------------------------
-
-const decodeText = <E, R>(self: Stream.Stream<Uint8Array, E, R>): Stream.Stream<string, E, R> =>
-  self.pipe(
-    Stream.mapAccum(
-      (): TextDecoder => new TextDecoder("utf-8"),
-      (decoder, chunk: Uint8Array) => [decoder, [decoder.decode(chunk, { stream: true })]] as const,
-      {
-        onHalt: (decoder: TextDecoder) => {
-          const tail = decoder.decode()
-          return tail.length > 0 ? [tail] : []
-        },
-      },
-    ),
-  )
-
-const splitOn =
-  (separator: string) =>
-  <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>
-    self.pipe(
-      Stream.mapAccum(
-        (): string => "",
-        (buffer, chunk: string) => {
-          const parts = (buffer + chunk).split(separator)
-          const tail = parts[parts.length - 1] ?? ""
-          return [tail, parts.slice(0, -1)] as const
-        },
-        { onHalt: (tail: string) => (tail.length > 0 ? [tail] : []) },
-      ),
-    )
-
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 
 /**
  * Decode a `Stream<Uint8Array>` into a `Stream<string>` of newline-delimited
- * lines. Empty lines are skipped. Buffers across chunk boundaries.
+ * lines. Empty lines are skipped. Buffers across chunk boundaries; a final
+ * line without a trailing newline is emitted at clean stream end, while a
+ * buffered partial line is discarded if the stream fails.
  */
 export const fromBytes = <E, R>(
   self: Stream.Stream<Uint8Array, E, R>,
 ): Stream.Stream<string, E, R> =>
   self.pipe(
-    decodeText,
-    Stream.map((s) => s.replace(/\r/g, "")),
-    splitOn("\n"),
+    Stream.decodeText,
+    Stream.pipeThroughChannel(Channel.splitLines()),
     Stream.filter((line) => line.length > 0),
   )
 

package/src/streaming/SSE.test.ts

@@ -1,4 +1,4 @@
-import { Effect, Stream } from "effect"
+import { Cause, Deferred, Effect, Exit, Fiber, Result, Stream } from "effect"
 import { describe, expect, it } from "vitest"
 import * as SSE from "./SSE.js"
 
@@ -8,6 +8,21 @@ const bytesOf = (...chunks: ReadonlyArray<string>) =>
 
 const collect = <A, E>(s: Stream.Stream<A, E>) => Effect.runPromise(Stream.runCollect(s))
 
+const runUntilEnd = <A, E>(s: Stream.Stream<A, E>) =>
+  Effect.runPromise(
+    s.pipe(
+      Stream.result,
+      Stream.runCollect,
+      Effect.map((results) => ({
+        seen: results.filter(Result.isSuccess).map((r) => r.success),
+        failures: results.filter(Result.isFailure).map((r) => r.failure),
+      })),
+    ),
+  )
+
+const failuresOf = (exit: Exit.Exit<unknown, unknown>): ReadonlyArray<unknown> =>
+  Exit.isFailure(exit) ? exit.cause.reasons.filter(Cause.isFailReason).map((r) => r.error) : []
+
 describe("SSE.fromBytes", () => {
   it("parses a single complete event", async () => {
     const out = await collect(SSE.fromBytes(bytesOf("event: foo\ndata: hello\n\n")))
@@ -39,9 +54,77 @@ describe("SSE.fromBytes", () => {
     expect(out).toEqual([{ id: "42", data: "x" }])
   })
 
-  it("flushes a trailing event without a closing blank line", async () => {
+  it("parses a data field with no space after the colon", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("data:x\n\n")))
+    expect(out).toEqual([{ data: "x" }])
+  })
+
+  it("ignores an id containing a NUL character", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("id: a\u0000b\ndata: x\n\n")))
+    expect(out).toEqual([{ data: "x" }])
+  })
+
+  it("discards a trailing event without a closing blank line", async () => {
     const out = await collect(SSE.fromBytes(bytesOf("data: tail")))
-    expect(out).toEqual([{ data: "tail" }])
+    expect(out).toEqual([])
+  })
+
+  it("discards buffered partial data when the upstream fails mid-stream", async () => {
+    const failing = Stream.concat(
+      bytesOf("data: good\n\ndata: partial-tr"),
+      Stream.fail("boom" as const),
+    )
+    const { seen, failures } = await runUntilEnd(SSE.fromBytes(failing))
+    expect(seen).toEqual([{ data: "good" }])
+    expect(failures).toEqual(["boom"])
+  })
+
+  it("discards a partial multi-byte char in the text decoder when the upstream fails", async () => {
+    const partialSquid = enc.encode("data: 🦑\n\n").slice(0, 8)
+    const failing = Stream.concat(
+      Stream.fromIterable([enc.encode("data: ok\n\n"), partialSquid]),
+      Stream.fail("boom" as const),
+    )
+    const { seen, failures } = await runUntilEnd(SSE.fromBytes(failing))
+    expect(seen).toEqual([{ data: "ok" }])
+    expect(failures).toEqual(["boom"])
+  })
+
+  it("discards buffered partial data when the stream is interrupted", async () => {
+    const { seen, exit } = await Effect.runPromise(
+      Effect.gen(function* () {
+        const seen: Array<SSE.Event> = []
+        const latch = yield* Deferred.make<void>()
+        const hanging = Stream.concat(bytesOf("data: good\n\ndata: partial"), Stream.never)
+        const fiber = yield* Stream.runForEach(SSE.fromBytes(hanging), (e) =>
+          Effect.sync(() => {
+            seen.push(e)
+          }).pipe(Effect.andThen(Deferred.succeed(latch, void 0))),
+        ).pipe(Effect.forkChild)
+        yield* Deferred.await(latch)
+        yield* Fiber.interrupt(fiber)
+        const exit = yield* Fiber.await(fiber)
+        return { seen, exit }
+      }),
+    )
+    expect(seen).toEqual([{ data: "good" }])
+    expect(Exit.isFailure(exit)).toBe(true)
+    expect(failuresOf(exit)).toEqual([])
+  })
+
+  it("ignores retry directives", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("retry: 3000\n\ndata: a\n\n")))
+    expect(out).toEqual([{ data: "a" }])
+  })
+
+  it("treats an explicit 'event: message' as the default event", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("event: message\ndata: x\n\n")))
+    expect(out).toEqual([{ data: "x" }])
+  })
+
+  it("does not dispatch events with no data", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("event: ping\n\ndata: x\n\n")))
+    expect(out).toEqual([{ data: "x" }])
   })
 
   it("ignores empty blocks between events", async () => {