@alexkroman1/aai-ui 6.10.0 → 6.11.0

package/dist/index.js

@@ -16,9 +16,8 @@ import clsx from "clsx";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { createContext, createElement, useCallback, useContext, useEffect, useId, useRef, useState } from "react";
 import { errorMessage, isTerminal, isTerminal as isTerminal$1 } from "@alexkroman1/aai";
-import { isRecord, omitUndefined, safeJsonParse as safeJsonParse$1 } from "@alexkroman1/aai/utils";
-import { createWorkflowApiClient } from "@alexkroman1/aai/workflow-api";
-import { createParser } from "eventsource-parser";
+import { isRecord, omitUndefined } from "@alexkroman1/aai/utils";
+import { createWorkflowApiClient, readEventStream } from "@alexkroman1/aai/workflow-api";
 import { createEpoch } from "@alexkroman1/aai/internal";
 //#region components/_form-readiness.ts
 /**
@@ -1210,83 +1209,6 @@ function repeatUntil(intervalMs, step) {
 	};
 }
 //#endregion
-//#region _sse.ts
-/**
-* The server-sent-event parser both workflow streams read through.
-*
-* Split out when the second stream arrived: `workflow-events.ts` watches a run's
-* STATE and `use-workflow-progress.ts` reads what the run WROTE, and they parse
-* the identical wire format. A second copy of a stream parser is the kind of
-* duplication that goes wrong quietly — the two would drift on exactly the edges
-* documented below, and the symptom is a page that silently stops updating.
-*
-* @internal
-*/
-/**
-* Parse an SSE byte stream into frames, with `eventsource-parser`.
-*
-* The parser is `aai-studio-client`'s already (`src/api-events.ts`), and it is
-* catalogued — plus a transitive dependency of `@ai-sdk/provider-utils`, so it
-* is in this package's tree either way. Adopting it retired a hand-rolled line
-* splitter justified on the subset in use being "small and fixed" — true of our
-* own server, and not of what sits between it and the page:
-*
-* - It split on `"\n\n"` only. The spec permits `\n`, `\r\n` and `\r`, and a
-*   CRLF stream is `\r\n\r\n` — no two adjacent `\n`, so **not one frame ever
-*   parsed** and `pump` fell through to `"fallback"` on the clean end. Silently
-*   dropping to the poll is the exact cost the run-watch stream exists to avoid,
-*   and an intermediary re-terminating lines is not our choice to make.
-* - `line.startsWith("event: ")` required the space the spec makes optional.
-* - It kept only the LAST `data:` line rather than joining a multi-line one.
-*
-* Those three are what `workflow-events.test.ts` pins, and they are the three
-* that DISCRIMINATE — checked by running the specs against the old parser.
-* Comment frames and a leading BOM were already fine and are not credited here:
-* a heartbeat has no `event:` line, so the old parser dropped it anyway, and
-* `TextDecoder` strips the BOM before either parser sees a byte.
-*
-* Three properties of the parser this leans on. `feed` invokes `onEvent`
-* SYNCHRONOUSLY for every complete event in the chunk, so a batch is collected
-* per read and yielded in arrival order — the generator shape, and therefore
-* every caller, is unchanged. An event with no `data:` line at all is not
-* dispatched (also per spec); every frame these routes emit carries one, since
-* `workflow-api-events.ts` and `workflow-api-stream.ts` write `event:` and
-* `data:` together. And a chunk ending in a lone `\r` holds that byte back,
-* because it may yet turn out to be the first half of a `\r\n` — so a CR-ONLY
-* stream chunked per frame dispatches one frame behind, and its last frame not
-* at all (it would need `reset({ consume: true })`, which would also consume a
-* genuinely truncated frame as if it were whole). Nothing emits CR-only endings,
-* and the outcome if anything did is the safe one for both readers: a stream
-* that ends with no final frame is read as a dropped connection, which the run
-* watch answers by falling back to the poll and the progress reader by
-* re-opening.
-*/
-async function* sseFrames(body, signal) {
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
-	let batch = [];
-	const parser = createParser({ onEvent: ({ event, data }) => {
-		if (event === void 0) return;
-		batch.push({
-			event,
-			data: safeJsonParse$1(data)
-		});
-	} });
-	try {
-		while (!signal.aborted) {
-			const { done, value } = await reader.read();
-			if (done) return;
-			parser.feed(decoder.decode(value, { stream: true }));
-			if (batch.length === 0) continue;
-			const frames = batch;
-			batch = [];
-			for (const frame of frames) yield frame;
-		}
-	} finally {
-		reader.cancel().catch(() => void 0);
-	}
-}
-//#endregion
 //#region workflow-events.ts
 /**
 * Watching a run over server-sent events — the PUSH half of `useWorkflowRun`.
@@ -1336,7 +1258,7 @@ function watchRunEvents(getClient, runId, onRun, onSettled, onFallback) {
 	const pump = async () => {
 		const res = await getClient().watch(runId, controller.signal);
 		if (!(res.ok && res.body)) return "fallback";
-		for await (const frame of sseFrames(res.body, controller.signal)) {
+		for await (const frame of readEventStream(res.body, controller.signal)) {
 			if (frame.event === "run" && frame.data) onRun(frame.data);
 			const outcome = endingFor(frame.event);
 			if (outcome) return outcome;
@@ -1845,7 +1767,7 @@ const DEFAULT_PROGRESS_POLL_MS = 1e3;
 async function consumeFrames(body, signal) {
 	const chunks = [];
 	let ending = "partial";
-	for await (const frame of sseFrames(body, signal)) if (frame.event === "chunk") chunks.push(frame.data);
+	for await (const frame of readEventStream(body, signal)) if (frame.event === "chunk") chunks.push(frame.data);
 	else if (frame.event === "done") ending = frame.data?.complete ? "complete" : "partial";
 	else if (frame.event === "missing") return {
 		ending: "complete",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-ui",
-  "version": "6.10.0",
+  "version": "6.11.0",
   "type": "module",
   "files": [
     "dist",
@@ -23,13 +23,12 @@
   },
   "dependencies": {
     "clsx": "^2.1.1",
-    "eventsource-parser": "^4.0.0",
     "partysocket": "^1.3.0",
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
     "use-stick-to-bottom": "^1.1.6",
     "use-sync-external-store": "^1.6.0",
-    "@alexkroman1/aai": "6.10.0"
+    "@alexkroman1/aai": "6.11.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/dist/_sse.d.ts

@@ -1,56 +0,0 @@
-/**
- * The server-sent-event parser both workflow streams read through.
- *
- * Split out when the second stream arrived: `workflow-events.ts` watches a run's
- * STATE and `use-workflow-progress.ts` reads what the run WROTE, and they parse
- * the identical wire format. A second copy of a stream parser is the kind of
- * duplication that goes wrong quietly — the two would drift on exactly the edges
- * documented below, and the symptom is a page that silently stops updating.
- *
- * @internal
- */
-/** One parsed SSE frame. Comment frames (heartbeats) are skipped, not yielded. */
-export type SseFrame = {
-    event: string;
-    data: unknown;
-};
-/**
- * Parse an SSE byte stream into frames, with `eventsource-parser`.
- *
- * The parser is `aai-studio-client`'s already (`src/api-events.ts`), and it is
- * catalogued — plus a transitive dependency of `@ai-sdk/provider-utils`, so it
- * is in this package's tree either way. Adopting it retired a hand-rolled line
- * splitter justified on the subset in use being "small and fixed" — true of our
- * own server, and not of what sits between it and the page:
- *
- * - It split on `"\n\n"` only. The spec permits `\n`, `\r\n` and `\r`, and a
- *   CRLF stream is `\r\n\r\n` — no two adjacent `\n`, so **not one frame ever
- *   parsed** and `pump` fell through to `"fallback"` on the clean end. Silently
- *   dropping to the poll is the exact cost the run-watch stream exists to avoid,
- *   and an intermediary re-terminating lines is not our choice to make.
- * - `line.startsWith("event: ")` required the space the spec makes optional.
- * - It kept only the LAST `data:` line rather than joining a multi-line one.
- *
- * Those three are what `workflow-events.test.ts` pins, and they are the three
- * that DISCRIMINATE — checked by running the specs against the old parser.
- * Comment frames and a leading BOM were already fine and are not credited here:
- * a heartbeat has no `event:` line, so the old parser dropped it anyway, and
- * `TextDecoder` strips the BOM before either parser sees a byte.
- *
- * Three properties of the parser this leans on. `feed` invokes `onEvent`
- * SYNCHRONOUSLY for every complete event in the chunk, so a batch is collected
- * per read and yielded in arrival order — the generator shape, and therefore
- * every caller, is unchanged. An event with no `data:` line at all is not
- * dispatched (also per spec); every frame these routes emit carries one, since
- * `workflow-api-events.ts` and `workflow-api-stream.ts` write `event:` and
- * `data:` together. And a chunk ending in a lone `\r` holds that byte back,
- * because it may yet turn out to be the first half of a `\r\n` — so a CR-ONLY
- * stream chunked per frame dispatches one frame behind, and its last frame not
- * at all (it would need `reset({ consume: true })`, which would also consume a
- * genuinely truncated frame as if it were whole). Nothing emits CR-only endings,
- * and the outcome if anything did is the safe one for both readers: a stream
- * that ends with no final frame is read as a dropped connection, which the run
- * watch answers by falling back to the poll and the progress reader by
- * re-opening.
- */
-export declare function sseFrames(body: ReadableStream<Uint8Array>, signal: AbortSignal): AsyncGenerator<SseFrame>;