@elizaos/app-core 2.0.0-alpha.13 → 2.0.0-alpha.15

package/src/platform/lifo.ts

@@ -77,7 +77,12 @@ function parseLocationParams(locationLike: LocationLike): {
 export function isLifoPopoutValue(value: string | null | undefined): boolean {
   if (typeof value !== "string") return false;
   const normalized = value.trim().toLowerCase();
-  return normalized === "" || normalized === "1" || normalized === "true" || normalized === "lifo";
+  return (
+    normalized === "" ||
+    normalized === "1" ||
+    normalized === "true" ||
+    normalized === "lifo"
+  );
 }
 
 export function getPopoutValueFromLocation(
@@ -87,7 +92,9 @@ export function getPopoutValueFromLocation(
   return search.get("popout") ?? hash.get("popout");
 }
 
-export function isLifoPopoutModeAtLocation(locationLike: LocationLike): boolean {
+export function isLifoPopoutModeAtLocation(
+  locationLike: LocationLike,
+): boolean {
   return isLifoPopoutValue(getPopoutValueFromLocation(locationLike));
 }
 
@@ -121,7 +128,9 @@ export function generateLifoSessionId(): string {
       bytes[index] = Math.floor(Math.random() * 256);
     }
   }
-  return Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join("");
+  return Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join(
+    "",
+  );
 }
 
 export function getLifoSyncChannelName(sessionId: string | null): string {
@@ -205,7 +214,8 @@ export async function createLifoRuntime(
           options?.onStdout?.("Command dispatched to sandbox runtime.\n");
           return { exitCode: 0 };
         } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
+          const message =
+            error instanceof Error ? error.message : String(error);
           options?.onStderr?.(`${message}\n`);
           throw error;
         }

package/src/state/AppContext.tsx

@@ -4,6 +4,7 @@
  * Children access state and actions through the useApp() hook.
  */
 
+import type { OnboardingConnection } from "@elizaos/autonomous/contracts/onboarding";
 import {
   type ReactNode,
   useCallback,
@@ -12,7 +13,6 @@ import {
   useRef,
   useState,
 } from "react";
-import type { OnboardingConnection } from "@elizaos/autonomous/contracts/onboarding";
 import { prepareDraftForSave } from "../actions/character";
 import {
   type AgentStartupDiagnostics,
@@ -926,6 +926,8 @@ export function AppProvider({ children }: { children: ReactNode }) {
 
   // --- Refs for timers ---
   const actionNoticeTimer = useRef<number | null>(null);
+  /** Session-scoped set of notice texts that have been shown with once=true. */
+  const shownOnceNotices = useRef<Set<string>>(new Set());
   const elizaCloudPollInterval = useRef<number | null>(null);
   const elizaCloudLoginPollTimer = useRef<number | null>(null);
   const prevAgentStateRef = useRef<string | null>(null);
@@ -989,7 +991,10 @@ export function AppProvider({ children }: { children: ReactNode }) {
       text: string,
       tone: "info" | "success" | "error" = "info",
       ttlMs = 2800,
+      once = false,
     ) => {
+      if (once && shownOnceNotices.current.has(text)) return;
+      if (once) shownOnceNotices.current.add(text);
       setActionNoticeState({ tone, text });
       if (actionNoticeTimer.current != null) {
         window.clearTimeout(actionNoticeTimer.current);
@@ -3092,6 +3097,24 @@ export function AppProvider({ children }: { children: ReactNode }) {
         conversationMessagesRef.current.length > 0
       )
         return;
+
+      // Clean up empty conversations: if the previous conversation has only
+      // system/greeting messages and no user messages, delete it silently.
+      const prevId = activeConversationId;
+      if (prevId && prevId !== id) {
+        const prevMessages = conversationMessagesRef.current;
+        const hasUserMessage = prevMessages.some((m) => m.role === "user");
+        if (!hasUserMessage && prevMessages.length <= 1) {
+          void client.deleteConversation(prevId).catch(() => {});
+          setConversations((prev) => prev.filter((c) => c.id !== prevId));
+          setUnreadConversations((prev) => {
+            const next = new Set(prev);
+            next.delete(prevId);
+            return next;
+          });
+        }
+      }
+
       const previousActive = activeConversationId;
       setActiveConversationId(id);
       activeConversationIdRef.current = id;

package/src/state/internal.ts

@@ -1,3 +1,9 @@
+export {
+  deriveOnboardingResumeConnection,
+  deriveOnboardingResumeFields,
+  hasPartialOnboardingConnectionConfig,
+  inferOnboardingResumeStep,
+} from "./onboarding-resume";
 export {
   asApiLikeError,
   computeStreamingDelta,
@@ -15,12 +21,6 @@ export {
   parseStreamEventEnvelopeEvent,
   shouldApplyFinalStreamText,
 } from "./parsers";
-export {
-  deriveOnboardingResumeConnection,
-  deriveOnboardingResumeFields,
-  hasPartialOnboardingConnectionConfig,
-  inferOnboardingResumeStep,
-} from "./onboarding-resume";
 export {
   applyUiTheme,
   clearPersistedOnboardingStep,

package/src/state/parsers.ts

@@ -171,11 +171,12 @@ function normalizeSlashCommandName(name: string): string {
 
 // A simple utility to split command arguments, equivalent to chat-commands splitCommandArgs
 function splitCommandArgs(text: string): string[] {
-  const parts = [];
+  const parts: string[] = [];
   const regex = /[^\s"']+|"([^"]*)"|'([^']*)'/g;
-  let match;
-  while ((match = regex.exec(text)) !== null) {
+  let match: RegExpExecArray | null = regex.exec(text);
+  while (match !== null) {
     parts.push(match[1] || match[2] || match[0]);
+    match = regex.exec(text);
   }
   return parts;
 }

package/src/state/persistence.ts

@@ -289,7 +289,7 @@ export function loadActiveConversationId(): string | null {
 
 export function saveActiveConversationId(value: string | null): void {
   try {
-    if (value && value.trim()) {
+    if (value?.trim()) {
       localStorage.setItem(ACTIVE_CONVERSATION_ID_KEY, value);
       return;
     }

package/test/app/MessageContent.test.tsx

@@ -324,3 +324,45 @@ describe("MessageContent — XML action stripping", () => {
     expect(rendered).toBe("**Saturday**: Sunny and warm.");
   });
 });
+
+describe("XML tag stripping during streaming", () => {
+  it("strips <actions> blocks completely", () => {
+    const output = renderText(
+      'Hello world<actions><action name="test">do thing</action></actions>',
+    );
+    expect(output).toContain("Hello world");
+    expect(output).not.toContain("do thing");
+    expect(output).not.toContain("<actions>");
+  });
+
+  it("strips <think> blocks completely", () => {
+    const output = renderText(
+      "<think>internal reasoning about the query</think>Hello there!",
+    );
+    expect(output).toContain("Hello there!");
+    expect(output).not.toContain("internal reasoning");
+    expect(output).not.toContain("<think>");
+  });
+
+  it("extracts text from <response><text> wrapper", () => {
+    const output = renderText(
+      "<response><text>Hello world</text></response>",
+    );
+    expect(output).toContain("Hello world");
+    expect(output).not.toContain("<response>");
+    expect(output).not.toContain("<text>");
+  });
+
+  it("handles partial <response><text> during streaming (no closing tag yet)", () => {
+    const output = renderText("<response><text>Hello wor");
+    expect(output).toContain("Hello wor");
+  });
+
+  it("does not leak <actions> tag name as visible text", () => {
+    const output = renderText(
+      'Answer here<actions><action name="save">data</action></actions> done',
+    );
+    expect(output).not.toContain("actions");
+    expect(output).not.toContain("save");
+  });
+});

package/test/app/bug-report-modal.test.tsx

@@ -14,9 +14,9 @@ const { mockUseBugReport, mockClient } = vi.hoisted(() => ({
 }));
 
 vi.mock("@elizaos/app-core/hooks", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/hooks")>(
-    "@elizaos/app-core/hooks",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/hooks")
+  >("@elizaos/app-core/hooks");
   return {
     ...actual,
     useBugReport: () => mockUseBugReport(),

package/test/app/chat-view.test.tsx

@@ -73,9 +73,9 @@ vi.mock("@elizaos/app-core/platform", () => ({
 }));
 
 vi.mock("@elizaos/app-core/hooks", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/hooks")>(
-    "@elizaos/app-core/hooks",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/hooks")
+  >("@elizaos/app-core/hooks");
   return {
     ...actual,
     useVoiceChat: (...args: unknown[]) => mockUseVoiceChat(...args),

package/test/app/cloud-login-lock.test.ts

@@ -74,6 +74,7 @@ vi.mock("@elizaos/app-core/api", () => ({
   SkillScanReportSummary: {},
 }));
 
+import type { AppState } from "@elizaos/app-core/state";
 import { AppProvider, useApp } from "@elizaos/app-core/state";
 
 function createDeferred<T>() {
@@ -99,8 +100,8 @@ function Probe(props: { onReady: (api: ProbeApi) => void }) {
 
   useEffect(() => {
     onReady({
-      // biome-ignore lint/suspicious/noExplicitAny: test probe
-      setState: (key, value) => app.setState(key as any, value),
+      setState: (key, value) =>
+        app.setState(key as keyof AppState, value as AppState[keyof AppState]),
       handleOnboardingNext: app.handleOnboardingNext,
       handleOnboardingBack: app.handleOnboardingBack,
       handleCloudLogin: app.handleCloudLogin,

package/test/app/custom-actions-smoke.test.ts

@@ -29,9 +29,9 @@ vi.mock("@elizaos/app-core/platform", () => ({
 }));
 
 vi.mock("@elizaos/app-core/hooks", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/hooks")>(
-    "@elizaos/app-core/hooks",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/hooks")
+  >("@elizaos/app-core/hooks");
   return {
     ...actual,
     useVoiceChat: () => mockUseVoiceChat(),

package/test/app/onboarding-language.test.tsx

@@ -7,9 +7,9 @@ const { mockUseApp } = vi.hoisted(() => ({
 }));
 
 vi.mock("@elizaos/app-core/state", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/state")>(
-    "@elizaos/app-core/state",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/state")
+  >("@elizaos/app-core/state");
   return {
     ...actual,
     useApp: () => mockUseApp(),

package/test/app/pages-navigation-smoke.e2e.test.ts

@@ -35,9 +35,9 @@ const { companionOverlayTabs, mockUseApp, noop } = vi.hoisted(() => ({
 }));
 
 vi.mock("@elizaos/app-core/state", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/state")>(
-    "@elizaos/app-core/state",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/state")
+  >("@elizaos/app-core/state");
   return {
     ...actual,
     useApp: () => mockUseApp(),
@@ -269,9 +269,9 @@ vi.mock("../../../packages/app-core/src/components/LifoSandboxView", () => ({
     React.createElement("section", null, "LifoSandboxView Ready"),
 }));
 vi.mock("@elizaos/app-core/hooks", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/hooks")>(
-    "@elizaos/app-core/hooks",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/hooks")
+  >("@elizaos/app-core/hooks");
   return {
     ...actual,
     useContextMenu: () => ({
@@ -396,7 +396,9 @@ describe("pages navigation smoke (e2e)", () => {
       conversations: [],
       elizaCloudCredits: null,
       uiShellMode: "companion",
-      setUiShellMode: vi.fn(),
+      setUiShellMode: vi.fn((mode: "native" | "companion") => {
+        state.uiShellMode = mode;
+      }),
       uiLanguage: "en",
       agentStatus: { state: "running", agentName: "Milady" },
       loadDropStatus: vi.fn(),
@@ -587,7 +589,9 @@ describe("pages navigation smoke (e2e)", () => {
         conversations: [],
         elizaCloudCredits: null,
         uiShellMode: "companion",
-        setUiShellMode: vi.fn(),
+        setUiShellMode: vi.fn((mode: "native" | "companion") => {
+          state.uiShellMode = mode;
+        }),
         uiLanguage: "en",
         agentStatus: { state: "running", agentName: "Milady" },
         loadDropStatus: vi.fn(),
@@ -600,6 +604,7 @@ describe("pages navigation smoke (e2e)", () => {
         setActionNotice: vi.fn(),
         setTab: (tab: Tab) => {
           state.tab = tab;
+          state.uiShellMode = shellModeForTab(tab);
         },
       };
       Object.assign(state, entry.patch);

package/test/app/plugin-bridge.test.ts

@@ -2,7 +2,6 @@
 /**
  * Tests for plugin-bridge — capabilities detection and feature flags on web platform.
  */
-import { describe, expect, it, vi } from "vitest";
 
 import {
   getPluginCapabilities,
@@ -15,6 +14,7 @@ import {
   isWeb,
   platform,
 } from "@elizaos/app-core/bridge";
+import { describe, expect, it, vi } from "vitest";
 
 describe("plugin-bridge", () => {
   // -- Platform --

package/test/app/provider-dropdown-default.test.tsx

@@ -85,8 +85,7 @@ function defaultProps() {
 }
 
 function getSelectValue(tree: ReactTestRenderer): string | undefined {
-  // biome-ignore lint/suspicious/noExplicitAny: test introspection
-  const root = (tree as any).root;
+  const root = tree.root;
   const selects = root.findAll(
     (node: ReactTestInstance) =>
       node.type === "select" && node.props.value !== undefined,
@@ -95,8 +94,7 @@ function getSelectValue(tree: ReactTestRenderer): string | undefined {
 }
 
 function getSelect(tree: ReactTestRenderer): ReactTestInstance {
-  // biome-ignore lint/suspicious/noExplicitAny: test introspection
-  const root = (tree as any).root;
+  const root = tree.root;
   return root.find(
     (node: ReactTestInstance) =>
       node.type === "select" && node.props.value !== undefined,

package/test/app/restart-banner.test.tsx

@@ -14,9 +14,9 @@ interface RestartBannerContextStub {
 const mockUseApp = vi.fn<() => RestartBannerContextStub>();
 
 vi.mock("@elizaos/app-core/state", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/state")>(
-    "@elizaos/app-core/state",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/state")
+  >("@elizaos/app-core/state");
   return {
     ...actual,
     useApp: () => mockUseApp(),

package/test/app/shell-mode-switching.e2e.test.ts

@@ -49,9 +49,9 @@ vi.mock("@elizaos/app-core/platform", async () => {
 /* ── Mock every leaf component ────────────────────────────────────── */
 
 vi.mock("@elizaos/app-core/state", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/state")>(
-    "@elizaos/app-core/state",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/state")
+  >("@elizaos/app-core/state");
   return {
     ...actual,
     useApp: () => mockUseApp(),
@@ -308,9 +308,9 @@ vi.mock("../../../packages/app-core/src/components/LifoSandboxView", () => ({
 }));
 
 vi.mock("@elizaos/app-core/hooks", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/hooks")>(
-    "@elizaos/app-core/hooks",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/hooks")
+  >("@elizaos/app-core/hooks");
   return {
     ...actual,
     useContextMenu: () => ({

package/test/app/shell-mode-tab-memory.test.tsx

@@ -1,5 +1,5 @@
-import { describe, expect, it } from "vitest";
 import type { Tab } from "@elizaos/app-core/navigation";
+import { describe, expect, it } from "vitest";
 import {
   deriveUiShellModeForTab,
   getTabForShellView,

package/test/app/startup-chat.e2e.test.ts

@@ -11,9 +11,9 @@ const { mockUseApp } = vi.hoisted(() => ({
 }));
 
 vi.mock("@elizaos/app-core/state", async () => {
-  const actual = await vi.importActual<typeof import("@elizaos/app-core/state")>(
-    "@elizaos/app-core/state",
-  );
+  const actual = await vi.importActual<
+    typeof import("@elizaos/app-core/state")
+  >("@elizaos/app-core/state");
   return {
     ...actual,
     useApp: () => mockUseApp(),

package/test/app/triggers-view.e2e.test.ts

@@ -475,8 +475,9 @@ describe("TriggersView UI E2E", () => {
     runtimeHarness = createTriggerRuntimeHarness();
     server = await startApiServerFn({
       port: 0,
-      // biome-ignore lint/suspicious/noExplicitAny: test mock
-      runtime: runtimeHarness.runtime as any,
+      runtime: runtimeHarness.runtime as Parameters<
+        typeof startApiServerFn
+      >[0]["runtime"],
     });
   });
 

package/test/app/wallet-api-save-lock.test.ts

@@ -1,8 +1,9 @@
 // @vitest-environment jsdom
+
+import type { WalletConfigUpdateRequest } from "@elizaos/autonomous/contracts/wallet";
 import React, { useEffect } from "react";
 import TestRenderer, { act } from "react-test-renderer";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { WalletConfigUpdateRequest } from "@elizaos/autonomous/contracts/wallet";
 
 const { mockClient } = vi.hoisted(() => ({
   mockClient: {

package/test/utils/assistant-text.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { stripAssistantStageDirections } from "../../src/utils/assistant-text";
+
+describe("stripAssistantStageDirections", () => {
+  it("strips asterisk-wrapped stage directions", () => {
+    const result = stripAssistantStageDirections("Hello *smiles warmly* there");
+    expect(result).not.toContain("smiles warmly");
+    expect(result).toContain("Hello");
+    expect(result).toContain("there");
+  });
+
+  it("strips underscore-wrapped stage directions", () => {
+    const result = stripAssistantStageDirections("Hello _waves happily_ there");
+    expect(result).not.toContain("waves happily");
+  });
+
+  it("preserves asterisk content that is NOT a stage direction", () => {
+    const result = stripAssistantStageDirections("Use *bold text* for emphasis");
+    expect(result).toContain("bold text");
+  });
+
+  it("preserves underscore content that is NOT a stage direction", () => {
+    const result = stripAssistantStageDirections("Use _italic text_ for emphasis");
+    expect(result).toContain("italic text");
+  });
+
+  it("handles empty input", () => {
+    expect(stripAssistantStageDirections("")).toBe("");
+  });
+
+  it("handles text with no stage directions", () => {
+    expect(stripAssistantStageDirections("Just plain text")).toBe(
+      "Just plain text",
+    );
+  });
+
+  it("handles multiple stage directions in one message", () => {
+    const result = stripAssistantStageDirections(
+      "*nods* I agree. *smiles* That sounds right.",
+    );
+    expect(result).not.toContain("nods");
+    expect(result).not.toContain("smiles");
+    expect(result).toContain("I agree.");
+    expect(result).toContain("That sounds right.");
+  });
+
+  it("handles stage direction at start of text", () => {
+    const result = stripAssistantStageDirections("*laughs* That's funny!");
+    expect(result).not.toContain("laughs");
+    expect(result).toContain("That's funny!");
+  });
+
+  it("handles stage direction at end of text", () => {
+    const result = stripAssistantStageDirections("Goodbye! *waves*");
+    expect(result).not.toContain("waves");
+    expect(result).toContain("Goodbye!");
+  });
+
+  it("does not strip across newlines (asterisk pattern is non-greedy single line)", () => {
+    const input = "*smiles\nacross lines*";
+    const result = stripAssistantStageDirections(input);
+    expect(result).toContain("smiles");
+  });
+});

package/test/utils/streaming-text.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import {
+  mergeStreamingText,
+  computeStreamingDelta,
+} from "../../src/utils/streaming-text";
+
+describe("mergeStreamingText", () => {
+  it("returns incoming when it starts with existing (cumulative snapshot)", () => {
+    expect(mergeStreamingText("Hello", "Hello world")).toBe("Hello world");
+  });
+
+  it("returns incoming when existing is empty", () => {
+    expect(mergeStreamingText("", "Hello")).toBe("Hello");
+  });
+
+  it("returns existing when incoming is empty", () => {
+    expect(mergeStreamingText("Hello", "")).toBe("Hello");
+  });
+
+  it("returns existing when incoming equals existing", () => {
+    expect(mergeStreamingText("Hello", "Hello")).toBe("Hello");
+  });
+
+  it("keeps existing when incoming is a prefix (regressive snapshot)", () => {
+    expect(mergeStreamingText("Hello world", "Hello")).toBe("Hello world");
+  });
+
+  it("appends new portion when incoming overlaps existing suffix", () => {
+    expect(mergeStreamingText("Hello wor", "world")).toBe("Hello world");
+  });
+
+  it("appends single character even when it matches last char (repeated chars)", () => {
+    expect(mergeStreamingText("Hel", "l")).toBe("Hell");
+  });
+
+  it("builds up character by character correctly", () => {
+    let text = "";
+    for (const char of "Hello") {
+      text = mergeStreamingText(text, char);
+    }
+    expect(text).toBe("Hello");
+  });
+
+  it("drops suffix-only resend larger than 1 character", () => {
+    expect(mergeStreamingText("Hello world", "world")).toBe("Hello world");
+  });
+
+  it("replaces when incoming shares prefix >=8 chars but differs", () => {
+    expect(
+      mergeStreamingText(
+        "The quick brown fox jumps",
+        "The quick brown fox leaps",
+      ),
+    ).toBe("The quick brown fox leaps");
+  });
+
+  it("does not false-positive on short messages with natural overlap", () => {
+    expect(mergeStreamingText("Hi", "Hi there")).toBe("Hi there");
+  });
+
+  it("returns incoming when it contains existing as substring", () => {
+    expect(mergeStreamingText("Hello", "prefix Hello suffix")).toBe(
+      "prefix Hello suffix",
+    );
+  });
+
+  it("concatenates when no overlap detected and not a snapshot", () => {
+    expect(mergeStreamingText("abc", "xyz")).toBe("abcxyz");
+  });
+});
+
+describe("computeStreamingDelta", () => {
+  it("returns empty string when merge result equals existing", () => {
+    expect(computeStreamingDelta("Hello world", "Hello")).toBe("");
+  });
+
+  it("returns only the new portion for cumulative snapshots", () => {
+    expect(computeStreamingDelta("Hello", "Hello world")).toBe(" world");
+  });
+
+  it("returns incoming for snapshot replacements", () => {
+    expect(
+      computeStreamingDelta(
+        "The quick brown fox jumps",
+        "The quick brown fox leaps",
+      ),
+    ).toBe("The quick brown fox leaps");
+  });
+});