@chipmobilesdk/rn-ai 0.2.0 → 0.3.0

package/src/transport/sseClient.ts

@@ -1,143 +1,143 @@
-/**
- * Minimal SSE reader over XMLHttpRequest (research R2).
- *
- * React Native's fetch does not reliably expose ReadableStream on Hermes, so
- * we use XHR incremental text delivery (readyState LOADING + onprogress) —
- * the same mechanism community SSE libraries use — with zero dependencies.
- * The gateway never compresses SSE responses (contract), which keeps
- * incremental delivery intact on both platforms.
- */
-
-export interface SseRequest {
-	url: string;
-	method?: 'GET' | 'POST';
-	headers?: Record<string, string>;
-	/** JSON string body for POST requests. */
-	body?: string;
-	/** Hard limit on the whole request. Rarely right for a stream; prefer the two below. */
-	timeoutMs?: number;
-	/** Fails with `onError(0, 'timeout')` if response headers have not arrived by then. */
-	connectTimeoutMs?: number;
-	/** Fails with `onError(0, 'timeout')` when no chunk arrives for this long. Reset per chunk. */
-	idleTimeoutMs?: number;
-}
-
-export interface SseHandlers {
-	/** One call per `data:` event payload (raw string, already de-framed). */
-	onData(payload: string): void;
-	/** Stream closed normally (transport level; `[DONE]` handling is the caller's). */
-	onEnd(): void;
-	/** Transport or HTTP error. `status` is 0 for network failures. */
-	onError(status: number, bodyText: string): void;
-}
-
-export interface SseHandle {
-	cancel(): void;
-}
-
-/** Parse complete `data:` events out of `text` starting at `fromIndex`. */
-export function drainSseEvents(
-	text: string,
-	fromIndex: number,
-	emit: (payload: string) => void,
-): number {
-	let cursor = fromIndex;
-	for (;;) {
-		const sep = text.indexOf('\n\n', cursor);
-		if (sep === -1) return cursor; // incomplete event stays buffered
-		const rawEvent = text.slice(cursor, sep);
-		cursor = sep + 2;
-		const dataLines = rawEvent
-			.split('\n')
-			.filter(line => line.startsWith('data:'))
-			.map(line => line.slice(5).trimStart());
-		if (dataLines.length > 0) emit(dataLines.join('\n'));
-	}
-}
-
-export function requestSse(request: SseRequest, handlers: SseHandlers): SseHandle {
-	const xhr = new XMLHttpRequest();
-	let seen = 0;
-	let finished = false;
-	let cancelled = false;
-
-	// One timer, re-armed as the request progresses: the connect limit until
-	// headers arrive, then the idle limit, restarted by every chunk.
-	let stallTimer: ReturnType<typeof setTimeout> | undefined;
-	const disarm = () => {
-		if (stallTimer !== undefined) {
-			clearTimeout(stallTimer);
-			stallTimer = undefined;
-		}
-	};
-
-	const finish = (fn: () => void) => {
-		disarm();
-		if (!finished && !cancelled) {
-			finished = true;
-			fn();
-		}
-	};
-
-	const stalled = () => {
-		stallTimer = undefined;
-		if (finished || cancelled) return;
-		finished = true;
-		try {
-			xhr.abort();
-		} catch {
-			// already settled
-		}
-		handlers.onError(0, 'timeout');
-	};
-
-	const arm = (ms: number | undefined) => {
-		disarm();
-		if (ms && !finished && !cancelled) stallTimer = setTimeout(stalled, ms);
-	};
-
-	const pump = () => {
-		if (xhr.status !== 200) return; // error path handled on load/error
-		arm(request.idleTimeoutMs);
-		const text: string = xhr.responseText ?? '';
-		seen = drainSseEvents(text, seen, handlers.onData);
-	};
-
-	xhr.open(request.method ?? 'POST', request.url, true);
-	for (const [k, v] of Object.entries(request.headers ?? {})) {
-		xhr.setRequestHeader(k, v);
-	}
-	xhr.setRequestHeader('Accept', 'text/event-stream');
-	if (request.timeoutMs) xhr.timeout = request.timeoutMs;
-
-	xhr.onprogress = pump;
-	xhr.onreadystatechange = () => {
-		if (xhr.readyState === 2) arm(request.idleTimeoutMs); // HEADERS_RECEIVED
-		if (xhr.readyState === 3) pump(); // LOADING: incremental text
-	};
-	xhr.onload = () => {
-		if (xhr.status === 200) {
-			pump();
-			finish(handlers.onEnd);
-		} else {
-			finish(() => handlers.onError(xhr.status, xhr.responseText ?? ''));
-		}
-	};
-	xhr.onerror = () => finish(() => handlers.onError(0, 'network error'));
-	xhr.ontimeout = () => finish(() => handlers.onError(0, 'timeout'));
-
-	xhr.send(request.body);
-	arm(request.connectTimeoutMs);
-
-	return {
-		cancel() {
-			cancelled = true;
-			disarm();
-			try {
-				xhr.abort();
-			} catch {
-				// aborting a settled XHR is a no-op
-			}
-		},
-	};
-}
+/**
+ * Minimal SSE reader over XMLHttpRequest (research R2).
+ *
+ * React Native's fetch does not reliably expose ReadableStream on Hermes, so
+ * we use XHR incremental text delivery (readyState LOADING + onprogress) —
+ * the same mechanism community SSE libraries use — with zero dependencies.
+ * The gateway never compresses SSE responses (contract), which keeps
+ * incremental delivery intact on both platforms.
+ */
+
+export interface SseRequest {
+	url: string;
+	method?: 'GET' | 'POST';
+	headers?: Record<string, string>;
+	/** JSON string body for POST requests. */
+	body?: string;
+	/** Hard limit on the whole request. Rarely right for a stream; prefer the two below. */
+	timeoutMs?: number;
+	/** Fails with `onError(0, 'timeout')` if response headers have not arrived by then. */
+	connectTimeoutMs?: number;
+	/** Fails with `onError(0, 'timeout')` when no chunk arrives for this long. Reset per chunk. */
+	idleTimeoutMs?: number;
+}
+
+export interface SseHandlers {
+	/** One call per `data:` event payload (raw string, already de-framed). */
+	onData(payload: string): void;
+	/** Stream closed normally (transport level; `[DONE]` handling is the caller's). */
+	onEnd(): void;
+	/** Transport or HTTP error. `status` is 0 for network failures. */
+	onError(status: number, bodyText: string): void;
+}
+
+export interface SseHandle {
+	cancel(): void;
+}
+
+/** Parse complete `data:` events out of `text` starting at `fromIndex`. */
+export function drainSseEvents(
+	text: string,
+	fromIndex: number,
+	emit: (payload: string) => void,
+): number {
+	let cursor = fromIndex;
+	for (;;) {
+		const sep = text.indexOf('\n\n', cursor);
+		if (sep === -1) return cursor; // incomplete event stays buffered
+		const rawEvent = text.slice(cursor, sep);
+		cursor = sep + 2;
+		const dataLines = rawEvent
+			.split('\n')
+			.filter(line => line.startsWith('data:'))
+			.map(line => line.slice(5).trimStart());
+		if (dataLines.length > 0) emit(dataLines.join('\n'));
+	}
+}
+
+export function requestSse(request: SseRequest, handlers: SseHandlers): SseHandle {
+	const xhr = new XMLHttpRequest();
+	let seen = 0;
+	let finished = false;
+	let cancelled = false;
+
+	// One timer, re-armed as the request progresses: the connect limit until
+	// headers arrive, then the idle limit, restarted by every chunk.
+	let stallTimer: ReturnType<typeof setTimeout> | undefined;
+	const disarm = () => {
+		if (stallTimer !== undefined) {
+			clearTimeout(stallTimer);
+			stallTimer = undefined;
+		}
+	};
+
+	const finish = (fn: () => void) => {
+		disarm();
+		if (!finished && !cancelled) {
+			finished = true;
+			fn();
+		}
+	};
+
+	const stalled = () => {
+		stallTimer = undefined;
+		if (finished || cancelled) return;
+		finished = true;
+		try {
+			xhr.abort();
+		} catch {
+			// already settled
+		}
+		handlers.onError(0, 'timeout');
+	};
+
+	const arm = (ms: number | undefined) => {
+		disarm();
+		if (ms && !finished && !cancelled) stallTimer = setTimeout(stalled, ms);
+	};
+
+	const pump = () => {
+		if (xhr.status !== 200) return; // error path handled on load/error
+		arm(request.idleTimeoutMs);
+		const text: string = xhr.responseText ?? '';
+		seen = drainSseEvents(text, seen, handlers.onData);
+	};
+
+	xhr.open(request.method ?? 'POST', request.url, true);
+	for (const [k, v] of Object.entries(request.headers ?? {})) {
+		xhr.setRequestHeader(k, v);
+	}
+	xhr.setRequestHeader('Accept', 'text/event-stream');
+	if (request.timeoutMs) xhr.timeout = request.timeoutMs;
+
+	xhr.onprogress = pump;
+	xhr.onreadystatechange = () => {
+		if (xhr.readyState === 2) arm(request.idleTimeoutMs); // HEADERS_RECEIVED
+		if (xhr.readyState === 3) pump(); // LOADING: incremental text
+	};
+	xhr.onload = () => {
+		if (xhr.status === 200) {
+			pump();
+			finish(handlers.onEnd);
+		} else {
+			finish(() => handlers.onError(xhr.status, xhr.responseText ?? ''));
+		}
+	};
+	xhr.onerror = () => finish(() => handlers.onError(0, 'network error'));
+	xhr.ontimeout = () => finish(() => handlers.onError(0, 'timeout'));
+
+	xhr.send(request.body);
+	arm(request.connectTimeoutMs);
+
+	return {
+		cancel() {
+			cancelled = true;
+			disarm();
+			try {
+				xhr.abort();
+			} catch {
+				// aborting a settled XHR is a no-op
+			}
+		},
+	};
+}

package/src/transport/timeouts.ts

@@ -1,53 +1,53 @@
-/**
- * Time limits for every network call the client makes (AI-04).
- *
- * Without them a stalled mobile connection left `useAiChat` in `loading` or
- * `streaming`, and `useAiQuota` in `loading`, until the user gave up.
- */
-
-export interface AiTimeouts {
-	/** Request sent → response headers received, for the chat stream. */
-	connectMs: number;
-	/** Longest silence allowed between two chunks of the chat stream. */
-	idleMs: number;
-	/** Behavior-config fetch, including reading the body. */
-	configMs: number;
-	/** Quota fetch, including reading the body. */
-	quotaMs: number;
-}
-
-/**
- * The gateway sends headers only once the model has answered, so `connectMs`
- * also covers time to first token on a large image prompt.
- */
-export const DEFAULT_AI_TIMEOUTS: AiTimeouts = {
-	connectMs: 30_000,
-	idleMs: 30_000,
-	configMs: 10_000,
-	quotaMs: 10_000,
-};
-
-/**
- * Runs `run` with an abort signal and rejects with `onTimeout()` after `ms`.
- * The race matters as much as the signal: an injected `fetchFn` (or an old
- * polyfill) may ignore the signal entirely.
- */
-export async function withTimeout<T>(
-	ms: number,
-	run: (signal: AbortSignal | undefined) => Promise<T>,
-	onTimeout: () => Error,
-): Promise<T> {
-	const controller = typeof AbortController === 'undefined' ? undefined : new AbortController();
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	const expired = new Promise<never>((_, reject) => {
-		timer = setTimeout(() => {
-			controller?.abort();
-			reject(onTimeout());
-		}, ms);
-	});
-	try {
-		return await Promise.race([run(controller?.signal), expired]);
-	} finally {
-		clearTimeout(timer);
-	}
-}
+/**
+ * Time limits for every network call the client makes (AI-04).
+ *
+ * Without them a stalled mobile connection left `useAiChat` in `loading` or
+ * `streaming`, and `useAiQuota` in `loading`, until the user gave up.
+ */
+
+export interface AiTimeouts {
+	/** Request sent → response headers received, for the chat stream. */
+	connectMs: number;
+	/** Longest silence allowed between two chunks of the chat stream. */
+	idleMs: number;
+	/** Behavior-config fetch, including reading the body. */
+	configMs: number;
+	/** Quota fetch, including reading the body. */
+	quotaMs: number;
+}
+
+/**
+ * The gateway sends headers only once the model has answered, so `connectMs`
+ * also covers time to first token on a large image prompt.
+ */
+export const DEFAULT_AI_TIMEOUTS: AiTimeouts = {
+	connectMs: 30_000,
+	idleMs: 30_000,
+	configMs: 10_000,
+	quotaMs: 10_000,
+};
+
+/**
+ * Runs `run` with an abort signal and rejects with `onTimeout()` after `ms`.
+ * The race matters as much as the signal: an injected `fetchFn` (or an old
+ * polyfill) may ignore the signal entirely.
+ */
+export async function withTimeout<T>(
+	ms: number,
+	run: (signal: AbortSignal | undefined) => Promise<T>,
+	onTimeout: () => Error,
+): Promise<T> {
+	const controller = typeof AbortController === 'undefined' ? undefined : new AbortController();
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const expired = new Promise<never>((_, reject) => {
+		timer = setTimeout(() => {
+			controller?.abort();
+			reject(onTimeout());
+		}, ms);
+	});
+	try {
+		return await Promise.race([run(controller?.signal), expired]);
+	} finally {
+		clearTimeout(timer);
+	}
+}