update embeds

Author: Shaw

packages/app-core/src/runtime/eliza.ts

@@ -425,6 +425,22 @@ interface RuntimeHookModule {
 
 const TRAINING_RUNTIME_HOOKS_SPECIFIER = "@elizaos/plugin-training";
 
+/**
+ * Returns true only for genuine "module is not installed" import failures.
+ * Bun raises `ResolveMessage` with `code === "ERR_MODULE_NOT_FOUND"` when a
+ * specifier cannot be resolved; Node uses the same `code`. Anything else
+ * (syntax error, runtime error during module init, tsconfig path hijack,
+ * missing transitive dependency) is a real load failure and must NOT be
+ * misreported as "not installed".
+ */
+function isModuleNotFoundError(err: unknown): boolean {
+  if (!err || typeof err !== "object") return false;
+  const errObj = err as { code?: unknown; constructor?: { name?: string } };
+  if (errObj.code === "ERR_MODULE_NOT_FOUND") return true;
+  if (errObj.constructor?.name === "ResolveMessage") return true;
+  return false;
+}
+
 async function registerTrainingRuntimeHooks(
   runtime: AgentRuntime,
 ): Promise<void> {
@@ -434,10 +450,18 @@ async function registerTrainingRuntimeHooks(
       TRAINING_RUNTIME_HOOKS_SPECIFIER
     )) as RuntimeHookModule;
   } catch (err) {
-    logger.warn(
-      `[eliza] @elizaos/plugin-training not installed, skipping runtime hooks: ${formatError(err)}`,
+    if (isModuleNotFoundError(err)) {
+      logger.warn(
+        `[eliza] @elizaos/plugin-training not installed, skipping runtime hooks`,
+      );
+      return;
+    }
+    // Real load failure (syntax error, broken transitive, init throw, etc.) —
+    // surface it loudly so it is not mistaken for "not installed".
+    logger.error(
+      `[eliza] @elizaos/plugin-training failed to load (not 'not installed'): ${formatErrorWithStack(err)}`,
     );
-    return;
+    throw err;
   }
 
   if (!hookMod.registerTrainingRuntimeHooks) {

packages/cloud-frontend/vite.config.ts

@@ -410,6 +410,18 @@ export default defineConfig(({ mode }) => {
       // Keep the build warning budget explicit so import and resolver warnings
       // still stand out in CI output.
       chunkSizeWarningLimit: 3000,
+      // Strip route-specific vendor chunks (wallet, docs, charts) from the
+      // entry's <link rel="modulepreload"> set. Rolldown otherwise lists every
+      // transitive dep of every lazy route in the entry's preload manifest,
+      // which on the landing page was 58 preloads (22 of them wallet chunks)
+      // before the user navigated anywhere. Those chunks still load on demand
+      // via Vite's __vitePreload helper at the dynamic-import callsite, so
+      // dropping them from the entry only saves the initial connection budget.
+      modulePreload: {
+        polyfill: false,
+        resolveDependencies: (_filename, deps) =>
+          deps.filter((dep) => !/vendor-(wallet|docs|charts)-/.test(dep)),
+      },
       rolldownOptions: {
         output: {
           codeSplitting: {

packages/core/src/runtime/planner-loop.ts

@@ -131,6 +131,8 @@ export async function runPlannerLoop(
 	const failures: FailureLike[] = [];
 	let terminalOnlyContinuations = 0;
 	let requiredToolMisses = 0;
+	let unavailableToolCallRetries = 0;
+	let silentFailedFinishRecoveries = 0;
 	const requireNonTerminalToolCall =
 		params.requireNonTerminalToolCall === true &&
 		hasExposedNonTerminalTool(params.tools);
@@ -218,27 +220,19 @@ export async function runPlannerLoop(
 					!hasExecutedNonTerminalTool(trajectory)
 				) {
 					requiredToolMisses++;
-					if (requiredToolMisses > config.maxRequiredToolMisses) {
-						params.runtime.logger?.warn?.(
-							{
-								src: "planner-loop",
-								iteration,
-								misses: requiredToolMisses,
-								max: config.maxRequiredToolMisses,
-								messageToUser: plannerOutput.messageToUser,
-							},
-							"required_tool_misses budget exhausted; honoring planner's terminal reply instead of throwing",
-						);
-					} else {
-						handleRequiredToolPlannerMiss({
-							trajectory,
-							iteration,
-							plannerOutput,
-							reason: "no_tool_calls",
-							logger: params.runtime.logger,
-						});
-						continue;
-					}
+					assertTrajectoryLimit({
+						kind: "required_tool_misses",
+						max: config.maxRequiredToolMisses,
+						observed: requiredToolMisses,
+					});
+					handleRequiredToolPlannerMiss({
+						trajectory,
+						iteration,
+						plannerOutput,
+						reason: "no_tool_calls",
+						logger: params.runtime.logger,
+					});
+					continue;
 				}
 				trajectory.steps.push({
 					iteration,
@@ -326,27 +320,19 @@ export async function runPlannerLoop(
 					!hasExecutedNonTerminalTool(trajectory)
 				) {
 					requiredToolMisses++;
-					if (requiredToolMisses > config.maxRequiredToolMisses) {
-						params.runtime.logger?.warn?.(
-							{
-								src: "planner-loop",
-								iteration,
-								misses: requiredToolMisses,
-								max: config.maxRequiredToolMisses,
-								messageToUser: plannerOutput.messageToUser,
-							},
-							"required_tool_misses budget exhausted; honoring planner's terminal tool-call reply instead of throwing",
-						);
-					} else {
-						handleRequiredToolPlannerMiss({
-							trajectory,
-							iteration,
-							plannerOutput,
-							reason: "terminal_only_tool_calls",
-							logger: params.runtime.logger,
-						});
-						continue;
-					}
+					assertTrajectoryLimit({
+						kind: "required_tool_misses",
+						max: config.maxRequiredToolMisses,
+						observed: requiredToolMisses,
+					});
+					handleRequiredToolPlannerMiss({
+						trajectory,
+						iteration,
+						plannerOutput,
+						reason: "terminal_only_tool_calls",
+						logger: params.runtime.logger,
+					});
+					continue;
 				}
 				const finalMessage = terminalMessageFromToolCalls(
 					plannerOutput.toolCalls,
@@ -388,12 +374,43 @@ export async function runPlannerLoop(
 			const nonTerminalCalls = plannerOutput.toolCalls
 				.filter((toolCall) => !isTerminalToolCall(toolCall))
 				.map((toolCall, index) => ensureToolCallId(toolCall, iteration, index));
-			trajectory.plannedQueue.push(...nonTerminalCalls);
+			const unavailable = splitUnavailableToolCalls(
+				nonTerminalCalls,
+				params.tools,
+			);
+			if (unavailable.invalid.length > 0) {
+				params.runtime.logger?.warn?.(
+					{
+						iteration,
+						invalidToolCalls: unavailable.invalid.map(
+							(toolCall) => toolCall.name,
+						),
+					},
+					"Planner called unavailable tools; retrying without executing them",
+				);
+				trajectory.context = appendUnavailableToolCallEvent({
+					context: trajectory.context,
+					iteration,
+					invalidToolCalls: unavailable.invalid,
+					tools: params.tools,
+				});
+				if (unavailable.valid.length === 0) {
+					unavailableToolCallRetries++;
+					assertTrajectoryLimit({
+						kind: "unavailable_tool_calls",
+						max: config.maxUnavailableToolCallRetries,
+						observed: unavailableToolCallRetries,
+					});
+					continue;
+				}
+			}
+			const validNonTerminalCalls = unavailable.valid;
+			trajectory.plannedQueue.push(...validNonTerminalCalls);
 			trajectory.context = {
 				...trajectory.context,
 				plannedQueue: [
 					...(trajectory.context.plannedQueue ?? []),
-					...nonTerminalCalls.map((toolCall) => ({
+					...validNonTerminalCalls.map((toolCall) => ({
 						id: toolCall.id,
 						name: toolCall.name,
 						args: stringifyForModel(toolCall.params ?? {}),
@@ -402,7 +419,7 @@ export async function runPlannerLoop(
 					})),
 				],
 			};
-			for (const toolCall of nonTerminalCalls) {
+			for (const toolCall of validNonTerminalCalls) {
 				trajectory.context = appendContextEvent(trajectory.context, {
 					id: `queue:${toolCall.id ?? toolCall.name}:${iteration}`,
 					type: "planned_tool_call",
@@ -503,12 +520,32 @@ export async function runPlannerLoop(
 		appendEvaluatorContextEvent(trajectory, evaluator, iteration);
 
 		if (evaluator.decision === "FINISH") {
+			if (
+				shouldRecoverSilentFailedFinish({
+					evaluator,
+					trajectory,
+					recoveryCount: silentFailedFinishRecoveries,
+				})
+			) {
+				silentFailedFinishRecoveries++;
+				trajectory.context = appendSilentFailedFinishRecoveryEvent({
+					context: trajectory.context,
+					iteration,
+					evaluator,
+					trajectory,
+				});
+				continue;
+			}
 			return {
 				status: "finished",
 				trajectory,
 				evaluator,
 				finalMessage: userSafeFinalMessage(
-					evaluator.messageToUser ?? latestToolResultText(trajectory),
+					evaluator.messageToUser ??
+						latestToolResultText(trajectory) ??
+						(evaluator.success === false
+							? failedToolFallbackMessage(trajectory)
+							: undefined),
 					trajectory,
 				),
 			};
@@ -1636,6 +1673,7 @@ async function executeQueuedToolCall(params: {
 		toolName: params.toolCall.name,
 		success: result.success,
 		error: result.error,
+		repeatKey: toolFailureRepeatKey(params.toolCall),
 	};
 	if (!result.success || result.error != null) {
 		params.failures.push(failure);

packages/homepage/public/brand/ogembeds/eliza_ogembed.png

@@ -1,4 +1,5 @@
 import { BRAND_COLORS } from "@elizaos/shared-brand";
+import { Loader2 } from "lucide-react";
 import { lazy, Suspense } from "react";
 import { BrowserRouter, Route, Routes } from "react-router-dom";
 import { QueryProvider } from "@/components/providers/query-provider";
@@ -15,12 +16,12 @@ function RouteFallback() {
     <main
       className="theme-app min-h-screen flex flex-col items-center justify-center px-4"
       style={{
-        background: BRAND_COLORS.black,
-        color: BRAND_COLORS.white,
+        background: BRAND_COLORS.orange,
+        color: BRAND_COLORS.black,
         fontFamily: "Poppins",
       }}
     >
-      <div className="opacity-70">Loading…</div>
+      <Loader2 className="h-8 w-8 animate-spin opacity-80" />
     </main>
   );
 }

packages/homepage/public/brand/ogembeds/elizacloud_ogembed.png

@@ -8,15 +8,19 @@ import {
 } from "@elizaos/ui/cloud-ui";
 import { animated, useSpring, useTrail } from "@react-spring/web";
 import { ArrowLeft, Check, Copy, ExternalLink, Info, Send } from "lucide-react";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { lazy, Suspense, useCallback, useEffect, useRef, useState } from "react";
 import { Link, useNavigate, useSearchParams } from "react-router-dom";
 import { ElizaLogo } from "@/components/brand/eliza-logo";
 import {
   buildFullPhoneNumber,
   PhoneNumberInput,
   useCountryOptions,
 } from "@/components/login/phone-number-input";
-import ShaderBackground from "@/components/ShaderBackground/ShaderBackground";
+
+// Defer the WebGL shader background so the form UI is interactive immediately.
+const ShaderBackground = lazy(
+  () => import("@/components/ShaderBackground/ShaderBackground"),
+);
 import {
   buildElizaSmsHref,
   ELIZA_PHONE_FORMATTED,
@@ -805,7 +809,9 @@ export default function GetStartedPage() {
 
   return (
     <main className="min-h-screen flex flex-col relative">
-      <ShaderBackground />
+      <Suspense fallback={null}>
+        <ShaderBackground />
+      </Suspense>
       <div
         className="fixed inset-0 pointer-events-none mix-blend-overlay z-0"
         style={{

packages/homepage/public/brand/ogembeds/elizaos_ogembed.png

@@ -31,13 +31,19 @@ import type {
   HTMLAttributes,
   SVGProps,
 } from "react";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { lazy, Suspense, useCallback, useEffect, useRef, useState } from "react";
 import { useNavigate } from "react-router-dom";
 import BlobButton from "@/components/BlobButton";
 import { ElizaLogo } from "@/components/brand/eliza-logo";
 import ModelB, { type ModelBHandle } from "@/components/ModelViewers/ModelB";
-import ShaderBackground from "@/components/ShaderBackground/ShaderBackground";
-import VideoCall from "@/components/VideoCall";
+
+// Heavy WebGL bundles split out so the leaderboard route shell becomes
+// interactive without waiting for the shader/canvas code. ShaderBackground is
+// opt-in via ?shader=1. VideoCall only mounts when the user opens the modal.
+const ShaderBackground = lazy(
+  () => import("@/components/ShaderBackground/ShaderBackground"),
+);
+const VideoCall = lazy(() => import("@/components/VideoCall"));
 import { buildElizaSmsHref } from "@/lib/contact";
 import type { SpringAnimatedStyle } from "@/lib/spring-types";
 
@@ -735,7 +741,11 @@ export default function Leaderboard() {
         transition: "background-color 240ms ease, background 240ms ease",
       }}
     >
-      {SHADER_BACKGROUND_OPT_IN && <ShaderBackground />}
+      {SHADER_BACKGROUND_OPT_IN && (
+        <Suspense fallback={null}>
+          <ShaderBackground />
+        </Suspense>
+      )}
       <ModelB
         ref={modelRef}
         tryActive={platform === "try"}
@@ -1270,7 +1280,11 @@ export default function Leaderboard() {
           )}
         </p>
       </AnimatedDiv>
-      <VideoCall visible={showVideo} onClose={() => setShowVideo(false)} />
+      {showVideo && (
+        <Suspense fallback={null}>
+          <VideoCall visible={showVideo} onClose={() => setShowVideo(false)} />
+        </Suspense>
+      )}
       <AnimatedDiv
         className={`fixed inset-0 z-50 bg-white pointer-events-none flex items-center justify-center duration-100 ${
           introDone ? "opacity-0" : ""

packages/homepage/src/App.tsx

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import tailwindcss from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
+import { visualizer } from "rollup-plugin-visualizer";
 import { defineConfig, type Plugin } from "vite";
 
 /**
@@ -26,9 +27,27 @@ function gh404Fallback(): Plugin {
 }
 
 export default defineConfig({
-  plugins: [react(), tailwindcss(), gh404Fallback()],
+  plugins: [
+    react(),
+    tailwindcss(),
+    gh404Fallback(),
+    visualizer({
+      filename: "dist/stats.html",
+      gzipSize: true,
+      brotliSize: false,
+      template: "treemap",
+    }),
+  ],
   resolve: {
-    dedupe: ["react", "react-dom", "react-router", "react-router-dom"],
+    dedupe: [
+      "react",
+      "react-dom",
+      "react-router",
+      "react-router-dom",
+      "@react-three/fiber",
+      "three",
+      "zod",
+    ],
     alias: [
       { find: "@", replacement: path.resolve(__dirname, "./src") },
       {