⚡ Bolt: Optimize ZimaOS V1 models fetch with concurrent promises

[bobdivx]

💡 What:
Replaced the await inside a for...of loop with a map operation to generate an array of Promises, which are then sequentially awaited. This ensures that the network requests to all fallback paths initiate concurrently instead of waiting for each one to complete.

🎯 Why:
To reduce sequential I/O latency when pinging multiple paths (like /v1/models and /api/v1/models) on the gateway.

📊 Impact:
Significantly reduces wait times for gateway connection probes in suboptimal scenarios, improving startup or settings menu render time.

🔬 Measurement:
Verified with pnpm run check and pnpm test. The system functions normally but worst-case API fetch execution time scales with the longest single request rather than the sum of all requests.

---

PR created automatically by Jules for task 9299138136734177918 started by @bobdivx

[google-labs-jules]

👋 Jules, reporting for duty! I'm here to lend a hand with this pull request.

When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down.

I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job!

For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with @jules. You can find this option in the Pull Request section of your global Jules UI settings. You can always switch back!

New to Jules? Learn more at jules.google/docs.

---

For security, I will only act on instructions from the user who triggered this task.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated (UTC)
forge	Ready	Preview, Comment	May 16, 2026 5:23pm

[gemini-code-assist]

Code Review

This pull request optimizes network I/O in the collectZimaOSV1ModelEntries function by initiating requests concurrently rather than sequentially, and adds a corresponding learning entry to the .jules/bolt.md documentation. Review feedback indicates that the current implementation's comments are misleading regarding how promises are processed in a loop and suggests using Promise.all for a more idiomatic approach that correctly handles concurrent fetching while preserving result order.

[gemini-code-assist]

The comment on line 122 is misleading. The current implementation using a for...of loop over an array of promises awaits them in their original array order, meaning it does not process them "individually as they arrive". If the first request is slow, the second request's result will wait even if it finished earlier. To achieve concurrent fetching while maintaining the original stateful logic in a more idiomatic way, I suggest using Promise.all which natively preserves the order of results.

Suggested change

	// We don't await Promise.all so we process them individually as they arrive
	// while preserving the original stateful fallback resolution logic.
	const fetches = V1_MODELS_PATHS.map((path) => fetchZimaOSJson(email, path));
	for (const p of fetches) {
	const r = await p;
	lastStatus = r.status;
	lastError = r.error;
	lastRaw = r.data;
	// We await them in order to preserve the original stateful fallback resolution logic.
	const results = await Promise.all(V1_MODELS_PATHS.map((path) => fetchZimaOSJson(email, path)));
	for (const r of results) {
	lastStatus = r.status;
	lastError = r.error;
	lastRaw = r.data;

[gemini-code-assist]

The description of the action is slightly inaccurate. Promise.all returns results in the same order as the input array, so there is no need to manually store promises and iterate over them sequentially to preserve order. Using Promise.all directly is the standard and most efficient way to handle this pattern.

Suggested change

	**Action:** Use `Promise.all` to fetch all resources concurrently. To preserve side-effect logic dependent on order (like keeping the "last" status or error), store the resolved promises in an array and iterate over them sequentially in the same order as the original paths array.
	**Action:** Use `Promise.all` to initiate network requests concurrently. This allows the system to wait for all responses in parallel while receiving the results in the original order, ensuring that stateful logic (like fallback resolution) remains consistent and predictable.