@elizaos/agent 2.0.0-alpha.354 → 2.0.0-alpha.376

package/apps/app-companion/src/character-catalog.d.ts

@@ -0,0 +1,10 @@
+import { type ResolvedCharacterAsset, type ResolvedInjectedCharacter } from "@elizaos/app-core";
+export declare function getCharacterAssets(): ResolvedCharacterAsset[];
+export declare const ELIZA_CHARACTER_ASSET_COUNT = 0;
+export declare const DEFAULT_ELIZA_CHARACTER_ASSET: ResolvedCharacterAsset | null;
+export declare const DEFAULT_MILADY_CHARACTER_ASSET: ResolvedCharacterAsset;
+export declare function getCharacterAsset(id: number): ResolvedCharacterAsset | null;
+export declare function getInjectedCharacters(): ResolvedInjectedCharacter[];
+export declare const ELIZA_INJECTED_CHARACTER_COUNT = 0;
+export declare function getInjectedCharacter(catchphrase: string): ResolvedInjectedCharacter | null;
+//# sourceMappingURL=character-catalog.d.ts.map

package/apps/app-companion/src/character-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-catalog.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-companion/src/character-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAE/B,MAAM,mBAAmB,CAAC;AAkB3B,wBAAgB,kBAAkB,IAAI,sBAAsB,EAAE,CAE7D;AAED,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,eAAO,MAAM,6BAA6B,EAAE,sBAAsB,GAAG,IAC/D,CAAC;AAEP,eAAO,MAAM,8BAA8B,wBAAgC,CAAC;AAE5E,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAE3E;AAED,wBAAgB,qBAAqB,IAAI,yBAAyB,EAAE,CAEnE;AAED,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CAElC"}

package/apps/app-companion/src/character-catalog.js

@@ -0,0 +1,32 @@
+import { getBootConfig, resolveCharacterCatalog, } from "@elizaos/app-core";
+function getResolved() {
+    const catalog = getBootConfig().characterCatalog;
+    if (!catalog) {
+        return {
+            assets: [],
+            assetCount: 0,
+            defaultAsset: null,
+            injectedCharacters: [],
+            injectedCharacterCount: 0,
+            getAsset: () => null,
+            getInjectedCharacter: () => null,
+        };
+    }
+    return resolveCharacterCatalog(catalog);
+}
+export function getCharacterAssets() {
+    return getResolved().assets;
+}
+export const ELIZA_CHARACTER_ASSET_COUNT = 0;
+export const DEFAULT_ELIZA_CHARACTER_ASSET = null;
+export const DEFAULT_MILADY_CHARACTER_ASSET = DEFAULT_ELIZA_CHARACTER_ASSET;
+export function getCharacterAsset(id) {
+    return getResolved().getAsset(id);
+}
+export function getInjectedCharacters() {
+    return getResolved().injectedCharacters;
+}
+export const ELIZA_INJECTED_CHARACTER_COUNT = 0;
+export function getInjectedCharacter(catchphrase) {
+    return getResolved().getInjectedCharacter(catchphrase);
+}

package/apps/app-companion/src/components/avatar/MathEnvironment.d.ts

@@ -0,0 +1,38 @@
+/**
+ * MathEnvironment — Matrix Construct-style Three.js background scene.
+ *
+ * Light mode: white void with faint receding grid and translucent screen
+ * panels — the loading construct from The Matrix.
+ *
+ * Dark mode: dark void with purple/neon-green grid and glowing screens
+ * — cyberpunk matrix terminal aesthetic.
+ *
+ * No external models or textures — everything is procedural geometry.
+ */
+import * as THREE from "three";
+export declare class MathEnvironment {
+    private group;
+    private gridHelper;
+    private gridMaterial;
+    private gridCenterMaterial;
+    private fog;
+    private screens;
+    private screenMaterials;
+    private borderMeshes;
+    private borderMaterials;
+    private scanLineMeshes;
+    private scanLineMaterials;
+    private elapsedTime;
+    private theme;
+    private sceneRef;
+    /** Build and attach the environment to the given scene. */
+    build(scene: THREE.Scene, theme: "light" | "dark"): void;
+    private buildScreens;
+    /** Per-frame update — call from the render loop. */
+    update(deltaTime: number, _camera: THREE.Camera): void;
+    /** Switch theme without rebuilding. */
+    setTheme(theme: "light" | "dark"): void;
+    /** Dispose all Three.js objects. */
+    dispose(): void;
+}
+//# sourceMappingURL=MathEnvironment.d.ts.map

package/apps/app-companion/src/components/avatar/MathEnvironment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MathEnvironment.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-companion/src/components/avatar/MathEnvironment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAqE/B,qBAAa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,UAAU,CAAiC;IACnD,OAAO,CAAC,YAAY,CAAwC;IAC5D,OAAO,CAAC,kBAAkB,CAAwC;IAClE,OAAO,CAAC,GAAG,CAA8B;IACzC,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,eAAe,CAAoC;IAC3D,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,cAAc,CAAoB;IAC1C,OAAO,CAAC,iBAAiB,CAAiC;IAC1D,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,QAAQ,CAA4B;IAE5C,2DAA2D;IAC3D,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI;IAgDxD,OAAO,CAAC,YAAY;IA6DpB,oDAAoD;IACpD,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI;IA0CtD,uCAAuC;IACvC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI;IA0CvC,oCAAoC;IACpC,OAAO,IAAI,IAAI;CAyChB"}

package/apps/app-companion/src/components/avatar/MathEnvironment.js

@@ -0,0 +1,295 @@
+/**
+ * MathEnvironment — Matrix Construct-style Three.js background scene.
+ *
+ * Light mode: white void with faint receding grid and translucent screen
+ * panels — the loading construct from The Matrix.
+ *
+ * Dark mode: dark void with purple/neon-green grid and glowing screens
+ * — cyberpunk matrix terminal aesthetic.
+ *
+ * No external models or textures — everything is procedural geometry.
+ */
+import * as THREE from "three";
+const GRID_SIZE = 60;
+const GRID_DIVISIONS = 60;
+const GRID_Y = -0.75;
+/** Screen panel definitions — varied sizes and positions for visual depth. */
+const SCREEN_DEFS = [
+    // Back wall — large screens
+    { width: 1.8, height: 1.2, x: -3.2, y: 1.8, z: -5.5 },
+    { width: 2.0, height: 1.4, x: 0.5, y: 2.2, z: -6.0 },
+    { width: 1.6, height: 1.0, x: 3.8, y: 1.5, z: -5.2 },
+    // Upper floating
+    { width: 1.2, height: 0.8, x: -1.5, y: 3.0, z: -4.5, rotY: 0.15 },
+    { width: 1.0, height: 0.7, x: 2.2, y: 3.2, z: -4.0, rotY: -0.2 },
+    // Side screens — angled inward
+    { width: 1.4, height: 0.9, x: -5.0, y: 1.2, z: -2.5, rotY: 0.7 },
+    { width: 1.2, height: 0.8, x: -4.5, y: 2.4, z: -1.0, rotY: 0.8 },
+    { width: 1.4, height: 0.9, x: 5.0, y: 1.4, z: -2.5, rotY: -0.7 },
+    { width: 1.0, height: 0.7, x: 4.8, y: 2.6, z: -0.8, rotY: -0.85 },
+    // Lower / near screens
+    { width: 0.9, height: 0.6, x: -2.8, y: 0.4, z: -3.8, rotY: 0.3 },
+    { width: 0.8, height: 0.55, x: 3.0, y: 0.5, z: -3.5, rotY: -0.25 },
+    // Far scattered
+    { width: 1.6, height: 1.1, x: -1.0, y: 1.0, z: -7.5 },
+    { width: 1.3, height: 0.9, x: 2.5, y: 1.8, z: -8.0, rotY: -0.1 },
+];
+const THEME_LIGHT = {
+    fogColor: 0xf5f5f5,
+    fogDensity: 0.045,
+    gridColor: new THREE.Color(0.82, 0.84, 0.86),
+    gridCenterColor: new THREE.Color(0.7, 0.75, 0.8),
+    gridOpacity: 0.2,
+    gridCenterOpacity: 0.25,
+    screenEmissive: new THREE.Color(0.55, 0.75, 0.9),
+    screenBaseColor: new THREE.Color(0.92, 0.94, 0.96),
+    screenBorderColor: new THREE.Color(0.7, 0.72, 0.75),
+    screenOpacity: 0.35,
+    screenEmissiveIntensity: 0.25,
+    scanBaseOpacity: 0.15,
+    bgColor: 0xf5f5f5,
+};
+const THEME_DARK = {
+    fogColor: 0x08060e,
+    fogDensity: 0.035,
+    gridColor: new THREE.Color(0.18, 0.06, 0.3),
+    gridCenterColor: new THREE.Color(0.3, 0.1, 0.55),
+    gridOpacity: 0.45,
+    gridCenterOpacity: 0.55,
+    screenEmissive: new THREE.Color(0.1, 0.95, 0.4),
+    screenBaseColor: new THREE.Color(0.04, 0.06, 0.1),
+    screenBorderColor: new THREE.Color(0.25, 0.8, 0.35),
+    screenOpacity: 0.3,
+    screenEmissiveIntensity: 0.6,
+    scanBaseOpacity: 0.35,
+    bgColor: 0x08060e,
+};
+export class MathEnvironment {
+    group = new THREE.Group();
+    gridHelper = null;
+    gridMaterial = null;
+    gridCenterMaterial = null;
+    fog = null;
+    screens = [];
+    screenMaterials = [];
+    borderMeshes = [];
+    borderMaterials = [];
+    scanLineMeshes = [];
+    scanLineMaterials = [];
+    elapsedTime = 0;
+    theme = "dark";
+    sceneRef = null;
+    /** Build and attach the environment to the given scene. */
+    build(scene, theme) {
+        this.theme = theme;
+        this.sceneRef = scene;
+        const config = theme === "light" ? THEME_LIGHT : THEME_DARK;
+        this.group.name = "MathEnvironment";
+        // White fog — everything fades to white at distance
+        this.fog = new THREE.FogExp2(config.fogColor, config.fogDensity);
+        scene.fog = this.fog;
+        scene.background = new THREE.Color(config.bgColor);
+        // Grid floor — faint in light mode, neon in dark mode
+        this.gridMaterial = new THREE.LineBasicMaterial({
+            color: config.gridColor,
+            transparent: true,
+            opacity: config.gridOpacity,
+            depthWrite: false,
+        });
+        this.gridCenterMaterial = new THREE.LineBasicMaterial({
+            color: config.gridCenterColor,
+            transparent: true,
+            opacity: config.gridCenterOpacity,
+            depthWrite: false,
+        });
+        this.gridHelper = new THREE.GridHelper(GRID_SIZE, GRID_DIVISIONS, config.gridCenterColor, config.gridColor);
+        this.gridHelper.position.y = GRID_Y;
+        const gridMats = this.gridHelper.material;
+        if (Array.isArray(gridMats)) {
+            for (const m of gridMats) {
+                m.transparent = true;
+                m.opacity = config.gridOpacity;
+                m.depthWrite = false;
+            }
+        }
+        this.group.add(this.gridHelper);
+        // Floating screen panels
+        this.buildScreens(config);
+        scene.add(this.group);
+    }
+    buildScreens(config) {
+        for (const def of SCREEN_DEFS) {
+            const geo = new THREE.PlaneGeometry(def.width, def.height);
+            // Screen surface — slightly translucent, emissive glow
+            const mat = new THREE.MeshStandardMaterial({
+                color: config.screenBaseColor,
+                emissive: config.screenEmissive,
+                emissiveIntensity: config.screenEmissiveIntensity,
+                transparent: true,
+                opacity: config.screenOpacity,
+                side: THREE.DoubleSide,
+                depthWrite: false,
+            });
+            this.screenMaterials.push(mat);
+            const mesh = new THREE.Mesh(geo, mat);
+            mesh.position.set(def.x, def.y, def.z);
+            if (def.rotY != null) {
+                mesh.rotation.y = def.rotY;
+            }
+            else {
+                // Face toward origin
+                mesh.lookAt(0, def.y, 0);
+            }
+            this.screens.push(mesh);
+            this.group.add(mesh);
+            // Thin border frame around each screen
+            const edgeGeo = new THREE.EdgesGeometry(geo);
+            const edgeMat = new THREE.LineBasicMaterial({
+                color: config.screenBorderColor,
+                transparent: true,
+                opacity: 0.5,
+                depthWrite: false,
+            });
+            this.borderMaterials.push(edgeMat);
+            const edgeMesh = new THREE.LineSegments(edgeGeo, edgeMat);
+            edgeMesh.position.copy(mesh.position);
+            edgeMesh.rotation.copy(mesh.rotation);
+            edgeMesh.quaternion.copy(mesh.quaternion);
+            this.borderMeshes.push(edgeMesh);
+            this.group.add(edgeMesh);
+            // Horizontal scan line sweeping across each screen
+            const scanGeo = new THREE.PlaneGeometry(def.width * 0.92, 0.015);
+            const scanMat = new THREE.MeshBasicMaterial({
+                color: config.screenEmissive,
+                transparent: true,
+                opacity: 0.2,
+                depthWrite: false,
+                side: THREE.DoubleSide,
+            });
+            this.scanLineMaterials.push(scanMat);
+            const scanMesh = new THREE.Mesh(scanGeo, scanMat);
+            scanMesh.position.copy(mesh.position);
+            scanMesh.quaternion.copy(mesh.quaternion);
+            this.scanLineMeshes.push(scanMesh);
+            this.group.add(scanMesh);
+        }
+    }
+    /** Per-frame update — call from the render loop. */
+    update(deltaTime, _camera) {
+        this.elapsedTime += deltaTime;
+        const config = this.theme === "light" ? THEME_LIGHT : THEME_DARK;
+        for (let i = 0; i < this.screens.length; i++) {
+            const screen = this.screens[i];
+            const def = SCREEN_DEFS[i];
+            // Gentle float / bob
+            screen.position.y =
+                def.y + Math.sin(this.elapsedTime * 0.35 + i * 1.4) * 0.04;
+            // Sync border position
+            const border = this.borderMeshes[i];
+            border.position.y = screen.position.y;
+            // Emissive pulse — subtle in light, prominent neon glow in dark
+            const mat = this.screenMaterials[i];
+            const baseEmissive = config.screenEmissiveIntensity;
+            const pulseRange = this.theme === "dark" ? 0.25 : 0.1;
+            mat.emissiveIntensity =
+                baseEmissive + Math.sin(this.elapsedTime * 0.6 + i * 0.8) * pulseRange;
+            // Scan line sweeps vertically
+            const scan = this.scanLineMeshes[i];
+            const scanPhase = ((this.elapsedTime * 0.2 + i * 0.5) % 1.0) * 2.0 - 1.0;
+            const upDir = new THREE.Vector3(0, 1, 0);
+            scan.position.copy(screen.position);
+            scan.position.addScaledVector(upDir, scanPhase * def.height * 0.45);
+            const scanMat = this.scanLineMaterials[i];
+            scanMat.opacity =
+                config.scanBaseOpacity * (1.0 - Math.abs(scanPhase) * 0.5);
+        }
+        // Grid subtle pulse
+        if (this.gridCenterMaterial) {
+            const basePulse = config.gridCenterOpacity;
+            this.gridCenterMaterial.opacity =
+                basePulse + Math.sin(this.elapsedTime * 0.3) * 0.05;
+        }
+    }
+    /** Switch theme without rebuilding. */
+    setTheme(theme) {
+        if (theme === this.theme)
+            return;
+        this.theme = theme;
+        const config = theme === "light" ? THEME_LIGHT : THEME_DARK;
+        if (this.fog) {
+            this.fog.color.set(config.fogColor);
+            this.fog.density = config.fogDensity;
+        }
+        if (this.sceneRef) {
+            this.sceneRef.background = new THREE.Color(config.bgColor);
+        }
+        if (this.gridMaterial) {
+            this.gridMaterial.color.copy(config.gridColor);
+            this.gridMaterial.opacity = config.gridOpacity;
+        }
+        if (this.gridCenterMaterial) {
+            this.gridCenterMaterial.color.copy(config.gridCenterColor);
+            this.gridCenterMaterial.opacity = config.gridCenterOpacity;
+        }
+        if (this.gridHelper) {
+            const gridMats = this.gridHelper.material;
+            if (Array.isArray(gridMats)) {
+                for (const m of gridMats) {
+                    m.opacity = config.gridOpacity;
+                }
+            }
+        }
+        for (const mat of this.screenMaterials) {
+            mat.color.copy(config.screenBaseColor);
+            mat.emissive.copy(config.screenEmissive);
+            mat.emissiveIntensity = config.screenEmissiveIntensity;
+            mat.opacity = config.screenOpacity;
+        }
+        for (const mat of this.borderMaterials) {
+            mat.color.copy(config.screenBorderColor);
+        }
+        for (const mat of this.scanLineMaterials) {
+            mat.color.copy(config.screenEmissive);
+        }
+    }
+    /** Dispose all Three.js objects. */
+    dispose() {
+        for (const mesh of this.screens) {
+            mesh.geometry.dispose();
+        }
+        for (const mat of this.screenMaterials) {
+            mat.dispose();
+        }
+        for (const mesh of this.borderMeshes) {
+            mesh.geometry.dispose();
+        }
+        for (const mat of this.borderMaterials) {
+            mat.dispose();
+        }
+        for (const mesh of this.scanLineMeshes) {
+            mesh.geometry.dispose();
+        }
+        for (const mat of this.scanLineMaterials) {
+            mat.dispose();
+        }
+        this.gridHelper?.geometry.dispose();
+        this.gridMaterial?.dispose();
+        this.gridCenterMaterial?.dispose();
+        if (this.sceneRef) {
+            this.sceneRef.remove(this.group);
+            this.sceneRef.fog = null;
+            this.sceneRef.background = null;
+        }
+        this.screens = [];
+        this.screenMaterials = [];
+        this.borderMeshes = [];
+        this.borderMaterials = [];
+        this.scanLineMeshes = [];
+        this.scanLineMaterials = [];
+        this.gridHelper = null;
+        this.gridMaterial = null;
+        this.gridCenterMaterial = null;
+        this.fog = null;
+        this.sceneRef = null;
+    }
+}

package/apps/app-companion/src/components/avatar/SceneOverlayManager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * SceneOverlayManager — manages holographic floating panels in the three.js scene.
+ *
+ * Creates billboard panels (chat, agent status, heartbeats) as textured
+ * planes with emissive materials, plus additional chat-mirror panels
+ * scattered around the scene to create the "floating screens with chat"
+ * effect in the Matrix Construct environment.
+ */
+import * as THREE from "three";
+import { type AgentStatusOverlay, type ChatOverlayMessage, type TriggerOverlay } from "./scene-overlay-renderer";
+export declare class SceneOverlayManager {
+    private chatPanel;
+    private statusPanel;
+    private heartbeatsPanel;
+    private chatMirrorPanels;
+    private attached;
+    private disposed;
+    private chatData;
+    private statusData;
+    private heartbeatsData;
+    private fontsChecked;
+    constructor();
+    /** Add panel groups to the scene. Called once when the engine is ready. */
+    attach(scene: THREE.Scene): void;
+    /**
+     * Per-frame update: billboard panels toward camera, animate opacity,
+     * and repaint dirty canvases.
+     */
+    update(camera: THREE.PerspectiveCamera, delta: number): void;
+    setChatMessages(messages: ChatOverlayMessage[]): void;
+    setAgentStatus(status: AgentStatusOverlay | null): void;
+    setHeartbeats(triggers: TriggerOverlay[]): void;
+    dispose(): void;
+    private updatePanel;
+}
+//# sourceMappingURL=SceneOverlayManager.d.ts.map

package/apps/app-companion/src/components/avatar/SceneOverlayManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneOverlayManager.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-companion/src/components/avatar/SceneOverlayManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EAIvB,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAC;AAiKlC,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,SAAS,CAAe;IAChC,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,eAAe,CAAe;IACtC,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IAGzB,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,UAAU,CAAmC;IACrD,OAAO,CAAC,cAAc,CAAwB;IAE9C,OAAO,CAAC,YAAY,CAAS;;IAa7B,2EAA2E;IAC3E,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,IAAI;IAWhC;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAgG5D,eAAe,CAAC,QAAQ,EAAE,kBAAkB,EAAE,GAAG,IAAI;IAgBrD,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,GAAG,IAAI;IAkBvD,aAAa,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,IAAI;IAkB/C,OAAO,IAAI,IAAI;IAcf,OAAO,CAAC,WAAW;CA+BpB"}