@elizaos/app-core 2.0.0-alpha.74 → 2.0.0-alpha.76

package/test/app/chat-language-header.test.ts

@@ -1,64 +0,0 @@
-import { ElizaClient } from "@elizaos/app-core/api";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-function buildSseDoneResponse(): Response {
-  const encoder = new TextEncoder();
-  const body = new ReadableStream<Uint8Array>({
-    start(controller) {
-      controller.enqueue(
-        encoder.encode(
-          'data: {"type":"done","fullText":"ok","agentName":"Eliza"}\n\n',
-        ),
-      );
-      controller.close();
-    },
-  });
-  return new Response(body, {
-    status: 200,
-    headers: { "Content-Type": "text/event-stream" },
-  });
-}
-
-describe("ElizaClient language header propagation", () => {
-  const originalFetch = globalThis.fetch;
-  let fetchMock: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    fetchMock = vi.fn();
-    globalThis.fetch = fetchMock as typeof globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  it("adds X-Eliza-UI-Language to normal chat requests", async () => {
-    fetchMock.mockResolvedValueOnce(
-      new Response(JSON.stringify({ text: "ok", agentName: "Eliza" }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      }),
-    );
-
-    const client = new ElizaClient("http://localhost:2138", "token");
-    client.setUiLanguage("zh-CN");
-    await client.sendChatRest("hello");
-
-    const init = fetchMock.mock.calls[0][1] as RequestInit;
-    const headers = new Headers(init.headers as HeadersInit);
-    expect(headers.get("X-Eliza-UI-Language")).toBe("zh-CN");
-  });
-
-  it("adds X-Eliza-UI-Language to streaming chat requests", async () => {
-    fetchMock.mockResolvedValueOnce(buildSseDoneResponse());
-
-    const client = new ElizaClient("http://localhost:2138");
-    client.setUiLanguage("zh-CN");
-    await client.sendConversationMessageStream("conv-1", "hello", () => {});
-
-    const init = fetchMock.mock.calls[0][1] as RequestInit;
-    const headers = new Headers(init.headers as HeadersInit);
-    expect(headers.get("X-Eliza-UI-Language")).toBe("zh-CN");
-    expect(headers.get("Accept")).toBe("text/event-stream");
-  });
-});

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

@@ -1,222 +0,0 @@
-// @vitest-environment jsdom
-
-import React from "react";
-import TestRenderer, { act } from "react-test-renderer";
-import { describe, expect, it, vi } from "vitest";
-
-const { mockUseApp } = vi.hoisted(() => ({
-  mockUseApp: vi.fn(),
-}));
-
-vi.mock("@elizaos/app-core/state", () => ({
-  useApp: () => mockUseApp(),
-}));
-
-vi.mock("../../src/components/MessageContent", () => ({
-  MessageContent: ({ message }: { message: { text: string } }) =>
-    React.createElement("span", null, message.text),
-}));
-
-import { ChatMessage } from "../../src/components/ChatMessage";
-
-describe("ChatMessage actions", () => {
-  it("reveals assistant actions on tap when hover is unavailable", async () => {
-    Object.defineProperty(window, "matchMedia", {
-      writable: true,
-      configurable: true,
-      value: vi.fn().mockImplementation(() => ({
-        matches: false,
-        addEventListener: vi.fn(),
-        removeEventListener: vi.fn(),
-        addListener: vi.fn(),
-        removeListener: vi.fn(),
-      })),
-    });
-    mockUseApp.mockReturnValue({
-      copyToClipboard: vi.fn(),
-      t: (key: string) => key,
-    });
-
-    let tree!: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(ChatMessage, {
-          message: {
-            id: "assistant-1",
-            role: "assistant",
-            text: "hello there",
-            timestamp: 1,
-          },
-          onSpeak: vi.fn(),
-        }),
-      );
-    });
-
-    const actionButtonsBeforeTap = tree.root.findAll(
-      (node) =>
-        node.type === "button" && node.props["aria-label"] === "Copy message",
-    );
-    expect(actionButtonsBeforeTap).toHaveLength(1);
-    expect(
-      tree.root.findAll(
-        (node) =>
-          typeof node.props.className === "string" &&
-          node.props.className.includes("pointer-events-none opacity-0"),
-      ),
-    ).toHaveLength(1);
-
-    await act(async () => {
-      tree.root
-        .findByProps({ "data-testid": "chat-message" })
-        .props.onTouchEnd({
-          target: {
-            closest: () => null,
-          },
-        });
-    });
-
-    tree.root.findByProps({ "aria-label": "Copy message" });
-    expect(
-      tree.root.findAll(
-        (node) =>
-          typeof node.props.className === "string" &&
-          node.props.className.includes("opacity-100"),
-      ).length,
-    ).toBeGreaterThan(0);
-    expect(
-      tree.root.findByProps({ "aria-label": "Play message" }),
-    ).toBeDefined();
-  });
-
-  it("renders copy and play actions for assistant messages", async () => {
-    mockUseApp.mockReturnValue({
-      copyToClipboard: vi.fn(),
-      t: (key: string) => key,
-    });
-
-    let tree!: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(ChatMessage, {
-          message: {
-            id: "assistant-1",
-            role: "assistant",
-            text: "hello there",
-            timestamp: 1,
-          },
-          onSpeak: vi.fn(),
-        }),
-      );
-    });
-
-    expect(
-      tree.root.findByProps({ "aria-label": "Copy message" }),
-    ).toBeDefined();
-    expect(
-      tree.root.findByProps({ "aria-label": "Play message" }),
-    ).toBeDefined();
-  });
-
-  it("plays assistant messages from the message action button", async () => {
-    mockUseApp.mockReturnValue({
-      copyToClipboard: vi.fn(),
-      t: (key: string) => key,
-    });
-    const onSpeak = vi.fn();
-
-    let tree!: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(ChatMessage, {
-          message: {
-            id: "assistant-1",
-            role: "assistant",
-            text: "hello there",
-            timestamp: 1,
-          },
-          onSpeak,
-        }),
-      );
-    });
-
-    const playButton = tree.root.findByProps({ "aria-label": "Play message" });
-    await act(async () => {
-      playButton.props.onClick();
-    });
-
-    expect(onSpeak).toHaveBeenCalledWith("assistant-1", "hello there");
-  });
-
-  it("edits and resends user messages from the inline editor", async () => {
-    mockUseApp.mockReturnValue({
-      copyToClipboard: vi.fn(),
-      t: (key: string) => key,
-    });
-    const onEdit = vi.fn(async () => true);
-
-    let tree!: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(ChatMessage, {
-          message: {
-            id: "user-1",
-            role: "user",
-            text: "old text",
-            timestamp: 1,
-          },
-          onEdit,
-        }),
-      );
-    });
-
-    const editButton = tree.root.findByProps({ "aria-label": "Edit message" });
-    await act(async () => {
-      editButton.props.onClick();
-    });
-
-    const textarea = tree.root.findByProps({ "aria-label": "Edit message" });
-    await act(async () => {
-      textarea.props.onChange({ target: { value: "edited text" } });
-    });
-
-    const saveButton = tree.root
-      .findAllByType("button")
-      .find((button) =>
-        button.children.some((child) => child === "Save and resend"),
-      );
-    expect(saveButton).toBeDefined();
-
-    await act(async () => {
-      saveButton?.props.onClick();
-    });
-
-    expect(onEdit).toHaveBeenCalledWith("user-1", "edited text");
-  });
-
-  it("does not render a retry action for interrupted assistant messages", async () => {
-    mockUseApp.mockReturnValue({
-      copyToClipboard: vi.fn(),
-      t: (key: string) => key,
-    });
-
-    let tree!: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(ChatMessage, {
-          message: {
-            id: "assistant-1",
-            role: "assistant",
-            text: "partial",
-            interrupted: true,
-            timestamp: 1,
-          },
-          onSpeak: vi.fn(),
-        }),
-      );
-    });
-
-    expect(
-      tree.root.findAllByProps({ "aria-label": "Retry message" }),
-    ).toHaveLength(0);
-  });
-});

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

@@ -1,191 +0,0 @@
-import React from "react";
-import TestRenderer, { act } from "react-test-renderer";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const { mockUseApp } = vi.hoisted(() => ({
-  mockUseApp: vi.fn(),
-}));
-
-const {
-  mockGetAgentAutomationMode,
-  mockSetAgentAutomationMode,
-  mockGetTradePermissionMode,
-  mockSetTradePermissionMode,
-} = vi.hoisted(() => ({
-  mockGetAgentAutomationMode: vi.fn(),
-  mockSetAgentAutomationMode: vi.fn(),
-  mockGetTradePermissionMode: vi.fn(),
-  mockSetTradePermissionMode: vi.fn(),
-}));
-
-vi.mock("@elizaos/app-core/state", () => ({
-  useApp: () => mockUseApp(),
-}));
-
-vi.mock("../../src/components/ChatView.js", () => ({
-  ChatView: () => React.createElement("section", null, "ChatView Ready"),
-}));
-
-vi.mock("../../src/components/ConversationsSidebar.js", () => ({
-  ConversationsSidebar: () =>
-    React.createElement("aside", null, "ConversationsSidebar Ready"),
-}));
-
-vi.mock("@elizaos/app-core/api", () => ({
-  client: {
-    getAgentAutomationMode: mockGetAgentAutomationMode,
-    setAgentAutomationMode: mockSetAgentAutomationMode,
-    getTradePermissionMode: mockGetTradePermissionMode,
-    setTradePermissionMode: mockSetTradePermissionMode,
-  },
-}));
-
-import { ChatModalView } from "../../src/components/ChatModalView";
-
-function createContext() {
-  return {
-    t: (k: string) => k,
-    conversations: [
-      {
-        id: "conv-1",
-        title: "General",
-        roomId: "room-1",
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-      },
-    ],
-    activeConversationId: "conv-1",
-    onboardingLoading: false,
-    startupPhase: "ready",
-    conversationMessages: [],
-    chatSending: false,
-    handleNewConversation: vi.fn(async () => {}),
-    handleChatClear: vi.fn(async () => {}),
-    setActionNotice: vi.fn(),
-    setTab: vi.fn(),
-    uiLanguage: "en",
-  };
-}
-
-function textOf(node: TestRenderer.ReactTestInstance): string {
-  return node.children
-    .map((child) => (typeof child === "string" ? child : textOf(child)))
-    .join("");
-}
-
-describe("ChatModalView", () => {
-  beforeEach(() => {
-    mockUseApp.mockReset();
-    mockGetAgentAutomationMode.mockReset();
-    mockSetAgentAutomationMode.mockReset();
-    mockGetTradePermissionMode.mockReset();
-    mockSetTradePermissionMode.mockReset();
-    mockGetAgentAutomationMode.mockResolvedValue({
-      mode: "connectors-only",
-      options: ["connectors-only", "full"],
-    });
-    mockSetAgentAutomationMode.mockImplementation(async (mode) => ({
-      mode,
-      options: ["connectors-only", "full"],
-    }));
-    mockGetTradePermissionMode.mockResolvedValue({
-      mode: "user-sign-only",
-      options: ["user-sign-only", "manual-local-key", "agent-auto"],
-    });
-    mockSetTradePermissionMode.mockImplementation(async (mode) => ({
-      mode,
-      options: ["user-sign-only", "manual-local-key", "agent-auto"],
-    }));
-    mockUseApp.mockReturnValue(createContext());
-  });
-
-  it("renders full overlay layout by default", async () => {
-    let tree: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(React.createElement(ChatModalView));
-    });
-
-    const overlays = tree?.root.findAll(
-      (node) => node.props["data-chat-game-overlay"] === true,
-    );
-    expect(overlays.length).toBe(1);
-
-    const shells = tree?.root.findAll(
-      (node) => node.props["data-chat-game-shell"] === true,
-    );
-    expect(shells.length).toBe(1);
-
-    const content = textOf(tree?.root);
-    expect(content).toContain("ChatView Ready");
-    expect(content).toContain("ConversationsSidebar Ready");
-  });
-
-  it("renders companion dock layout", async () => {
-    let tree: TestRenderer.ReactTestRenderer;
-    await act(async () => {
-      tree = TestRenderer.create(
-        React.createElement(ChatModalView, {
-          variant: "companion-dock",
-        }),
-      );
-    });
-
-    const docks = tree?.root.findAll(
-      (node) => node.props["data-chat-game-dock"] === true,
-    );
-    expect(docks.length).toBe(1);
-
-    const overlays = tree?.root.findAll(
-      (node) => node.props["data-chat-game-overlay"] === true,
-    );
-    expect(overlays.length).toBe(0);
-
-    const shell = tree?.root.find(
-      (node) => node.props["data-chat-game-shell"] === true,
-    );
-    const thread = tree?.root.find(
-      (node) => node.props["data-chat-game-thread"] === true,
-    );
-    expect(String(shell.props.className)).toContain("overflow-visible");
-    expect(String(thread.props.className)).toContain("overflow-visible");
-  });
-
-  it("does not boot a new conversation in companion dock when none is active", async () => {
-    const handleNewConversation = vi.fn(async () => {});
-    mockUseApp.mockReturnValue({
-      ...createContext(),
-      activeConversationId: null,
-      handleNewConversation,
-    });
-
-    await act(async () => {
-      TestRenderer.create(
-        React.createElement(ChatModalView, {
-          variant: "companion-dock",
-        }),
-      );
-    });
-
-    expect(handleNewConversation).not.toHaveBeenCalled();
-  });
-
-  it("does not boot a new conversation before startup restore finishes", async () => {
-    const handleNewConversation = vi.fn(async () => {});
-    mockUseApp.mockReturnValue({
-      ...createContext(),
-      activeConversationId: null,
-      onboardingLoading: true,
-      handleNewConversation,
-    });
-
-    await act(async () => {
-      TestRenderer.create(
-        React.createElement(ChatModalView, {
-          variant: "companion-dock",
-        }),
-      );
-    });
-
-    expect(handleNewConversation).not.toHaveBeenCalled();
-  });
-});

package/test/app/chat-routine-filter.test.ts

@@ -1,96 +0,0 @@
-import { isRoutineCodingAgentMessage } from "@elizaos/app-core/chat";
-import { describe, expect, it } from "vitest";
-
-describe("isRoutineCodingAgentMessage", () => {
-  const routine = (text: string) => ({
-    source: "coding-agent" as const,
-    text,
-  });
-  const other = (text: string) => ({ text });
-
-  it("filters auto-approval messages", () => {
-    expect(
-      isRoutineCodingAgentMessage(
-        routine(
-          "[my-task] Approved: Accept trust prompt for working directory",
-        ),
-      ),
-    ).toBe(true);
-  });
-
-  it("filters responded messages", () => {
-    expect(
-      isRoutineCodingAgentMessage(
-        routine("[my-task] Responded: yes — reasoning here"),
-      ),
-    ).toBe(true);
-  });
-
-  it("filters sent keys messages", () => {
-    expect(
-      isRoutineCodingAgentMessage(routine("[my-task] Sent keys: enter, down")),
-    ).toBe(true);
-  });
-
-  it("filters turn done messages", () => {
-    expect(
-      isRoutineCodingAgentMessage(
-        routine("[my-task] Turn done, continuing: implement the feature..."),
-      ),
-    ).toBe(true);
-  });
-
-  it("filters idle nudge messages", () => {
-    expect(
-      isRoutineCodingAgentMessage(
-        routine("[my-task] Idle for 3m — Nudged: are you still working?"),
-      ),
-    ).toBe(true);
-  });
-
-  it("keeps completion messages", () => {
-    expect(
-      isRoutineCodingAgentMessage(
-        routine('Finished "my-task".\n\nImplemented the guestbook feature.'),
-      ),
-    ).toBe(false);
-  });
-
-  it("keeps all-done summary", () => {
-    expect(
-      isRoutineCodingAgentMessage(
-        routine(
-          "All 3 coding agents finished (2 completed, 1 errored). Review their work when you're ready.",
-        ),
-      ),
-    ).toBe(false);
-  });
-
-  it("keeps escalation messages", () => {
-    expect(
-      isRoutineCodingAgentMessage(
-        routine("[my-task] Needs your attention: tests are failing"),
-      ),
-    ).toBe(false);
-  });
-
-  it("keeps error messages", () => {
-    expect(
-      isRoutineCodingAgentMessage(
-        routine('"my-task" hit an error: process exited'),
-      ),
-    ).toBe(false);
-  });
-
-  it("ignores non-coding-agent sources", () => {
-    expect(
-      isRoutineCodingAgentMessage(other("[my-task] Approved: something")),
-    ).toBe(false);
-  });
-
-  it("ignores messages without source", () => {
-    expect(
-      isRoutineCodingAgentMessage({ text: "[my-task] Approved: something" }),
-    ).toBe(false);
-  });
-});