@aexhq/sdk 0.62.1 → 0.63.0

package/dist/transport.js

@@ -1,744 +0,0 @@
-import { MAX_CREATE_SESSION_REQUEST_BYTES, MAX_CUSTOMER_OBSERVATION_BYTES, MAX_MESSAGE_REQUEST_BYTES, MAX_PUBLIC_EVENT_BYTES, } from "@aexhq/brain";
-import { AbortError, AexError, SessionError, abortError, errorFromApi } from "./errors.js";
-const MAX_ORDINARY_JSON_BYTES = 2 * 1024 * 1024;
-const MAX_ERROR_RESPONSE_BYTES = 64 * 1024;
-const CUSTOMER_ENVIRONMENT_OBSERVATION_TIMEOUT_MS = 15_000;
-export class Transport {
-    baseUrl;
-    #apiKey;
-    #fetch;
-    constructor(apiKey, baseUrl, fetchImplementation) {
-        this.#apiKey = apiKey;
-        let end = baseUrl.length;
-        while (end > 0 && baseUrl.charCodeAt(end - 1) === 47)
-            end -= 1;
-        this.baseUrl = baseUrl.slice(0, end);
-        this.#fetch = fetchImplementation;
-    }
-    async customerEnvironmentGrant(clientId, signal) {
-        const grant = await this.json("POST", "/v1/customer-environment/grants", { body: { client_id: clientId }, signal });
-        const observationUrl = validateCustomerEnvironmentGrant(this.baseUrl, grant);
-        return {
-            url: grant.url,
-            protocol: grant.protocol,
-            expiresAt: grant.expires_at,
-            observationUrl,
-            observationToken: grant.observation_token,
-        };
-    }
-    async customerEnvironmentObserve(url, token, observation) {
-        const body = encodeJsonOnce(observation, MAX_CUSTOMER_OBSERVATION_BYTES, "Customer Environment observation");
-        const response = await this.#fetch(url, {
-            method: "POST",
-            redirect: "error",
-            headers: {
-                Accept: "application/json",
-                Authorization: `Bearer ${token}`,
-                "Content-Type": "application/json",
-            },
-            body,
-            signal: AbortSignal.timeout(CUSTOMER_ENVIRONMENT_OBSERVATION_TIMEOUT_MS),
-        });
-        if (response.ok)
-            return;
-        const preview = await readResponseText(response, 4096)
-            .catch(() => "<response too large or unreadable>");
-        throw new SessionError(`Customer Environment observation ingress returned HTTP ${response.status}: ${preview}`, { status: response.status, requestId: response.headers.get("x-request-id") ?? undefined });
-    }
-    async downloadTransfer(ticket, signal, expectedBytes) {
-        const stream = await this.downloadTransferStream(ticket, signal, expectedBytes);
-        const reader = stream.getReader();
-        const chunks = [];
-        let bytes = 0;
-        try {
-            while (true) {
-                const item = await reader.read();
-                if (item.done)
-                    break;
-                bytes += item.value.byteLength;
-                chunks.push(item.value);
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-        const content = new Uint8Array(bytes);
-        let offset = 0;
-        for (const chunk of chunks) {
-            content.set(chunk, offset);
-            offset += chunk.byteLength;
-        }
-        return content;
-    }
-    async downloadTransferStream(ticket, signal, expectedBytes) {
-        assertTransferTicket(ticket, "GET");
-        if (expectedBytes !== undefined &&
-            (!Number.isSafeInteger(expectedBytes) || expectedBytes < 0 || expectedBytes > ticket.max_bytes)) {
-            throw new SessionError("Aex file download has an invalid expected length");
-        }
-        const response = await this.#fetch(ticket.url, {
-            method: "GET",
-            redirect: "error",
-            headers: ticket.headers,
-            ...(signal === undefined ? {} : { signal }),
-        });
-        if (!response.ok) {
-            throw new SessionError(`Aex file download returned HTTP ${response.status}`, {
-                status: response.status,
-            });
-        }
-        const declaredHeader = response.headers.get("content-length");
-        const declared = declaredHeader === null ? undefined : Number(declaredHeader);
-        if (declared !== undefined && Number.isFinite(declared) && declared > ticket.max_bytes) {
-            throw new SessionError("Aex file download exceeded its transfer ticket");
-        }
-        if (expectedBytes !== undefined &&
-            declared !== undefined &&
-            Number.isFinite(declared) &&
-            declared !== expectedBytes) {
-            throw new SessionError("Aex file download length does not match its object metadata");
-        }
-        return boundedStream(response.body ?? emptyStream(), ticket.max_bytes, signal, "download", expectedBytes);
-    }
-    async uploadTransfer(ticket, content, bytes, signal) {
-        assertTransferTicket(ticket, "PUT");
-        if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > ticket.max_bytes) {
-            throw new TypeError("Aex file upload exceeds its transfer ticket");
-        }
-        const streaming = typeof content === "function";
-        const body = streaming
-            ? exactStream(content(), bytes, ticket.max_bytes, signal)
-            : arrayBufferBody(content);
-        if (!streaming && content.byteLength !== bytes) {
-            throw new TypeError("Aex file upload length does not match its transfer request");
-        }
-        const init = {
-            method: "PUT",
-            redirect: "error",
-            headers: ticket.headers,
-            body,
-            ...(signal === undefined ? {} : { signal }),
-            ...(streaming ? { duplex: "half" } : {}),
-        };
-        const response = await this.#fetch(ticket.url, init);
-        if (!response.ok) {
-            throw new SessionError(`Aex file upload returned HTTP ${response.status}`, {
-                status: response.status,
-            });
-        }
-    }
-    async json(method, path, options = {}) {
-        const attempts = options.retry === true ? 2 : 1;
-        // Serialize once before the first await. A caller mutating its source object after a lost
-        // response must never send different bytes under the same idempotency identity on retry.
-        const requestBody = options.body === undefined
-            ? undefined
-            : encodeJsonOnce(options.body, requestLimit(method, path), "Aex API request");
-        let lastError;
-        for (let attempt = 0; attempt < attempts; attempt += 1) {
-            try {
-                const response = await this.#fetch(`${this.baseUrl}${path}`, {
-                    method,
-                    redirect: "error",
-                    headers: {
-                        Accept: "application/json",
-                        ...(requestBody === undefined ? {} : { "Content-Type": "application/json" }),
-                        Authorization: `Bearer ${this.#apiKey}`,
-                        ...options.headers,
-                    },
-                    ...(requestBody === undefined ? {} : { body: requestBody }),
-                    ...(options.signal === undefined ? {} : { signal: options.signal }),
-                });
-                if (!response.ok)
-                    throw await this.responseError(response);
-                if (response.status === 204)
-                    return undefined;
-                const text = await readResponseText(response, MAX_ORDINARY_JSON_BYTES);
-                if (text === "")
-                    return undefined;
-                try {
-                    return JSON.parse(text);
-                }
-                catch (cause) {
-                    throw new SessionError("Aex returned invalid JSON", { cause });
-                }
-            }
-            catch (error) {
-                if (options.signal?.aborted === true || isAbort(error))
-                    throw abortError(error);
-                if (error instanceof AexError) {
-                    const retryableServerFailure = options.retry === true && error.status !== undefined && error.status >= 500;
-                    if (!retryableServerFailure || attempt + 1 >= attempts)
-                        throw error;
-                }
-                lastError = error;
-            }
-        }
-        throw new SessionError("Could not reach the Aex API", { cause: lastError });
-    }
-    /** Accept one durable deletion job; strict callers poll its short status resource client-side. */
-    async deleteSession(sessionId, waitForCompletion, signal) {
-        const path = `/v1/sessions/${encodeURIComponent(sessionId)}`;
-        let accepted;
-        let lastError;
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            try {
-                const response = await this.#fetch(`${this.baseUrl}${path}`, {
-                    method: "DELETE",
-                    redirect: "error",
-                    headers: {
-                        Accept: "application/json",
-                        Authorization: `Bearer ${this.#apiKey}`,
-                    },
-                    ...(signal === undefined ? {} : { signal }),
-                });
-                if (!response.ok)
-                    throw await this.responseError(response);
-                if (response.status !== 202 && response.status !== 204) {
-                    throw new SessionError(`Aex returned invalid deletion status HTTP ${response.status}`);
-                }
-                accepted = response;
-                break;
-            }
-            catch (error) {
-                if (signal?.aborted === true || isAbort(error))
-                    throw abortError(error);
-                if (error instanceof AexError) {
-                    const retryableServerFailure = error.status !== undefined && error.status >= 500;
-                    if (!retryableServerFailure || attempt + 1 >= 2)
-                        throw error;
-                }
-                lastError = error;
-            }
-        }
-        if (accepted === undefined) {
-            throw new SessionError("Could not reach the Aex API", { cause: lastError });
-        }
-        if (accepted.status === 204 || !waitForCompletion)
-            return;
-        const canonicalStatusPath = `${path}/deletion`;
-        const location = accepted.headers.get("location") ?? canonicalStatusPath;
-        const statusUrl = deletionStatusUrl(this.baseUrl, canonicalStatusPath, location);
-        let retryMs = retryAfterMs(accepted.headers.get("retry-after"));
-        while (true) {
-            await delay(jitter(retryMs), signal);
-            let response;
-            try {
-                response = await this.#fetch(statusUrl, {
-                    method: "GET",
-                    redirect: "error",
-                    headers: {
-                        Accept: "application/json",
-                        Authorization: `Bearer ${this.#apiKey}`,
-                    },
-                    ...(signal === undefined ? {} : { signal }),
-                });
-            }
-            catch (error) {
-                if (signal?.aborted === true || isAbort(error))
-                    throw abortError(error);
-                retryMs = Math.min(30_000, Math.max(250, retryMs * 2));
-                continue;
-            }
-            if (!response.ok) {
-                const error = await this.responseError(response);
-                if (error.status === undefined || error.status < 500)
-                    throw error;
-                retryMs = Math.min(30_000, Math.max(retryAfterMs(response.headers.get("retry-after")), retryMs * 2));
-                continue;
-            }
-            let status;
-            try {
-                const body = await readResponseText(response, MAX_ERROR_RESPONSE_BYTES);
-                status = JSON.parse(body);
-            }
-            catch (cause) {
-                throw new SessionError("Aex returned invalid deletion status JSON", { cause });
-            }
-            const state = typeof status === "object" && status !== null && "state" in status
-                ? status.state
-                : undefined;
-            if (state === "succeeded")
-                return;
-            if (state !== "accepted" &&
-                state !== "deleting" &&
-                state !== "retrying" &&
-                state !== "blocked") {
-                throw new SessionError("Aex returned an invalid deletion state");
-            }
-            retryMs = retryAfterMs(response.headers.get("retry-after"));
-        }
-    }
-    async *events(sessionId, options = {}) {
-        let cursor = options.after ?? 0;
-        const follow = options.follow ?? true;
-        let consecutiveFailures = 0;
-        while (true) {
-            try {
-                const query = new URLSearchParams({ after: String(cursor), follow: String(follow) });
-                const response = await this.#fetch(`${this.baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}/events?${query}`, {
-                    method: "GET",
-                    redirect: "error",
-                    headers: {
-                        Accept: "text/event-stream",
-                        Authorization: `Bearer ${this.#apiKey}`,
-                        ...(cursor > 0 ? { "Last-Event-ID": String(cursor) } : {}),
-                    },
-                    ...(options.signal === undefined ? {} : { signal: options.signal }),
-                });
-                if (!response.ok)
-                    throw await this.responseError(response);
-                if (response.body === null)
-                    throw new SessionError("The Aex event stream had no body");
-                let received = false;
-                for await (const frame of parseEventFrames(response.body)) {
-                    // Only Brain's SSE `id` is reconnect authority. Provisional provider/Tool frames can
-                    // carry an internal JSON sequence while deliberately omitting `id`; advancing from the
-                    // payload would skip durable recovery records after a crash.
-                    if (frame.durableId !== undefined) {
-                        if (frame.durableId <= cursor)
-                            continue;
-                        cursor = frame.durableId;
-                    }
-                    received = true;
-                    consecutiveFailures = 0;
-                    yield frame.event;
-                }
-                if (!follow)
-                    return;
-                if (!received)
-                    consecutiveFailures += 1;
-            }
-            catch (error) {
-                if (options.signal?.aborted === true || isAbort(error))
-                    throw abortError(error);
-                if (error instanceof AexError && error.status !== undefined && error.status < 500)
-                    throw error;
-                consecutiveFailures += 1;
-                if (consecutiveFailures > 5) {
-                    if (error instanceof AexError)
-                        throw error;
-                    throw new SessionError("The Aex event stream disconnected", { cause: error });
-                }
-            }
-            await delay(Math.min(2_000, 100 * 2 ** (consecutiveFailures - 1)), options.signal);
-        }
-    }
-    async responseError(response) {
-        let envelope;
-        try {
-            const text = await readResponseText(response, MAX_ERROR_RESPONSE_BYTES);
-            envelope = text === "" ? undefined : JSON.parse(text);
-        }
-        catch {
-            // Fall through to a status-based error.
-        }
-        if (envelope?.error !== undefined)
-            return errorFromApi(envelope.error, response.status);
-        return new SessionError(`Aex API request failed with HTTP ${response.status}`, {
-            status: response.status,
-            requestId: response.headers.get("x-request-id") ?? undefined,
-        });
-    }
-}
-function requestLimit(method, path) {
-    if (method === "POST" && path === "/v1/sessions")
-        return MAX_CREATE_SESSION_REQUEST_BYTES;
-    if (method === "POST" &&
-        (/^\/v1\/sessions\/[^/]+\/messages(?:\?|$)/u.test(path) ||
-            /^\/v1\/sessions\/[^/]+\/children(?:\?|$)/u.test(path) ||
-            /^\/v1\/sessions\/[^/]+\/children\/[^/]+\/(?:messages|follow-up)(?:\?|$)/u.test(path))) {
-        return MAX_MESSAGE_REQUEST_BYTES;
-    }
-    return MAX_ORDINARY_JSON_BYTES;
-}
-function encodeJsonOnce(value, maxBytes, label) {
-    let encoded;
-    try {
-        encoded = JSON.stringify(value);
-    }
-    catch (cause) {
-        throw new TypeError(`${label} is not JSON-serializable`, { cause });
-    }
-    if (encoded === undefined)
-        throw new TypeError(`${label} must be a JSON value`);
-    if (new TextEncoder().encode(encoded).byteLength > maxBytes) {
-        throw new TypeError(`${label} exceeds ${maxBytes} bytes`);
-    }
-    return encoded;
-}
-async function readResponseText(response, maxBytes) {
-    if (response.body === null)
-        return "";
-    const declared = Number(response.headers.get("content-length"));
-    if (Number.isFinite(declared) && declared > maxBytes) {
-        await response.body.cancel().catch(() => undefined);
-        throw new SessionError(`Aex response exceeds ${maxBytes} bytes`);
-    }
-    const reader = response.body.getReader();
-    const chunks = [];
-    let bytes = 0;
-    try {
-        while (true) {
-            const item = await reader.read();
-            if (item.done)
-                break;
-            bytes += item.value.byteLength;
-            if (bytes > maxBytes)
-                throw new SessionError(`Aex response exceeds ${maxBytes} bytes`);
-            chunks.push(item.value);
-        }
-    }
-    finally {
-        await reader.cancel().catch(() => undefined);
-        reader.releaseLock();
-    }
-    const content = new Uint8Array(bytes);
-    let offset = 0;
-    for (const chunk of chunks) {
-        content.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return new TextDecoder().decode(content);
-}
-function assertTransferTicket(ticket, method) {
-    if (ticket.method !== method) {
-        throw new SessionError(`Aex returned a ${ticket.method} transfer for ${method}`);
-    }
-    if (!Number.isSafeInteger(ticket.max_bytes) || ticket.max_bytes < 0) {
-        throw new SessionError("Aex returned an invalid file-transfer limit");
-    }
-    let url;
-    try {
-        url = new URL(ticket.url);
-    }
-    catch (cause) {
-        throw new SessionError("Aex returned an invalid file-transfer URL", { cause });
-    }
-    if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback(url.hostname))) {
-        throw new SessionError("Aex file transfers require HTTPS (or loopback HTTP for development)");
-    }
-}
-function validateCustomerEnvironmentGrant(baseUrl, grant) {
-    if (!/^[A-Za-z0-9_.-]{1,128}$/u.test(grant.grant_id)) {
-        throw new SessionError("Aex returned an invalid customer Environment grant id");
-    }
-    if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]{1,2048}$/u.test(grant.protocol)) {
-        throw new SessionError("Aex returned an invalid customer Environment WebSocket protocol");
-    }
-    if (!/^[\x21-\x7e]{1,2048}$/u.test(grant.observation_token)) {
-        throw new SessionError("Aex returned an invalid customer Environment observation token");
-    }
-    let socket;
-    let observation;
-    let expectedObservation;
-    try {
-        socket = new URL(grant.url);
-        observation = new URL(grant.observation_url);
-        expectedObservation = new URL(`${baseUrl}/v1/customer-environment/observations/${encodeURIComponent(grant.grant_id)}`);
-    }
-    catch (cause) {
-        throw new SessionError("Aex returned an invalid customer Environment URL", { cause });
-    }
-    const secureSocket = socket.protocol === "wss:" ||
-        (socket.protocol === "ws:" && isLoopback(socket.hostname));
-    if (!secureSocket || socket.username !== "" || socket.password !== "" ||
-        socket.search !== "" || socket.hash !== "") {
-        throw new SessionError("Aex customer Environment sockets require credential-free WSS (or loopback WS for development)");
-    }
-    if (observation.href !== expectedObservation.href) {
-        throw new SessionError("Aex returned an unsafe customer Environment observation URL");
-    }
-    if (observation.href.includes(grant.observation_token)) {
-        throw new SessionError("Aex returned an observation URL containing its bearer token");
-    }
-    return expectedObservation.href;
-}
-function arrayBufferBody(content) {
-    if (content.buffer instanceof ArrayBuffer) {
-        return content;
-    }
-    // SharedArrayBuffer-backed views are not a Fetch BodyInit. This uncommon compatibility copy is
-    // the only buffered-copy path; ordinary Uint8Array/ArrayBuffer uploads stay zero-copy.
-    return Uint8Array.from(content);
-}
-function emptyStream() {
-    return new ReadableStream({
-        start(controller) {
-            controller.close();
-        },
-    });
-}
-function boundedStream(source, maxBytes, signal, direction, expectedBytes) {
-    const reader = source.getReader();
-    let bytes = 0;
-    let finished = false;
-    let controller;
-    const cleanup = () => signal?.removeEventListener("abort", onAbort);
-    const onAbort = () => {
-        if (finished)
-            return;
-        finished = true;
-        void reader.cancel(signal?.reason).catch(() => undefined);
-        controller?.error(abortError(signal?.reason));
-        cleanup();
-    };
-    return new ReadableStream({
-        start(value) {
-            controller = value;
-            if (signal?.aborted === true)
-                onAbort();
-            else
-                signal?.addEventListener("abort", onAbort, { once: true });
-        },
-        async pull(value) {
-            if (finished)
-                return;
-            try {
-                const item = await reader.read();
-                if (item.done) {
-                    if (expectedBytes !== undefined && bytes !== expectedBytes) {
-                        throw new TypeError(`Aex file ${direction} produced ${bytes} bytes; expected ${expectedBytes}`);
-                    }
-                    finished = true;
-                    cleanup();
-                    value.close();
-                    return;
-                }
-                if (!(item.value instanceof Uint8Array)) {
-                    throw new TypeError(`Aex file ${direction} stream must yield Uint8Array chunks`);
-                }
-                bytes += item.value.byteLength;
-                if (bytes > maxBytes || (expectedBytes !== undefined && bytes > expectedBytes)) {
-                    throw new TypeError(`Aex file ${direction} exceeded its declared byte limit`);
-                }
-                value.enqueue(item.value);
-            }
-            catch (error) {
-                finished = true;
-                cleanup();
-                await reader.cancel(error).catch(() => undefined);
-                value.error(error);
-            }
-        },
-        async cancel(reason) {
-            if (finished)
-                return;
-            finished = true;
-            cleanup();
-            await reader.cancel(reason);
-        },
-    });
-}
-function exactStream(source, expectedBytes, maxBytes, signal) {
-    return boundedStream(source, maxBytes, signal, "upload", expectedBytes);
-}
-function isLoopback(hostname) {
-    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
-}
-function deletionStatusUrl(baseUrl, canonicalPath, location) {
-    let url;
-    try {
-        url = new URL(location, `${baseUrl}/`);
-    }
-    catch (cause) {
-        throw new SessionError("Aex returned an invalid deletion status location", { cause });
-    }
-    const base = new URL(`${baseUrl}/`);
-    if (url.origin !== base.origin || url.pathname !== canonicalPath || url.search !== "") {
-        throw new SessionError("Aex returned an unsafe deletion status location");
-    }
-    return url.toString();
-}
-function retryAfterMs(value) {
-    if (value !== null && /^\d+$/u.test(value)) {
-        return Math.min(30_000, Math.max(25, Number(value) * 1_000));
-    }
-    if (value !== null) {
-        const at = Date.parse(value);
-        if (Number.isFinite(at))
-            return Math.min(30_000, Math.max(25, at - Date.now()));
-    }
-    return 1_000;
-}
-function jitter(milliseconds) {
-    return Math.floor(milliseconds / 2 + Math.random() * (milliseconds / 2));
-}
-const MAX_SSE_FRAMING_BYTES = 4 * 1024;
-const MAX_SSE_WIRE_FRAME_BYTES = MAX_PUBLIC_EVENT_BYTES + MAX_SSE_FRAMING_BYTES;
-const MAX_SSE_LINE_BYTES = MAX_SSE_WIRE_FRAME_BYTES;
-/** @internal Incremental, constant-space decoder for Brain's bounded public SSE events. */
-export async function* parseEventStream(stream) {
-    for await (const frame of parseEventFrames(stream))
-        yield frame.event;
-}
-async function* parseEventFrames(stream) {
-    const reader = stream.getReader();
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    const line = new Uint8Array(MAX_SSE_LINE_BYTES);
-    const data = new Uint8Array(MAX_PUBLIC_EVENT_BYTES);
-    let lineLength = 0;
-    let dataLength = 0;
-    let dataLines = 0;
-    let frameFramingBytes = 0;
-    let frameStarted = false;
-    let eventId;
-    const reset = () => {
-        dataLength = 0;
-        dataLines = 0;
-        frameFramingBytes = 0;
-        frameStarted = false;
-        eventId = undefined;
-    };
-    const dispatch = () => {
-        if (dataLines === 0) {
-            reset();
-            return undefined;
-        }
-        let encoded;
-        try {
-            encoded = decoder.decode(data.subarray(0, dataLength));
-        }
-        catch (cause) {
-            throw new SessionError("Aex sent an event that was not valid UTF-8", { cause });
-        }
-        const id = eventId;
-        reset();
-        try {
-            const event = JSON.parse(encoded);
-            if (id === undefined) {
-                if (!isEphemeralEvent(event)) {
-                    throw new SessionError(`Aex sent durable event ${event.type} without an SSE id`);
-                }
-                return { event };
-            }
-            if (!/^[1-9][0-9]*$/u.test(id)) {
-                throw new SessionError("Aex sent an invalid durable SSE id");
-            }
-            const durableId = Number(id);
-            const payloadSeq = "seq" in event ? event.seq : undefined;
-            if (!Number.isSafeInteger(durableId) || payloadSeq !== durableId) {
-                throw new SessionError("Aex durable SSE id does not match its event sequence");
-            }
-            return { event, durableId };
-        }
-        catch (cause) {
-            if (cause instanceof SessionError)
-                throw cause;
-            throw new SessionError("Aex sent an invalid event", { cause });
-        }
-    };
-    const processLine = () => {
-        const wireLineBytes = lineLength + 1;
-        let end = lineLength;
-        if (end > 0 && line[end - 1] === 13)
-            end -= 1;
-        lineLength = 0;
-        const addFraming = (payloadBytes = 0) => {
-            frameFramingBytes += wireLineBytes - payloadBytes;
-            if (frameFramingBytes > MAX_SSE_FRAMING_BYTES) {
-                throw new SessionError(`Aex event frame exceeds ${MAX_SSE_FRAMING_BYTES} framing bytes`);
-            }
-        };
-        if (end === 0) {
-            addFraming();
-            return dispatch();
-        }
-        frameStarted = true;
-        if (line[0] === 58) {
-            addFraming();
-            return undefined; // SSE comment.
-        }
-        let separator = -1;
-        for (let index = 0; index < end; index += 1) {
-            if (line[index] === 58) {
-                separator = index;
-                break;
-            }
-        }
-        let start = separator + 1;
-        if (start < end && line[start] === 32)
-            start += 1;
-        const isData = separator === 4 && line[0] === 100 && line[1] === 97 &&
-            line[2] === 116 && line[3] === 97;
-        const isId = separator === 2 && line[0] === 105 && line[1] === 100;
-        if (!isData)
-            addFraming();
-        if (isId) {
-            try {
-                eventId = decoder.decode(line.subarray(start, end));
-            }
-            catch (cause) {
-                throw new SessionError("Aex sent an SSE id that was not valid UTF-8", { cause });
-            }
-            return undefined;
-        }
-        if (!isData)
-            return undefined;
-        const contentBytes = end - start;
-        addFraming(contentBytes);
-        const joinedBytes = dataLength + (dataLines > 0 ? 1 : 0) + contentBytes;
-        if (joinedBytes > MAX_PUBLIC_EVENT_BYTES) {
-            throw new SessionError(`Aex event payload exceeds ${MAX_PUBLIC_EVENT_BYTES} bytes`);
-        }
-        if (dataLines > 0)
-            data[dataLength++] = 10;
-        data.set(line.subarray(start, end), dataLength);
-        dataLength += contentBytes;
-        dataLines += 1;
-        return undefined;
-    };
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            if (!(value instanceof Uint8Array)) {
-                throw new SessionError("Aex event stream yielded a non-byte chunk");
-            }
-            for (const byte of value) {
-                if (byte === 10) {
-                    const event = processLine();
-                    if (event !== undefined)
-                        yield event;
-                    continue;
-                }
-                if (lineLength >= line.byteLength) {
-                    throw new SessionError(`Aex event line exceeds ${MAX_SSE_LINE_BYTES} bytes`);
-                }
-                line[lineLength++] = byte;
-            }
-        }
-        if (lineLength > 0 || frameStarted || dataLines > 0) {
-            throw new SessionError("Aex event stream ended in a truncated SSE frame");
-        }
-    }
-    finally {
-        await reader.cancel().catch(() => undefined);
-        reader.releaseLock();
-    }
-}
-function isEphemeralEvent(event) {
-    return event.type === "assistant.delta" || event.type === "tool.output" ||
-        event.type === "replay.complete";
-}
-function isAbort(error) {
-    return error instanceof AbortError || (error instanceof DOMException && error.name === "AbortError");
-}
-function delay(milliseconds, signal) {
-    if (signal?.aborted === true)
-        return Promise.reject(abortError(signal.reason));
-    return new Promise((resolve, reject) => {
-        const cleanup = () => signal?.removeEventListener("abort", onAbort);
-        const timer = setTimeout(() => {
-            cleanup();
-            resolve();
-        }, milliseconds);
-        const onAbort = () => {
-            clearTimeout(timer);
-            cleanup();
-            reject(abortError(signal?.reason));
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}