@effect-uai/core 0.10.0 → 0.12.0

package/src/observability/Metrics.ts

@@ -12,7 +12,7 @@ import {
   Stream,
 } from "effect"
 import type { Usage } from "../domain/Items.js"
-import type { Turn, TurnEvent } from "../domain/Turn.js"
+import { type Turn, TurnEvent } from "../domain/Turn.js"
 
 // ---------------------------------------------------------------------------
 // Self-describing measurements (the exporter-facing payload)
@@ -126,6 +126,7 @@ const MetricName = {
   totalTokens: "effect_uai_total_tokens",
   reasoningTokens: "effect_uai_reasoning_tokens",
   cachedInputTokens: "effect_uai_cached_input_tokens",
+  cacheWriteTokens: "effect_uai_cache_write_tokens",
 } as const
 
 /** Read a structural `_tag` off any value without narrowing to a closed union. */
@@ -141,6 +142,34 @@ const contentDeltaKind = (ev: unknown): Option.Option<"text" | "reasoning"> => {
       : Option.none()
 }
 
+const isTextDelta = TurnEvent.$is("TextDelta")
+const isReasoningDelta = TurnEvent.$is("ReasoningDelta")
+const isRefusalDelta = TurnEvent.$is("RefusalDelta")
+const isToolCallArgsDelta = TurnEvent.$is("ToolCallArgsDelta")
+
+/** A delta carrying generated output, whatever the model was producing. */
+export type OutputDelta = Extract<
+  TurnEvent,
+  { readonly _tag: "TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallArgsDelta" }
+>
+
+/**
+ * Narrow to a delta that contributes to the model's output stream. Tool-call
+ * arguments count: an agent turn can be almost entirely `ToolCallArgsDelta`,
+ * and measuring only prose reports a near-zero rate for it.
+ *
+ * The single place the output-delta tag list lives — the throughput
+ * accumulator and `unitCount` both read it. Distinct from `contentDeltaKind`,
+ * which answers a narrower question for first-token latency.
+ */
+const outputDelta = (ev: unknown): Option.Option<OutputDelta> =>
+  isTextDelta(ev) || isReasoningDelta(ev) || isRefusalDelta(ev) || isToolCallArgsDelta(ev)
+    ? Option.some(ev)
+    : Option.none()
+
+const outputTextOf = (delta: OutputDelta): string =>
+  isToolCallArgsDelta(delta) ? delta.delta : delta.text
+
 const isTurnCompleteEvent = (ev: unknown): boolean => tagOf(ev) === "TurnComplete"
 
 const turnOf = (ev: unknown): Turn =>
@@ -154,6 +183,10 @@ const addUsage = (a: Usage, b: Usage): Usage => {
     a.input_tokens_details?.cached_tokens,
     b.input_tokens_details?.cached_tokens,
   )
+  const cacheWrite = sumOptional(
+    a.input_tokens_details?.cache_write_tokens,
+    b.input_tokens_details?.cache_write_tokens,
+  )
   const reasoning = sumOptional(
     a.output_tokens_details?.reasoning_tokens,
     b.output_tokens_details?.reasoning_tokens,
@@ -162,7 +195,13 @@ const addUsage = (a: Usage, b: Usage): Usage => {
     input_tokens: sumOptional(a.input_tokens, b.input_tokens),
     output_tokens: sumOptional(a.output_tokens, b.output_tokens),
     total_tokens: sumOptional(a.total_tokens, b.total_tokens),
-    input_tokens_details: cached === undefined ? undefined : { cached_tokens: cached },
+    input_tokens_details:
+      cached === undefined && cacheWrite === undefined
+        ? undefined
+        : {
+            ...(cached !== undefined && { cached_tokens: cached }),
+            ...(cacheWrite !== undefined && { cache_write_tokens: cacheWrite }),
+          },
     output_tokens_details: reasoning === undefined ? undefined : { reasoning_tokens: reasoning },
   }
 }
@@ -175,6 +214,7 @@ const usageMeasurements = (usage: Usage): ReadonlyArray<Measurement> => {
     [MetricName.totalTokens, usage.total_tokens],
     [MetricName.reasoningTokens, usage.output_tokens_details?.reasoning_tokens],
     [MetricName.cachedInputTokens, usage.input_tokens_details?.cached_tokens],
+    [MetricName.cacheWriteTokens, usage.input_tokens_details?.cache_write_tokens],
   ]
   return Arr.filterMap(pairs, ([name, value]) =>
     value === undefined
@@ -349,8 +389,11 @@ export type ThroughputOptions = {
   readonly every?: Duration.Input
   /** What a "unit" is. Default `"char"` (exact and chunking-independent). */
   readonly unit?: "char" | "token" | "event"
-  /** Token counter for `unit: "token"`. Absent => approximate 1 per content delta. */
-  readonly tokenizer?: (event: TurnEvent) => Effect.Effect<number>
+  /**
+   * Token counter for `unit: "token"`. Called only for deltas that carry
+   * generated output. Absent => approximate 1 per such delta.
+   */
+  readonly tokenizer?: (event: OutputDelta) => Effect.Effect<number>
   /** Rate definition. Default `"windowed"` (current speed, no cold-start bias). */
   readonly mode?: "windowed" | "cumulative"
   /** EWMA smoothing. Omitted => off; `"default"` => a sensible factor. */
@@ -434,14 +477,13 @@ const unitCount = (
   unit: "char" | "token" | "event",
   tokenizer: ThroughputOptions["tokenizer"],
 ): Effect.Effect<number> => {
-  if (tagOf(ev) !== "TextDelta") return Effect.succeed(0)
-  const text = (ev as { readonly text: string }).text
+  const output = outputDelta(ev)
+  if (Option.isNone(output)) return Effect.succeed(0)
+  const delta = output.value
   return Match.value(unit).pipe(
-    Match.when("char", () => Effect.succeed([...text].length)),
+    Match.when("char", () => Effect.succeed([...outputTextOf(delta)].length)),
     Match.when("event", () => Effect.succeed(1)),
-    Match.when("token", () =>
-      tokenizer === undefined ? Effect.succeed(1) : tokenizer(ev as TurnEvent),
-    ),
+    Match.when("token", () => (tokenizer === undefined ? Effect.succeed(1) : tokenizer(delta))),
     Match.exhaustive,
   )
 }
@@ -465,7 +507,7 @@ export const throughput =
           Stream.tap((ev) =>
             isTurnCompleteEvent(ev)
               ? Ref.update(ref, resetTurn)
-              : tagOf(ev) === "TextDelta"
+              : Option.isSome(outputDelta(ev))
                 ? Effect.flatMap(Clock.currentTimeMillis, (now) =>
                     Effect.flatMap(unitCount(ev, unit, tokenizer), (n) =>
                       Ref.update(ref, (state) => addUnits(state, n, now)),

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/retry/Retry.ts

@@ -29,14 +29,55 @@ import type * as AiError from "../domain/AiError.js"
  * variants if needed (e.g. a custom schedule that observes `cause`).
  */
 export class Retryable extends Data.TaggedError("RetryableAi")<{
-  readonly cause: AiError.RateLimited | AiError.Unavailable | AiError.Timeout
+  readonly cause:
+    | AiError.RateLimited
+    | AiError.Unavailable
+    | AiError.Timeout
+    | AiError.InvalidRequest
 }> {}
 
+/**
+ * `InvalidRequest` payloads that are a transient fault on the provider's side
+ * rather than a defect in the request.
+ *
+ * The class exists because a provider can only answer within its own error
+ * vocabulary: a constrained-decoding grammar that times out while compiling is
+ * a cold-start timeout, but it arrives as `invalid_request_error` because that
+ * is where the vendor files schema problems. Replaying it succeeds — the same
+ * schema compiles on the next call.
+ *
+ * An allow-list rather than a general softening of `InvalidRequest`, and it
+ * must stay one. The whole point of that tag being fatal is that a genuinely
+ * malformed request retried on a schedule burns quota to arrive at the same
+ * rejection, slowly. An entry earns its place by having been observed to
+ * succeed on replay.
+ */
+const TRANSIENT_INVALID_REQUEST: ReadonlyArray<RegExp> = [/grammar compilation timed out/i]
+
+/** The payload as text, for matching. `raw` is whatever the provider handed
+ *  back — usually its response body as a string, sometimes a parsed object,
+ *  and occasionally something that will not serialise. */
+const rawText = (raw: unknown): string => {
+  if (typeof raw === "string") return raw
+  try {
+    return JSON.stringify(raw) ?? ""
+  } catch {
+    return String(raw)
+  }
+}
+
+const isTransientInvalidRequest = (e: AiError.AiError): boolean =>
+  e._tag === "InvalidRequest" &&
+  TRANSIENT_INVALID_REQUEST.some((pattern) => pattern.test(rawText(e.raw)))
+
 /** Type-narrowing predicate for the retryable subset. */
 export const isRetryable = (
   e: AiError.AiError,
-): e is AiError.RateLimited | AiError.Unavailable | AiError.Timeout =>
-  e._tag === "RateLimited" || e._tag === "Unavailable" || e._tag === "Timeout"
+): e is AiError.RateLimited | AiError.Unavailable | AiError.Timeout | AiError.InvalidRequest =>
+  e._tag === "RateLimited" ||
+  e._tag === "Unavailable" ||
+  e._tag === "Timeout" ||
+  isTransientInvalidRequest(e)
 
 // Lift events to Items, non-retryable failures to Terminal values
 // (escape retry), retryable failures to wrapped errors (only thing

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),
   )