gemi 0.84.1 → 0.85.0

package/dist/ai/client/index.js

@@ -37,7 +37,8 @@ function reduce(state, event, now) {
 			threadId: event.threadId ?? state.threadId,
 			runMessageIds: [],
 			loadedTools: [],
-			finishReason: void 0
+			finishReason: void 0,
+			usage: void 0
 		};
 		case "message-start": return withMessage(state, event.messageId, now, (message) => ({
 			...message,
@@ -143,24 +144,16 @@ function reduce(state, event, now) {
 			...message,
 			finishReason: event.finishReason,
 			...event.outputTruncated ? { outputTruncated: true } : {},
+			...event.usage ? { usage: event.usage } : {},
 			content: event.outputTruncated || event.finishReason === "length" ? message.content.filter((part) => !(part.type === "output" && part.partial)) : message.content.map((part) => part.type === "output" && part.partial ? {
 				...part,
 				partial: false
 			} : part)
 		}));
-		case "usage": {
-			const index = lastIndexWhere(state.messages, (message) => message.role === "assistant");
-			if (index === -1) return state;
-			const messages = state.messages.slice();
-			messages[index] = {
-				...messages[index],
-				usage: event.usage
-			};
-			return {
-				...state,
-				messages
-			};
-		}
+		case "usage": return {
+			...state,
+			usage: event.usage
+		};
 		case "error": return {
 			...state,
 			error: event.error,
@@ -337,7 +330,7 @@ function applyNested(run, event, now) {
 		...event.label !== void 0 ? { label: event.label } : {},
 		messages: next.messages,
 		...next.finishReason !== void 0 ? { finishReason: next.finishReason } : {},
-		...event.event.type === "usage" ? { usage: event.event.usage } : {}
+		...next.usage !== void 0 ? { usage: next.usage } : {}
 	};
 }
 /**
@@ -361,10 +354,6 @@ function isFinished(state, messageId) {
 	const message = state.messages.find((candidate) => candidate.id === messageId);
 	return message !== void 0 && message.finishReason !== void 0;
 }
-function lastIndexWhere(items, match) {
-	for (let i = items.length - 1; i >= 0; i--) if (match(items[i])) return i;
-	return -1;
-}
 function withMessage(state, messageId, now, update) {
 	const index = state.messages.findIndex((message) => message.id === messageId);
 	const runMessageIds = state.runMessageIds.includes(messageId) ? state.runMessageIds : [...state.runMessageIds, messageId];
@@ -564,6 +553,27 @@ async function* decodeSSE(stream) {
 }
 //#endregion
 //#region ai/useChat.tsx
+/**
+* Why `attach()` rejected, for that file alone.
+*
+* `code` is the server's when it sent one — `unsupported_file_type`,
+* `file_too_large`, `file_rejected` and `invalid_request` from
+* `AgentController.upload`, or a framework refusal's `kind` such as
+* `authentication` — and otherwise `upload_failed` (an answer that was
+* not JSON, `status` says which) or `network_error` (no answer at all). A
+* string rather than a union, because an app's own `attachmentDestination`
+* can throw an error with a code of its own and that has to arrive intact.
+*/
+var AttachError = class extends Error {
+	code;
+	status;
+	constructor(code, message, status) {
+		super(message);
+		this.name = "AttachError";
+		this.code = code;
+		if (status !== void 0) this.status = status;
+	}
+};
 var localIdCounter = 0;
 /** Ids the client mints: messages it authored, and the correlation id it names a
 *  run by before the server has. Server-assigned ids are what keep a reattached
@@ -596,6 +606,95 @@ async function httpError(response) {
 		retryable: response.status === 429 || response.status >= 500
 	};
 }
+function abortError() {
+	return new DOMException("The upload was aborted.", "AbortError");
+}
+/** No progress wanted: `fetch`, which aborts on the signal by itself. */
+async function fetchUpload(url, form, headers, signal) {
+	let response;
+	try {
+		response = await fetch(url, {
+			method: "POST",
+			headers,
+			body: form,
+			signal
+		});
+	} catch (error) {
+		if (isAbort(error) || signal?.aborted) throw abortError();
+		throw new AttachError("network_error", error instanceof Error && error.message ? error.message : "The upload could not be sent.");
+	}
+	try {
+		return {
+			status: response.status,
+			statusText: response.statusText,
+			body: await response.text()
+		};
+	} catch (error) {
+		if (isAbort(error) || signal?.aborted) throw abortError();
+		throw new AttachError("network_error", "The upload's answer could not be read.");
+	}
+}
+/**
+* Progress wanted: `XMLHttpRequest`, the one browser API that reports bytes
+* sent. Settled on `load`/`error`/`timeout`/`abort`, never on `readyState` 4,
+* which an abort reaches too with status 0 (#671 is that bug in `useUpload`).
+*/
+function xhrUpload(url, form, headers, signal, onProgress) {
+	return new Promise((resolve, reject) => {
+		const xhr = new XMLHttpRequest();
+		const onAbort = () => xhr.abort();
+		const done = () => signal?.removeEventListener("abort", onAbort);
+		xhr.addEventListener("load", () => {
+			done();
+			resolve({
+				status: xhr.status,
+				statusText: xhr.statusText,
+				body: xhr.responseText
+			});
+		});
+		xhr.addEventListener("abort", () => {
+			done();
+			reject(abortError());
+		});
+		const failed = () => {
+			done();
+			reject(new AttachError("network_error", "The upload could not be sent."));
+		};
+		xhr.addEventListener("error", failed);
+		xhr.addEventListener("timeout", failed);
+		xhr.upload.addEventListener("progress", (event) => {
+			try {
+				onProgress({
+					loaded: event.loaded,
+					total: event.lengthComputable ? event.total : 0
+				});
+			} catch {}
+		});
+		xhr.open("POST", url, true);
+		for (const [name, value] of Object.entries(headers)) xhr.setRequestHeader(name, value);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		xhr.send(form);
+	});
+}
+/** A non-2xx answer as the file's error: the server's code and sentence when
+*  it sent `{ error: { code, message } }`, the status line when it did not. */
+function attachErrorFrom(answer) {
+	let code = "upload_failed";
+	let message = answer.statusText || `The upload failed with status ${answer.status}.`;
+	try {
+		const data = JSON.parse(answer.body);
+		const error = data?.error;
+		if (typeof error === "string") {
+			if (error) message = error;
+		} else {
+			const named = error?.code ?? error?.kind;
+			if (typeof named === "string" && named) code = named;
+			const text = error?.message ?? data?.message;
+			if (typeof text === "string" && text) message = text;
+		}
+	} catch {}
+	return new AttachError(code, message, answer.status);
+}
 function turnFrom(message) {
 	let text = "";
 	const files = [];
@@ -827,7 +926,7 @@ function useChat(path, params = {}) {
 			else if (event.type === "error") handlers.current.onError?.(event.error);
 		}
 	}, [commit, setPhaseSafe]);
-	const send = useCallback(async (turn) => {
+	const send = useCallback(async (turn, options = {}) => {
 		const { base: url, extraBody: body } = requestRef.current;
 		const superseded = abortRef.current;
 		superseded?.controller.abort();
@@ -872,7 +971,8 @@ function useChat(path, params = {}) {
 				turn,
 				clientRunId,
 				threadId: stateRef.current.threadId,
-				messages: stateRef.current.threadId ? void 0 : forWire(history)
+				messages: stateRef.current.threadId ? void 0 : forWire(history),
+				...options.regenerate && stateRef.current.threadId ? { regenerate: true } : {}
 			};
 			const response = await post(url, payload, controller.signal);
 			if (!response.ok) {
@@ -1022,7 +1122,7 @@ function useChat(path, params = {}) {
 			pending: [],
 			error: null
 		});
-		await send(turn);
+		await send(turn, { regenerate: true });
 	}, [commit, send]);
 	const setMessages = useCallback((messages) => {
 		commit({
@@ -1030,22 +1130,24 @@ function useChat(path, params = {}) {
 			messages
 		});
 	}, [commit]);
-	const uploadFile = useCallback(async (file) => {
+	const uploadFile = useCallback(async (file, options = {}) => {
 		const { base: url, headers: extraHeaders, extraBody: body } = requestRef.current;
+		const { signal, onProgress } = options;
+		if (signal?.aborted) throw abortError();
 		const form = new FormData();
 		form.append("file", file);
 		if (body !== void 0) form.append("body", JSON.stringify(body));
-		const response = await fetch(`${url}/files`, {
-			method: "POST",
-			headers: { ...extraHeaders },
-			body: form
-		});
-		if (!response.ok) {
-			const error = await httpError(response);
-			fail(error);
-			throw new Error(error.message);
+		const threadId = stateRef.current.threadId;
+		if (threadId) form.append("threadId", threadId);
+		const answer = onProgress ? await xhrUpload(`${url}/files`, form, { ...extraHeaders }, signal, onProgress) : await fetchUpload(`${url}/files`, form, { ...extraHeaders }, signal);
+		if (answer.status < 200 || answer.status > 299) throw attachErrorFrom(answer);
+		let parsed;
+		try {
+			parsed = JSON.parse(answer.body);
+		} catch {
+			throw new AttachError("upload_failed", "The upload answered with something that is not JSON.", answer.status);
 		}
-		const data = await response.json();
+		const data = parsed;
 		return {
 			fileId: data.fileId,
 			attachmentId: data.attachmentId,
@@ -1053,7 +1155,7 @@ function useChat(path, params = {}) {
 			mimeType: data.mimeType ?? file.type,
 			downgraded: data.downgraded
 		};
-	}, [fail]);
+	}, []);
 	useEffect(() => {
 		if (attachOnMount === false || !initialThreadId) return;
 		const controller = new AbortController();
@@ -1097,12 +1199,13 @@ function useChat(path, params = {}) {
 		setMessages,
 		pending: state.pending,
 		loadedTools: state.loadedTools,
+		usage: state.usage,
 		approve,
 		answer,
 		attach: uploadFile
 	};
 }
 //#endregion
-export { useChat };
+export { AttachError, useChat };
 
 //# sourceMappingURL=index.js.map