@elizaos/app-core 2.0.0-alpha.73 → 2.0.0-alpha.75

package/test/avatar/avatar-selector.test.ts

@@ -1,173 +0,0 @@
-/**
- * Tests for avatar selection logic — VRM index management, path resolution, localStorage persistence.
- */
-
-import {
-  getCompanionBackgroundUrl,
-  getVrmPreviewUrl,
-  getVrmTitle,
-  getVrmUrl,
-  VRM_COUNT,
-} from "@elizaos/app-core/state";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-describe("Avatar VRM Utilities", () => {
-  describe("VRM_COUNT", () => {
-    it("is 4 for all bundled base avatars", () => {
-      expect(VRM_COUNT).toBe(4);
-    });
-  });
-
-  describe("getVrmUrl", () => {
-    it("returns correct path for base eliza VRMs (1-4)", () => {
-      const expectedSourceIds = [1, 4, 5, 9];
-      expectedSourceIds.forEach((sourceId, index) => {
-        expect(getVrmUrl(index + 1)).toBe(`/vrms/eliza-${sourceId}.vrm.gz`);
-      });
-    });
-
-    it("clamps out-of-range indices to avatar 1", () => {
-      expect(getVrmUrl(5)).toBe("/vrms/eliza-1.vrm.gz");
-      expect(getVrmUrl(34)).toBe("/vrms/eliza-1.vrm.gz");
-      expect(getVrmUrl(-3)).toBe("/vrms/eliza-1.vrm.gz");
-      expect(getVrmUrl(Number.NaN)).toBe("/vrms/eliza-1.vrm.gz");
-      expect(getVrmUrl(0)).toBe("/vrms/eliza-1.vrm.gz");
-    });
-  });
-
-  describe("getVrmPreviewUrl", () => {
-    it("returns correct preview path for base VRMs (1-4)", () => {
-      const expectedSourceIds = [1, 4, 5, 9];
-      expectedSourceIds.forEach((sourceId, index) => {
-        expect(getVrmPreviewUrl(index + 1)).toBe(
-          `/vrms/previews/eliza-${sourceId}.png`,
-        );
-      });
-    });
-
-    it("clamps out-of-range preview indices to avatar 1", () => {
-      expect(getVrmPreviewUrl(5)).toBe("/vrms/previews/eliza-1.png");
-      expect(getVrmPreviewUrl(999)).toBe("/vrms/previews/eliza-1.png");
-      expect(getVrmPreviewUrl(-1)).toBe("/vrms/previews/eliza-1.png");
-      expect(getVrmPreviewUrl(0)).toBe("/vrms/previews/eliza-1.png");
-    });
-  });
-
-  describe("getVrmTitle", () => {
-    it("returns formatted title for base VRMs", () => {
-      expect(getVrmTitle(1)).toBe("ELIZA-01");
-      expect(getVrmTitle(2)).toBe("ELIZA-04");
-      expect(getVrmTitle(3)).toBe("ELIZA-05");
-      expect(getVrmTitle(4)).toBe("ELIZA-09");
-    });
-
-    it("clamps out-of-range index to avatar 1", () => {
-      expect(getVrmTitle(5)).toBe("ELIZA-01");
-    });
-  });
-
-  describe("getCompanionBackgroundUrl", () => {
-    it("stays within the bundled 4-avatar background set", () => {
-      expect(getCompanionBackgroundUrl("light")).toBe(
-        "/vrms/backgrounds/eliza-5.png",
-      );
-      expect(getCompanionBackgroundUrl("dark")).toBe(
-        "/vrms/backgrounds/eliza-9.png",
-      );
-    });
-  });
-});
-
-describe("Avatar Selection State", () => {
-  // Must match AVATAR_INDEX_KEY in AppContext.tsx
-  const AVATAR_STORAGE_KEY = "eliza_avatar_index";
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("localStorage persistence", () => {
-    it("stores selected VRM index", () => {
-      const mockStorage = new Map<string, string>();
-      const mockGetItem = vi.fn((key: string) => mockStorage.get(key) ?? null);
-      const mockSetItem = vi.fn((key: string, value: string) => {
-        mockStorage.set(key, value);
-      });
-
-      // Simulate saving avatar selection
-      mockSetItem(AVATAR_STORAGE_KEY, "3");
-      expect(mockStorage.get(AVATAR_STORAGE_KEY)).toBe("3");
-
-      // Simulate loading
-      const stored = mockGetItem(AVATAR_STORAGE_KEY);
-      expect(stored).toBe("3");
-      const index = Number(stored);
-      expect(index).toBe(3);
-      expect(index >= 1 && index <= VRM_COUNT).toBe(true);
-    });
-
-    it("handles custom VRM (index 0)", () => {
-      const mockStorage = new Map<string, string>();
-      mockStorage.set(AVATAR_STORAGE_KEY, "0");
-
-      const stored = mockStorage.get(AVATAR_STORAGE_KEY);
-      const index = Number(stored);
-      expect(index).toBe(0); // custom VRM
-    });
-
-    it("falls back to 1 for invalid stored values", () => {
-      const testCases = ["", "abc", "-1", "34", "NaN"];
-
-      for (const invalid of testCases) {
-        const n = Number(invalid);
-        const isValid = !Number.isNaN(n) && n >= 0 && n <= VRM_COUNT;
-        const result = isValid ? n : 1;
-        // Invalid cases should fall back to 1
-        if (!isValid) {
-          expect(result).toBe(1);
-        }
-      }
-    });
-  });
-});
-
-describe("Onboarding Avatar Step", () => {
-  it("avatar step comes after name and before style", () => {
-    const steps = [
-      "welcome",
-      "name",
-      "avatar",
-      "style",
-      "theme",
-      "runMode",
-      "llmProvider",
-      "inventorySetup",
-      "connectors",
-    ];
-
-    const nameIdx = steps.indexOf("name");
-    const avatarIdx = steps.indexOf("avatar");
-    const styleIdx = steps.indexOf("style");
-
-    expect(avatarIdx).toBe(nameIdx + 1);
-    expect(styleIdx).toBe(avatarIdx + 1);
-  });
-
-  it("avatar step is always valid (defaults to 1)", () => {
-    const onboardingAvatar = 1; // default
-    const canGoNext = true; // avatar step always allows next
-    expect(canGoNext).toBe(true);
-    expect(onboardingAvatar).toBeGreaterThanOrEqual(0);
-    expect(onboardingAvatar).toBeLessThanOrEqual(VRM_COUNT);
-  });
-
-  it("onboarding saves avatar to selectedVrmIndex on next", () => {
-    let selectedVrmIndex = 1;
-    const onboardingAvatar = 4;
-
-    // Simulate handleOnboardingNext for "avatar" step
-    selectedVrmIndex = onboardingAvatar;
-
-    expect(selectedVrmIndex).toBe(4);
-  });
-});

package/test/avatar/mixamo-vrm-rig-map.test.ts

@@ -1,111 +0,0 @@
-/**
- * Tests for mixamoVRMRigMap — Mixamo to VRM bone name mapping.
- */
-
-import { mixamoVRMRigMap } from "@elizaos/app-core/components/avatar/mixamoVRMRigMap";
-import { describe, expect, it } from "vitest";
-
-describe("mixamoVRMRigMap", () => {
-  it("contains all essential bone mappings", () => {
-    // Core spine chain
-    expect(mixamoVRMRigMap.mixamorigHips).toBe("hips");
-    expect(mixamoVRMRigMap.mixamorigSpine).toBe("spine");
-    expect(mixamoVRMRigMap.mixamorigSpine1).toBe("chest");
-    expect(mixamoVRMRigMap.mixamorigSpine2).toBe("upperChest");
-    expect(mixamoVRMRigMap.mixamorigNeck).toBe("neck");
-    expect(mixamoVRMRigMap.mixamorigHead).toBe("head");
-  });
-
-  it("maps left arm bones correctly", () => {
-    expect(mixamoVRMRigMap.mixamorigLeftShoulder).toBe("leftShoulder");
-    expect(mixamoVRMRigMap.mixamorigLeftArm).toBe("leftUpperArm");
-    expect(mixamoVRMRigMap.mixamorigLeftForeArm).toBe("leftLowerArm");
-    expect(mixamoVRMRigMap.mixamorigLeftHand).toBe("leftHand");
-  });
-
-  it("maps right arm bones correctly", () => {
-    expect(mixamoVRMRigMap.mixamorigRightShoulder).toBe("rightShoulder");
-    expect(mixamoVRMRigMap.mixamorigRightArm).toBe("rightUpperArm");
-    expect(mixamoVRMRigMap.mixamorigRightForeArm).toBe("rightLowerArm");
-    expect(mixamoVRMRigMap.mixamorigRightHand).toBe("rightHand");
-  });
-
-  it("maps left leg bones correctly", () => {
-    expect(mixamoVRMRigMap.mixamorigLeftUpLeg).toBe("leftUpperLeg");
-    expect(mixamoVRMRigMap.mixamorigLeftLeg).toBe("leftLowerLeg");
-    expect(mixamoVRMRigMap.mixamorigLeftFoot).toBe("leftFoot");
-    expect(mixamoVRMRigMap.mixamorigLeftToeBase).toBe("leftToes");
-  });
-
-  it("maps right leg bones correctly", () => {
-    expect(mixamoVRMRigMap.mixamorigRightUpLeg).toBe("rightUpperLeg");
-    expect(mixamoVRMRigMap.mixamorigRightLeg).toBe("rightLowerLeg");
-    expect(mixamoVRMRigMap.mixamorigRightFoot).toBe("rightFoot");
-    expect(mixamoVRMRigMap.mixamorigRightToeBase).toBe("rightToes");
-  });
-
-  it("has symmetric arm mappings (left/right)", () => {
-    const leftArm = [
-      "mixamorigLeftShoulder",
-      "mixamorigLeftArm",
-      "mixamorigLeftForeArm",
-      "mixamorigLeftHand",
-    ];
-    const rightArm = [
-      "mixamorigRightShoulder",
-      "mixamorigRightArm",
-      "mixamorigRightForeArm",
-      "mixamorigRightHand",
-    ] as const;
-
-    for (const [index, leftKey] of leftArm.entries()) {
-      const leftBone = mixamoVRMRigMap[leftKey];
-      const rightBone = mixamoVRMRigMap[rightArm[index]];
-      expect(leftBone).toBeDefined();
-      expect(rightBone).toBeDefined();
-      // Left bone name should have "left", right should have "right"
-      expect(leftBone?.toLowerCase()).toContain("left");
-      expect(rightBone?.toLowerCase()).toContain("right");
-    }
-  });
-
-  it("has symmetric leg mappings (left/right)", () => {
-    const leftLeg = [
-      "mixamorigLeftUpLeg",
-      "mixamorigLeftLeg",
-      "mixamorigLeftFoot",
-      "mixamorigLeftToeBase",
-    ];
-    const rightLeg = [
-      "mixamorigRightUpLeg",
-      "mixamorigRightLeg",
-      "mixamorigRightFoot",
-      "mixamorigRightToeBase",
-    ] as const;
-
-    for (const [index, leftKey] of leftLeg.entries()) {
-      const leftBone = mixamoVRMRigMap[leftKey];
-      const rightBone = mixamoVRMRigMap[rightLeg[index]];
-      expect(leftBone).toBeDefined();
-      expect(rightBone).toBeDefined();
-      expect(leftBone?.toLowerCase()).toContain("left");
-      expect(rightBone?.toLowerCase()).toContain("right");
-    }
-  });
-
-  it("maps all standard bones (at least 22 entries)", () => {
-    const keys = Object.keys(mixamoVRMRigMap);
-    // 6 spine/head + 4*2 arms + 4*2 legs = 22
-    expect(keys.length).toBeGreaterThanOrEqual(22);
-  });
-
-  it("all values are valid VRM bone names (lowercase camelCase)", () => {
-    for (const [key, value] of Object.entries(mixamoVRMRigMap)) {
-      expect(value).toBeTruthy();
-      // VRM bone names are camelCase (start lowercase)
-      expect(value[0]).toBe(value[0]?.toLowerCase());
-      // Keys should start with "mixamorig"
-      expect(key.startsWith("mixamorig")).toBe(true);
-    }
-  });
-});

package/test/avatar/voice-chat-streaming-text.test.ts

@@ -1,96 +0,0 @@
-import { __voiceChatInternals } from "@elizaos/app-core/hooks";
-import { describe, expect, it } from "vitest";
-
-const {
-  remainderAfter,
-  queueableSpeechPrefix,
-  resolveEffectiveVoiceConfig,
-  toSpeakableText,
-} = __voiceChatInternals;
-
-describe("useVoiceChat streaming text helpers", () => {
-  it("returns only unseen suffix text when remainder grows", () => {
-    expect(remainderAfter("alpha beta gamma", "alpha beta")).toBe("gamma");
-  });
-
-  it("does not replay full text when prefix matching fails", () => {
-    expect(
-      remainderAfter("canonical final response", "first streamed sentence."),
-    ).toBe("");
-  });
-
-  it("queues only complete sentences before the final chunk", () => {
-    expect(
-      queueableSpeechPrefix(
-        "second sentence done. third sentence still streaming",
-        false,
-      ),
-    ).toBe("second sentence done.");
-  });
-
-  it("flushes all remaining text on the final chunk", () => {
-    expect(
-      queueableSpeechPrefix(
-        "second sentence done. third sentence still streaming",
-        true,
-      ),
-    ).toBe("second sentence done. third sentence still streaming");
-  });
-
-  it("falls back to a chunk for long text without punctuation", () => {
-    const longText = [
-      "this stream has no punctuation and keeps going with useful words",
-      "so the speaker should not remain silent forever while waiting",
-      "for a sentence boundary that never arrives during generation",
-    ].join(" ");
-
-    const queued = queueableSpeechPrefix(longText, false);
-    expect(queued.length).toBeGreaterThan(80);
-    expect(queued.length).toBeLessThan(longText.length);
-  });
-
-  it("defaults to ElevenLabs cloud config when Cloud auth is present", () => {
-    expect(
-      resolveEffectiveVoiceConfig(null, {
-        cloudConnected: true,
-      }),
-    ).toEqual({
-      provider: "elevenlabs",
-      mode: "cloud",
-      elevenlabs: {
-        voiceId: "EXAVITQu4vr4xnSDxMaL",
-        modelId: "eleven_flash_v2_5",
-        stability: 0.5,
-        similarityBoost: 0.75,
-        speed: 1,
-      },
-    });
-  });
-
-  it("keeps explicit non-ElevenLabs providers intact", () => {
-    expect(
-      resolveEffectiveVoiceConfig(
-        {
-          provider: "edge",
-          edge: { voice: "en-US-AriaNeural" },
-        },
-        { cloudConnected: true },
-      ),
-    ).toEqual({
-      provider: "edge",
-      edge: { voice: "en-US-AriaNeural" },
-    });
-  });
-
-  it("drops parenthetical asides and stage directions from speech", () => {
-    expect(
-      toSpeakableText(
-        "Hello there (with extra context). *curtsies* Visit https://example.com now.",
-      ),
-    ).toBe("Hello there. Visit now.");
-  });
-
-  it("returns empty text when only stage directions remain", () => {
-    expect(toSpeakableText("*waves* (quietly) [off mic]")).toBe("");
-  });
-});