refactor: remove unsafe overload casts in parallel probe

parallel-probe used forced casts to distinguish overload inputs and to
normalize probe failures. Replace those with explicit type guards and
error normalization so the module keeps the same behavior without
leaning on unsafe assertions.

Author: ndycode

lib/parallel-probe.ts

@@ -38,6 +38,34 @@ export interface GetTopCandidatesParams {
 	maxCandidates: number;
 }
 
+function isAccountManager(value: unknown): value is AccountManager {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"getAccountsSnapshot" in value &&
+		typeof value.getAccountsSnapshot === "function"
+	);
+}
+
+function isGetTopCandidatesParams(value: unknown): value is GetTopCandidatesParams {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"accountManager" in value &&
+		isAccountManager(value.accountManager) &&
+		"modelFamily" in value &&
+		typeof value.modelFamily === "string" &&
+		"model" in value &&
+		(typeof value.model === "string" || value.model === null) &&
+		"maxCandidates" in value &&
+		typeof value.maxCandidates === "number"
+	);
+}
+
+function toProbeError(error: unknown): Error {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
 /**
  * Get top N candidates ranked by hybrid score WITHOUT mutating AccountManager state.
  * Uses getAccountsSnapshot() and ranks by health + tokens + freshness.
@@ -64,13 +92,19 @@ export function getTopCandidates(
 	let resolvedMaxCandidates: number | undefined;
 
 	if (useNamedParams) {
-		const namedParams = accountManagerOrParams as GetTopCandidatesParams;
+		if (!isGetTopCandidatesParams(accountManagerOrParams)) {
+			throw new TypeError("getTopCandidates requires accountManager");
+		}
+		const namedParams = accountManagerOrParams;
 		resolvedAccountManager = namedParams.accountManager;
 		resolvedModelFamily = namedParams.modelFamily;
 		resolvedModel = namedParams.model;
 		resolvedMaxCandidates = namedParams.maxCandidates;
 	} else {
-		resolvedAccountManager = accountManagerOrParams as AccountManager;
+		if (!isAccountManager(accountManagerOrParams)) {
+			throw new TypeError("getTopCandidates requires accountManager");
+		}
+		resolvedAccountManager = accountManagerOrParams;
 		resolvedModelFamily = modelFamily;
 		resolvedModel = model;
 		resolvedMaxCandidates = maxCandidates;
@@ -158,7 +192,7 @@ export async function probeAccountsInParallel<T>(
 			const response = await probeFn(account, controller.signal);
 			return { type: "success", account, response };
 		} catch (error) {
-			return { type: "failure", account, error: error as Error };
+			return { type: "failure", account, error: toProbeError(error) };
 		}
 	}
 

test/parallel-probe.test.ts

@@ -77,6 +77,19 @@ describe("parallel-probe", () => {
 			expect(result?.error?.message).toBe("network error");
 		});
 
+		it("normalizes non-Error probe failures for single candidates", async () => {
+			const account = createMockAccount(0);
+			const candidates = createProbeCandidates([account]);
+
+			const result = await probeAccountsInParallel(candidates, async () => {
+				throw "string failure";
+			});
+
+			expect(result?.type).toBe("failure");
+			expect(result?.error).toBeInstanceOf(Error);
+			expect(result?.error?.message).toBe("string failure");
+		});
+
 		it("returns first success in parallel probing", async () => {
 			const accounts = [createMockAccount(0), createMockAccount(1), createMockAccount(2)];
 			const candidates = createProbeCandidates(accounts);
@@ -174,6 +187,23 @@ describe("parallel-probe", () => {
 	});
 
 	describe("getTopCandidates", () => {
+		it("accepts named params without overload casts", () => {
+			const accounts = [createMockAccount(0), createMockAccount(1)];
+			const mockManager = {
+				getAccountsSnapshot: vi.fn().mockReturnValue(accounts),
+			};
+
+			const candidates = getTopCandidates({
+				accountManager: mockManager as AccountManager,
+				modelFamily: "codex",
+				model: null,
+				maxCandidates: 1,
+			});
+
+			expect(candidates).toHaveLength(1);
+			expect(mockManager.getAccountsSnapshot).toHaveBeenCalledTimes(1);
+		});
+
 		it("returns empty array when no accounts available", () => {
 			const mockManager = {
 				getAccountsSnapshot: vi.fn().mockReturnValue([]),