@gradio/client 2.5.1 → 2.7.0

package/dist/index.js

@@ -62,9 +62,11 @@ function map_names_to_ids(fns) {
 	});
 	return apis;
 }
-function resolve_config_root(root, current_location) {
-	const root_url = new URL(root, current_location);
+function resolve_config_root(root, current_location, prioritize_current_location = false) {
 	const current_url = new URL(current_location);
+	const root_url = new URL(root, current_url);
+	const is_colab_runtime = root_url.hostname.endsWith(".colab-user-runtimes.internal") || root_url.hostname.endsWith(".codatalab-user-runtimes.internal");
+	if (prioritize_current_location || is_colab_runtime) return new URL(new URL(root, current_url).pathname, current_url).toString().replace(/\/$/, "");
 	if (root_url.hostname !== current_url.hostname) return root;
 	root_url.protocol = current_url.protocol;
 	root_url.host = current_url.host;
@@ -75,7 +77,9 @@ async function resolve_config(endpoint, strip_current_page = true) {
 	if (typeof window !== "undefined" && window.gradio_config && location.origin !== "http://localhost:9876") {
 		if (strip_current_page && window.gradio_config.current_page) endpoint = endpoint.substring(0, endpoint.lastIndexOf("/"));
 		if (window.gradio_config.dev_mode || typeof window !== "undefined" && window?.BUILD_MODE === "dev") {
-			let config_url = join_urls(endpoint, this.deep_link ? CONFIG_URL + "?deep_link=" + this.deep_link : CONFIG_URL);
+			let config_url = new URL(join_urls(endpoint, CONFIG_URL));
+			if (this.deep_link) config_url.searchParams.set("deep_link", this.deep_link);
+			if (this.page !== null) config_url.searchParams.set("page", this.page);
 			const config = await handleConfigResponse(await this.fetch(config_url, {
 				headers,
 				credentials: this.options.credentials ?? "same-origin"
@@ -87,10 +91,12 @@ async function resolve_config(endpoint, strip_current_page = true) {
 			};
 		}
 		const config = { ...window.gradio_config };
-		config.root = resolve_config_root(config.root, location.href);
+		config.root = resolve_config_root(config.root, location.href, config.is_colab);
 		return config;
 	} else if (endpoint) {
-		let config_url = join_urls(endpoint, this.deep_link ? CONFIG_URL + "?deep_link=" + this.deep_link : CONFIG_URL);
+		let config_url = new URL(join_urls(endpoint, CONFIG_URL));
+		if (this.deep_link) config_url.searchParams.set("deep_link", this.deep_link);
+		if (this.page !== null) config_url.searchParams.set("page", this.page);
 		const config = await handleConfigResponse(await this.fetch(config_url, {
 			headers,
 			credentials: this.options.credentials ?? "same-origin"
@@ -489,7 +495,8 @@ async function view_api() {
 		let api_info;
 		if (typeof window !== "undefined" && window.gradio_api_info) api_info = window.gradio_api_info;
 		else {
-			const url = join_urls(config.root, this.api_prefix, API_INFO_URL);
+			const url = new URL(join_urls(config.root, this.api_prefix, API_INFO_URL));
+			if (this.page !== null) url.searchParams.set("page", this.page);
 			response = await this.fetch(url, {
 				headers,
 				credentials: this.options.credentials ?? "same-origin"
@@ -609,10 +616,11 @@ async function upload(file_data, root_url, upload_id, max_file_size) {
 		if (response.error) throw new Error(response.error);
 		else {
 			if (response.files) return response.files.map((f, i) => {
+				const encoded_path = f.split("/").map((segment) => encodeURIComponent(segment)).join("/");
 				return new FileData({
 					...file_data[i],
 					path: f,
-					url: `${root_url}${this.api_prefix}/file=${f}`
+					url: `${root_url}${this.api_prefix}/file=${encoded_path}`
 				});
 			});
 			return [];
@@ -774,6 +782,48 @@ function handle_payload(resolved_payload, dependency, components, type, with_nul
 	}
 	return updated_payload;
 }
+var FILE_ROUTE_PREFIXES = [
+	"/file=",
+	"/file/",
+	"/stream/",
+	"/proxy="
+];
+/**
+* Add the Space JWT required for browser-managed media requests.
+*
+* This is a bearer credential and must not be logged or persisted. Restrict it
+* to Gradio routes that serve files; the user's Hugging Face token remains in
+* the Authorization header used to obtain this credential.
+*/
+function sign_file_urls(data, root, api_prefix, jwt) {
+	if (!jwt || data === null || typeof data !== "object") return;
+	const signature = jwt;
+	const root_url = new URL(root);
+	const root_path = root_url.pathname.replace(/\/+$/, "");
+	const normalized_api_prefix = api_prefix ? `/${api_prefix.replace(/^\/+|\/+$/g, "")}` : "";
+	const route_bases = new Set([`${root_path}${normalized_api_prefix}`, normalized_api_prefix]);
+	if (!normalized_api_prefix) {
+		route_bases.add(`${root_path}/gradio_api`);
+		route_bases.add("/gradio_api");
+	}
+	function visit(value) {
+		if (value === null || typeof value !== "object") return;
+		const object = value;
+		if (object.meta?._type === "gradio.FileData" && typeof object.url === "string") {
+			const file_url = new URL(object.url, `${root_url.toString().replace(/\/$/, "")}/`);
+			const is_file_route = [...route_bases].some((base) => FILE_ROUTE_PREFIXES.some((route) => file_url.pathname.startsWith(`${base}${route}`)));
+			if ((file_url.protocol === "http:" || file_url.protocol === "https:") && file_url.origin === root_url.origin && is_file_route) {
+				file_url.searchParams.set("__sign", signature);
+				object.url = file_url.toString();
+			}
+		}
+		for (const child of Object.values(object)) visit(child);
+	}
+	visit(data);
+}
+function sign_config_file_urls(config, jwt) {
+	for (const component of config.components || []) sign_file_urls(component.props?.value, config.root, config.api_prefix || "", jwt);
+}
 //#endregion
 //#region src/utils/handle_blob.ts
 async function handle_blob(endpoint, data, api_info) {
@@ -1432,6 +1482,7 @@ function readable_stream(input, init = {}) {
 var KEY_ROOT = "gradio:run-history:";
 var STORAGE_PREFIX = `${KEY_ROOT}v2:`;
 var REPLAY_PREFIX = `${KEY_ROOT}replay:v2:`;
+var DESTINATION_PREFIX = `${KEY_ROOT}destination:v1:`;
 var MAX_RUNS = 100;
 var MAX_APPS = 8;
 /**
@@ -1469,6 +1520,34 @@ function replay_key(scope) {
 	const key = storage_key(scope);
 	return key ? key.replace(STORAGE_PREFIX, REPLAY_PREFIX) : null;
 }
+function destination_key(scope) {
+	const key = storage_key(scope);
+	return key ? key.replace(STORAGE_PREFIX, DESTINATION_PREFIX) : null;
+}
+function read_run_history_storage_impl(scope) {
+	const key = destination_key(scope);
+	if (!key) return { type: "browser" };
+	try {
+		const value = JSON.parse(window.localStorage.getItem(key) || "null");
+		if (typeof value?.bucket_id === "string") return value.type === "bucket" ? {
+			type: "bucket",
+			bucket_id: value.bucket_id
+		} : {
+			type: "browser",
+			bucket_id: value.bucket_id
+		};
+		return { type: "browser" };
+	} catch {
+		return { type: "browser" };
+	}
+}
+function set_run_history_storage_impl(scope, storage) {
+	const key = destination_key(scope);
+	if (!key) return;
+	if (storage.type === "browser" && !storage.bucket_id) window.localStorage.removeItem(key);
+	else window.localStorage.setItem(key, JSON.stringify(storage));
+	notify_run_history_change();
+}
 /** When a run was most recently saved under a key, for deciding what to drop. */
 function last_saved_at(key) {
 	try {
@@ -1485,7 +1564,7 @@ function last_saved_at(key) {
 */
 function prune_apps(current_key) {
 	const keys = Object.keys(window.localStorage).filter((key) => key.startsWith(KEY_ROOT));
-	const stale = [...keys.filter((key) => !key.startsWith(STORAGE_PREFIX) && !key.startsWith(REPLAY_PREFIX)), ...keys.filter((key) => key.startsWith(STORAGE_PREFIX) && key !== current_key).sort((a, b) => last_saved_at(b) - last_saved_at(a)).slice(MAX_APPS - 1)];
+	const stale = [...keys.filter((key) => !key.startsWith(STORAGE_PREFIX) && !key.startsWith(REPLAY_PREFIX) && !key.startsWith(DESTINATION_PREFIX)), ...keys.filter((key) => key.startsWith(STORAGE_PREFIX) && key !== current_key).sort((a, b) => last_saved_at(b) - last_saved_at(a)).slice(MAX_APPS - 1)];
 	for (const key of stale) try {
 		window.localStorage.removeItem(key);
 		window.sessionStorage.removeItem(key.replace(STORAGE_PREFIX, REPLAY_PREFIX));
@@ -1615,6 +1694,7 @@ function apply_run_history_replay_impl(config) {
 	return run ? restore_run_impl(config, run) : false;
 }
 function start_run_history_impl(options) {
+	if (read_run_history_storage_impl(options).type === "bucket") return null;
 	const key = storage_key(options);
 	if (!key) return null;
 	prune_apps(key);
@@ -1694,6 +1774,12 @@ function mark_complete(run, event) {
 function read_run_history(scope) {
 	return safely(() => read_run_history_impl(scope), []);
 }
+function read_run_history_storage(scope) {
+	return safely(() => read_run_history_storage_impl(scope), { type: "browser" });
+}
+function set_run_history_storage(scope, storage) {
+	safely(() => set_run_history_storage_impl(scope, storage), void 0);
+}
 function clear_run_history(scope) {
 	safely(() => clear_run_history_impl(scope), void 0);
 }
@@ -1734,10 +1820,11 @@ function submit(endpoint, data = {}, event_data, trigger_id, all_events, additio
 	try {
 		const { token } = this.options;
 		const { fetch, app_reference, config, session_hash, api_info, api_map, stream_status, pending_stream_messages, pending_diff_streams, event_callbacks, unclosed_events, post_data, options, api_prefix } = this;
-		const addt_headers = additional_headers || { "x-gradio-user": "api" };
+		const base_headers = additional_headers || { "x-gradio-user": "api" };
 		const that = this;
 		if (!api_info) throw new Error(NO_API_INFO_MSG);
 		if (!config) throw new Error("Could not resolve app config");
+		const root = config.root;
 		let { fn_index, endpoint_info, dependency } = get_endpoint_info(api_info, endpoint, api_map, config);
 		let resolved_data = map_data_to_params(data, endpoint_info);
 		let protocol = config.protocol ?? "ws";
@@ -1759,6 +1846,11 @@ function submit(endpoint, data = {}, event_data, trigger_id, all_events, additio
 			app_id: config.app_id,
 			username: config.username
 		};
+		const history_storage = read_run_history_storage(history_scope);
+		const addt_headers = {
+			...base_headers,
+			...history_enabled && history_storage.type === "bucket" ? { "x-gradio-history-bucket": history_storage.bucket_id } : {}
+		};
 		const history_run_id = !history_enabled || !is_documented_endpoint ? null : start_run_history({
 			...history_scope,
 			endpoint: history_endpoint,
@@ -1782,6 +1874,7 @@ function submit(endpoint, data = {}, event_data, trigger_id, all_events, additio
 		}, {}) || {};
 		function fire_event(event) {
 			update_run_history(history_scope, history_run_id, event);
+			if (event.type === "data" || event.type === "render") sign_file_urls(event.data, root, api_prefix, that.jwt);
 			if (all_events || events_to_publish[event.type]) push_event(event);
 		}
 		async function cancel() {
@@ -1932,7 +2025,7 @@ function submit(endpoint, data = {}, event_data, trigger_id, all_events, additio
 							...payload,
 							session_hash,
 							event_id
-						});
+						}, addt_headers);
 						if (status !== 200) {
 							fire_event({
 								type: "status",
@@ -2285,6 +2378,7 @@ var Client = class {
 	app_reference;
 	options;
 	deep_link = null;
+	page = null;
 	config;
 	api_prefix = "";
 	api_info;
@@ -2365,6 +2459,7 @@ var Client = class {
 	constructor(app_reference, options = { events: ["data"] }) {
 		this.app_reference = app_reference;
 		this.deep_link = options.query_params?.deep_link || null;
+		this.page = options.query_params?.page ?? null;
 		if (!options.events) options.events = ["data"];
 		normalise_token_option(options);
 		this.options = options;
@@ -2396,14 +2491,10 @@ var Client = class {
 		this.api_map = map_names_to_ids(this.config?.dependencies || []);
 	}
 	async _resolve_heartbeat(_config) {
-		if (_config) {
-			this.config = _config;
-			this.api_prefix = _config.api_prefix || "";
-			if (this.config && this.config.connect_heartbeat) {
-				if (this.config.space_id && this.options.token) this.jwt = await get_jwt(this.config.space_id, this.options.token, this.cookies);
-			}
-		}
-		if (_config.space_id && this.options.token) this.jwt = await get_jwt(_config.space_id, this.options.token);
+		this.config = _config;
+		this.api_prefix = _config.api_prefix || "";
+		if (_config.space_id && this.options.token) this.jwt = await get_jwt(_config.space_id, this.options.token, this.cookies);
+		sign_config_file_urls(this.config, this.jwt);
 		if (this.config && this.config.connect_heartbeat) {
 			const heartbeat_url = new URL(`${this.config.root}${this.api_prefix}/${HEARTBEAT_URL}/${this.session_hash}`);
 			if (this.jwt) heartbeat_url.searchParams.set("__sign", this.jwt);
@@ -2444,6 +2535,7 @@ var Client = class {
 		this.config = config;
 		this.api_prefix = config.api_prefix || "";
 		this.api_map = map_names_to_ids(config.dependencies || []);
+		sign_config_file_urls(this.config, this.jwt);
 		try {
 			this.api_info = await this.view_api();
 		} catch (e) {
@@ -2553,7 +2645,9 @@ var Client = class {
 				credentials: this.options.credentials ?? "same-origin"
 			});
 			if (!response.ok) throw new Error("Could not connect to component server: " + response.statusText);
-			return await response.json();
+			const output = await response.json();
+			sign_file_urls(output, this.config.root, this.config.api_prefix || "", this.jwt);
+			return output;
 		} catch (e) {
 			console.warn(e);
 		}
@@ -2594,4 +2688,91 @@ async function duplicate_space(app_reference, options) {
 	return await Client.duplicate(app_reference, options);
 }
 //#endregion
-export { Client, FileData, MISSING_CREDENTIALS_MSG, apply_run_history_replay, clear_run_history, client, consume_run_history_replay, delete_run_history, duplicate_space as duplicate, handle_file, on_run_history_change, predict, prepare_files, read_run_history, run_history_url, stage_run_history_replay, submit, upload, upload_files };
+//#region src/utils/bucket_sync.ts
+/**
+* Client for the durable run history in an HF Hub bucket
+* (`/gradio_api/run-history/*`).
+*
+* Read-only by design. Records are written by the server from the run it
+* actually executed — there is no push function here, and nothing in this
+* module can create a record.
+*
+* Every call names the bucket it is talking about. The server holds no
+* per-session binding, so two tabs (or two apps on one origin) cannot end up
+* reading each other's history.
+*/
+var BUCKET_ID_RE = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-][a-zA-Z0-9_./-]*$/;
+function is_valid_bucket_id(id) {
+	if (!BUCKET_ID_RE.test(id)) return false;
+	return !id.split("/").some((seg) => seg === "" || seg === "." || seg === "..");
+}
+function url(root, path, params) {
+	const query = params ? `?${new URLSearchParams(params)}` : "";
+	const base = root.replace(/\/+$/, "");
+	if (base) return `${base}/gradio_api/run-history/${path}${query}`;
+	if (typeof document !== "undefined" && document.baseURI) return new URL(`gradio_api/run-history/${path}${query}`, document.baseURI).toString();
+	return `gradio_api/run-history/${path}${query}`;
+}
+async function parse_error(res) {
+	try {
+		const j = await res.json();
+		return typeof j?.detail === "string" ? j.detail : `${res.status}`;
+	} catch {
+		return `${res.status}`;
+	}
+}
+async function request(input, init, fallback, pick) {
+	try {
+		const res = await fetch(input, {
+			credentials: "include",
+			...init
+		});
+		if (!res.ok) return {
+			ok: false,
+			status: res.status,
+			data: fallback,
+			detail: await parse_error(res)
+		};
+		return {
+			ok: true,
+			status: res.status,
+			data: pick(await res.json())
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			status: 0,
+			data: fallback,
+			detail: String(e)
+		};
+	}
+}
+/**
+* Create the bucket if it does not exist and confirm it is writable. Stores
+* nothing server-side — the caller keeps its own choice and names it on every
+* later request.
+*/
+async function connect_bucket(root, bucket_id) {
+	if (!is_valid_bucket_id(bucket_id)) return {
+		ok: false,
+		status: 422,
+		data: null,
+		detail: "invalid bucket id"
+	};
+	return request(url(root, "connect"), {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ bucket_id })
+	}, null, () => null);
+}
+async function list_user_buckets(root) {
+	return request(url(root, "buckets"), {}, [], (b) => Array.isArray(b?.buckets) ? b.buckets : []);
+}
+async function list_bucket_records(root, bucket) {
+	return request(url(root, "records", { bucket }), {}, [], (b) => Array.isArray(b?.records) ? b.records : []);
+}
+function asset_url(root, bucket, endpoint, record_id, filename) {
+	return url(root, `records/${encodeURIComponent(endpoint)}/${encodeURIComponent(record_id)}/assets/${encodeURIComponent(filename)}`, { bucket });
+}
+//#endregion
+export { Client, FileData, MISSING_CREDENTIALS_MSG, apply_run_history_replay, asset_url, clear_run_history, client, connect_bucket, consume_run_history_replay, delete_run_history, duplicate_space as duplicate, handle_file, is_valid_bucket_id, list_bucket_records, list_user_buckets, on_run_history_change, predict, prepare_files, read_run_history, read_run_history_storage, run_history_url, set_run_history_storage, stage_run_history_replay, submit, upload, upload_files };