@gradio/client 2.3.1 → 2.5.0

package/src/helpers/init_helpers.ts

@@ -1,10 +1,11 @@
-import type { Config } from "../types";
+import type { ClientOptions, Config } from "../types";
 import {
 	CONFIG_ERROR_MSG,
 	CONFIG_URL,
 	INVALID_CREDENTIALS_MSG,
 	LOGIN_URL,
 	MISSING_CREDENTIALS_MSG,
+	PRIVATE_SPACE_MSG,
 	SPACE_METADATA_ERROR_MSG,
 	UNAUTHORIZED_MSG
 } from "../constants";
@@ -53,6 +54,22 @@ export async function get_jwt(
 	}
 }
 
+/**
+ * The `hf_token` option was renamed to `token`, but a lot of existing code
+ * (and the Python client) still uses `hf_token`. Accept it as an alias so
+ * that authenticated requests are not silently sent without credentials,
+ * which previously surfaced as "Could not resolve app config" errors when
+ * connecting to private Spaces.
+ */
+export function normalise_token_option(options: ClientOptions): void {
+	if (options.hf_token && !options.token) {
+		options.token = options.hf_token;
+		console.warn(
+			"The `hf_token` option has been renamed to `token`. Support for `hf_token` will be removed in a future version of @gradio/client."
+		);
+	}
+}
+
 export function map_names_to_ids(
 	fns: Config["dependencies"]
 ): Record<string, number> {
@@ -64,9 +81,25 @@ export function map_names_to_ids(
 	return apis;
 }
 
+export function resolve_config_root(
+	root: string,
+	current_location: string
+): string {
+	const root_url = new URL(root, current_location);
+	const current_url = new URL(current_location);
+	if (root_url.hostname !== current_url.hostname) {
+		return root;
+	}
+
+	root_url.protocol = current_url.protocol;
+	root_url.host = current_url.host;
+	return root_url.toString().replace(/\/$/, "");
+}
+
 export async function resolve_config(
 	this: Client,
-	endpoint: string
+	endpoint: string,
+	strip_current_page = true
 ): Promise<Config | undefined> {
 	const headers: Record<string, string> = this.options.token
 		? { Authorization: `Bearer ${this.options.token}` }
@@ -77,7 +110,7 @@ export async function resolve_config(
 		window.gradio_config &&
 		location.origin !== "http://localhost:9876"
 	) {
-		if (window.gradio_config.current_page) {
+		if (strip_current_page && window.gradio_config.current_page) {
 			endpoint = endpoint.substring(0, endpoint.lastIndexOf("/"));
 		}
 		if (
@@ -102,8 +135,13 @@ export async function resolve_config(
 				current_page: window.gradio_config.current_page
 			};
 		}
-		// @ts-ignore
-		return { ...window.gradio_config } as Config;
+		// The page was rendered by this Gradio server, so a same-host root may
+		// contain an internal protocol or port supplied by a reverse proxy. Keep
+		// the configured path, but use the browser-visible origin for requests
+		// made by the client itself (queue, upload, reset, etc.).
+		const config = { ...window.gradio_config } as unknown as Config;
+		config.root = resolve_config_root(config.root, location.href);
+		return config;
 	} else if (endpoint) {
 		let config_url = join_urls(
 			endpoint,
@@ -132,7 +170,14 @@ async function handleConfigResponse(
 	authorized: boolean
 ): Promise<Config> {
 	if (response?.status === 401 && !authorized) {
-		const error_data = await response.json();
+		let error_data: any = null;
+		try {
+			error_data = await response.json();
+		} catch (e) {
+			// Unauthenticated requests to private Spaces receive a non-JSON 401
+			// page from the Hugging Face proxy rather than a Gradio auth payload.
+			throw new Error(PRIVATE_SPACE_MSG);
+		}
 		const auth_message = error_data?.detail?.auth_message;
 		throw new Error(auth_message || MISSING_CREDENTIALS_MSG);
 	} else if (response?.status === 401 && authorized) {
@@ -151,7 +196,9 @@ async function handleConfigResponse(
 		throw new Error(UNAUTHORIZED_MSG);
 	}
 
-	throw new Error(CONFIG_ERROR_MSG);
+	throw new Error(
+		`${CONFIG_ERROR_MSG}(received status ${response?.status} when fetching the app config)`
+	);
 }
 
 export async function resolve_cookies(this: Client): Promise<void> {

package/src/index.ts

@@ -5,6 +5,18 @@ export { submit } from "./utils/submit";
 export { upload_files } from "./utils/upload_files";
 export { FileData, upload, prepare_files } from "./upload";
 export { handle_file } from "./helpers/data";
+export {
+	clear_run_history,
+	consume_run_history_replay,
+	delete_run_history,
+	on_run_history_change,
+	read_run_history,
+	run_history_url,
+	stage_run_history_replay,
+	type RunHistoryScope,
+	type StoredRunComponent,
+	type StoredRun
+} from "./utils/run_history";
 
 export type {
 	SpaceStatus,

package/src/test/api_info.test.ts

@@ -1,7 +1,7 @@
 import {
 	INVALID_URL_MSG,
 	QUEUE_FULL_MSG,
-	SPACE_METADATA_ERROR_MSG
+	SPACE_NOT_FOUND_MSG
 } from "../constants";
 import { beforeAll, afterEach, afterAll, it, expect, describe } from "vitest";
 import {
@@ -10,7 +10,8 @@ import {
 	get_type,
 	process_endpoint,
 	join_urls,
-	map_data_to_params
+	map_data_to_params,
+	transform_api_info
 } from "../helpers/api_info";
 import { initialise_server } from "./server";
 import { transformed_api_info } from "./test_data";
@@ -471,19 +472,13 @@ describe("process_endpoint", () => {
 		expect(result).toEqual(expected);
 	});
 
-	it("should throw an error when fetching space metadata fails", async () => {
+	it("should throw a clear error when the space does not exist or is private", async () => {
 		const app_reference = "hmb/bye_world";
 		const token = "hf_token";
 
-		try {
-			await process_endpoint(app_reference, token);
-		} catch (error) {
-			if (error instanceof Error) {
-				expect(error.message).toEqual(SPACE_METADATA_ERROR_MSG);
-			} else {
-				expect.fail("Error should not be unknown.");
-			}
-		}
+		await expect(process_endpoint(app_reference, token)).rejects.toThrow(
+			SPACE_NOT_FOUND_MSG(app_reference, 404)
+		);
 	});
 
 	it("should return the correct data when app_reference is a valid space domain", async () => {
@@ -699,3 +694,73 @@ describe("map_data_params", () => {
 		);
 	});
 });
+
+describe("transform_api_info", () => {
+	it("defaults parameters and returns to empty arrays when an endpoint entry is malformed", () => {
+		const api_info = {
+			named_endpoints: {
+				// missing `parameters` and `returns`, as returned by some legacy
+				// or misbehaving apps (see issue #10945)
+				"/predict": {}
+			},
+			unnamed_endpoints: {}
+		} as any;
+		const config = {
+			dependencies: [
+				{
+					id: 0,
+					api_name: "predict",
+					inputs: [1],
+					outputs: [2],
+					types: { generator: false, cancel: false }
+				}
+			],
+			components: [
+				{ id: 1, type: "textbox", props: {} },
+				{ id: 2, type: "textbox", props: {} }
+			]
+		} as any;
+
+		const result = transform_api_info(api_info, config, { predict: 0 });
+
+		expect(result.named_endpoints["/predict"].parameters).toEqual([]);
+		expect(result.named_endpoints["/predict"].returns).toEqual([]);
+	});
+
+	it("keeps oauth_token, which submit() needs to decide where a token may be sent", () => {
+		const api_info = {
+			named_endpoints: {
+				"/report": { parameters: [], returns: [], oauth_token: "optional" },
+				"/calculator": { parameters: [], returns: [] }
+			},
+			unnamed_endpoints: {}
+		} as any;
+		const config = {
+			dependencies: [
+				{
+					id: 0,
+					api_name: "report",
+					inputs: [],
+					outputs: [],
+					types: { generator: false, cancel: false }
+				},
+				{
+					id: 1,
+					api_name: "calculator",
+					inputs: [],
+					outputs: [],
+					types: { generator: false, cancel: false }
+				}
+			],
+			components: []
+		} as any;
+
+		const result = transform_api_info(api_info, config, {
+			report: 0,
+			calculator: 1
+		});
+
+		expect(result.named_endpoints["/report"].oauth_token).toBe("optional");
+		expect(result.named_endpoints["/calculator"].oauth_token).toBeUndefined();
+	});
+});

package/src/test/data.test.ts

@@ -97,6 +97,27 @@ describe("walk_and_store_blobs", () => {
 		expect(parts[0].path).toEqual(["0"]);
 	});
 
+	it("should preserve File instances (and their filenames)", async () => {
+		const file = new File(["test data"], "report.txt", {
+			type: "text/plain"
+		});
+		const parts = await walk_and_store_blobs([file]);
+
+		expect(parts).toHaveLength(1);
+		expect(parts[0].blob).toBe(file);
+		expect((parts[0].blob as File).name).toBe("report.txt");
+		expect((parts[0].blob as File).type).toBe("text/plain");
+	});
+
+	it("should preserve the MIME type of Blob instances", async () => {
+		const blob = new Blob(["test data"], { type: "image/png" });
+		const parts = await walk_and_store_blobs([blob]);
+
+		expect(parts).toHaveLength(1);
+		expect(parts[0].blob).toBe(blob);
+		expect(parts[0].blob && parts[0].blob.type).toBe("image/png");
+	});
+
 	it("should handle deep structures", async () => {
 		const image = new Blob([]);
 		const parts = await walk_and_store_blobs({ a: { b: { data: { image } } } });
@@ -371,11 +392,13 @@ describe("handle_file", () => {
 	);
 
 	it.skipIf(IS_NODE)(
-		"should handle a File object and return it as FileData",
+		"should handle a File object and return it unchanged, preserving its name and type",
 		() => {
 			const file = new File(["test image"], "test.png", { type: "image/png" });
-			const result = handle_file(file) as FileData;
-			expect(result).toBeInstanceOf(Blob);
+			const result = handle_file(file) as File;
+			expect(result).toBe(file);
+			expect(result.name).toBe("test.png");
+			expect(result.type).toBe("image/png");
 		}
 	);
 

package/src/test/init.test.ts

@@ -15,7 +15,7 @@ import {
 	response_api_info
 } from "./test_data";
 import { initialise_server } from "./server";
-import { SPACE_METADATA_ERROR_MSG } from "../constants";
+import { SPACE_NOT_FOUND_MSG } from "../constants";
 
 const app_reference = "hmb/hello_world";
 const broken_app_reference = "hmb/bye_world";
@@ -87,12 +87,28 @@ describe("Client class", () => {
 			});
 		});
 
+		test("connecting successfully to a private running app with the deprecated hf_token option", async () => {
+			const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+			const app = await Client.connect("hmb/secret_world", {
+				hf_token: "hf_123"
+			});
+
+			expect(app.config).toEqual({
+				...config_response,
+				root: "https://hmb-secret-world.hf.space"
+			});
+			expect(warn).toHaveBeenCalledWith(
+				expect.stringContaining("`hf_token` option has been renamed")
+			);
+			warn.mockRestore();
+		});
+
 		test("unsuccessfully attempting to connect to a private running app", async () => {
 			await expect(
 				Client.connect("hmb/secret_world", {
 					token: "hf_bad_token"
 				})
-			).rejects.toThrowError(SPACE_METADATA_ERROR_MSG);
+			).rejects.toThrowError(SPACE_NOT_FOUND_MSG("hmb/secret_world", 401));
 		});
 
 		test("viewing the api info of a running app", async () => {
@@ -139,7 +155,9 @@ describe("Client class", () => {
 		test("creating a duplicate of a broken app", async () => {
 			const duplicate = Client.duplicate(broken_app_reference);
 
-			await expect(duplicate).rejects.toThrow(SPACE_METADATA_ERROR_MSG);
+			await expect(duplicate).rejects.toThrow(
+				SPACE_NOT_FOUND_MSG(broken_app_reference, 404)
+			);
 		});
 	});
 

package/src/test/init_helpers.test.ts

@@ -3,7 +3,8 @@ import {
 	get_jwt,
 	determine_protocol,
 	parse_and_set_cookies,
-	resolve_config
+	resolve_config,
+	resolve_config_root
 } from "../helpers/init_helpers";
 import { initialise_server } from "./server";
 import { beforeAll, afterEach, afterAll, it, expect, describe } from "vitest";
@@ -21,6 +22,24 @@ afterEach(() => server.resetHandlers());
 afterAll(() => server.stop());
 
 describe("resolve_config", () => {
+	it("uses the public protocol and port for a same-host proxy root", () => {
+		expect(
+			resolve_config_root(
+				"http://machine.local:7862/gradio",
+				"https://machine.local:20443/gradio"
+			)
+		).toBe("https://machine.local:20443/gradio");
+	});
+
+	it("keeps the configured origin for a remote root", () => {
+		expect(
+			resolve_config_root(
+				"https://remote.example/gradio",
+				"https://host.example/page"
+			)
+		).toBe("https://remote.example/gradio");
+	});
+
 	it("requests /config without a Content-Type header and with same-origin credentials, so the cross-origin embed fetch is not blocked by CORS", async () => {
 		let captured_init: RequestInit | undefined;
 		const fake_client = {
@@ -43,6 +62,53 @@ describe("resolve_config", () => {
 		expect(header_names).not.toContain("content-type");
 		expect(captured_init?.credentials).toBe("same-origin");
 	});
+
+	const in_browser = typeof window !== "undefined";
+
+	it.skipIf(!in_browser)(
+		"uses the browser origin for a same-host config root behind a proxy",
+		async () => {
+			const page = new URL(window.location.href);
+			const internal_root = `${page.protocol}//${page.hostname}:7862/gradio`;
+			window.gradio_config = {
+				...config_response,
+				root: internal_root
+			};
+			const fake_client = {
+				options: {},
+				deep_link: null
+			} as unknown as Client;
+
+			try {
+				const config = await resolve_config.call(fake_client, internal_root);
+				expect(config?.root).toBe(`${page.origin}/gradio`);
+			} finally {
+				delete (window as Partial<Window>).gradio_config;
+			}
+		}
+	);
+
+	it.skipIf(!in_browser)(
+		"keeps a remote config root when the page and backend hostnames differ",
+		async () => {
+			const remote_root = "https://remote.example/gradio";
+			window.gradio_config = {
+				...config_response,
+				root: remote_root
+			};
+			const fake_client = {
+				options: {},
+				deep_link: null
+			} as unknown as Client;
+
+			try {
+				const config = await resolve_config.call(fake_client, remote_root);
+				expect(config?.root).toBe(remote_root);
+			} finally {
+				delete (window as Partial<Window>).gradio_config;
+			}
+		}
+	);
 });
 
 describe("resolve_root", () => {

package/src/test/refresh.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test, vi } from "vitest";
+import { Client } from "../client";
+import type { Config } from "../types";
+
+describe("Client.refresh", () => {
+	test("refreshes from the app root without stripping the current page again", async () => {
+		const client = new Client("https://example.test/app/page");
+		client.config = {
+			root: "https://example.test/app",
+			dependencies: []
+		} as unknown as Config;
+
+		const refreshed_config = {
+			root: "https://example.test/app",
+			api_prefix: "/gradio_api",
+			dependencies: [{ id: 4, api_name: "generate" }]
+		} as unknown as Config;
+		const resolve_config = vi.fn().mockResolvedValue(refreshed_config);
+		Reflect.set(client, "resolve_config", resolve_config);
+		client.view_api = vi.fn().mockResolvedValue({});
+		client.get_url_config = vi.fn().mockReturnValue(refreshed_config);
+
+		await client.refresh();
+
+		expect(resolve_config).toHaveBeenCalledWith(
+			"https://example.test/app",
+			false
+		);
+		expect(client.api_map).toEqual({ generate: 4 });
+	});
+});