@elizaos/agent 0.25.8 → 2.0.0-alpha.83

package/packages/agent/src/providers/workspace-provider.js

@@ -0,0 +1,167 @@
+/**
+ * Reads workspace init files and injects them into agent context.
+ *
+ * Also provides coding agent context enrichment: when coding-agent metadata
+ * is present on the inbound message, the provider appends a summary of the
+ * current coding session state (active iteration, recent errors, pending
+ * feedback) so the LLM has full awareness during the autonomous coding loop.
+ */
+import { ChannelType, logger, } from "@elizaos/core";
+import { DEFAULT_AGENT_WORKSPACE_DIR, filterInitFilesForSession, isDefaultBoilerplate, loadWorkspaceInitFiles, } from "./workspace";
+const DEFAULT_MAX_CHARS = 20_000;
+/** Hard cap on total workspace context to prevent prompt explosion. */
+const MAX_TOTAL_WORKSPACE_CHARS = 100_000;
+const CACHE_TTL_MS = 60_000;
+// Per-workspace cache so multi-agent doesn't thrash.
+const cache = new Map();
+/** Maximum number of workspace directories to cache simultaneously. */
+const MAX_CACHE_ENTRIES = 20;
+async function getFiles(dir) {
+    const now = Date.now();
+    const entry = cache.get(dir);
+    if (entry && now - entry.at < CACHE_TTL_MS)
+        return entry.files;
+    // Evict expired entries and enforce size cap before inserting
+    for (const [key, val] of cache) {
+        if (now - val.at >= CACHE_TTL_MS)
+            cache.delete(key);
+    }
+    if (cache.size >= MAX_CACHE_ENTRIES) {
+        // Remove the oldest entry
+        const oldest = cache.keys().next().value;
+        if (oldest)
+            cache.delete(oldest);
+    }
+    const files = await loadWorkspaceInitFiles(dir);
+    cache.set(dir, { files, at: now });
+    return files;
+}
+/** @internal Exported for testing. */
+export function truncate(content, max) {
+    if (content.length <= max)
+        return content;
+    return `${content.slice(0, max)}\n\n[... truncated at ${max.toLocaleString()} chars]`;
+}
+/** @internal Exported for testing. */
+export function buildContext(files, maxChars) {
+    const sections = [];
+    let totalChars = 0;
+    for (const f of files) {
+        if (f.missing || !f.content?.trim())
+            continue;
+        // Skip files that are still the default boilerplate — they add ~3k of
+        // generic placeholder text with zero useful context for the model.
+        if (isDefaultBoilerplate(f.name, f.content))
+            continue;
+        const trimmed = f.content.trim();
+        // Per-file truncation
+        const text = truncate(trimmed, maxChars);
+        const tag = text.length > trimmed.length ? " [TRUNCATED]" : "";
+        const section = `### ${f.name}${tag}\n\n${text}`;
+        // Stop adding files if the total would exceed the hard cap
+        if (totalChars + section.length > MAX_TOTAL_WORKSPACE_CHARS &&
+            sections.length > 0) {
+            break;
+        }
+        sections.push(section);
+        totalChars += section.length;
+    }
+    if (sections.length === 0)
+        return "";
+    return `## Project Context (Workspace)\n\n${sections.join("\n\n---\n\n")}`;
+}
+/** @internal Exported for testing. Builds a summary of the coding agent session. */
+export function buildCodingAgentSummary(ctx) {
+    const lines = [];
+    lines.push("## Coding Agent Session");
+    lines.push("");
+    lines.push(`**Task:** ${ctx.taskDescription}`);
+    lines.push(`**Working Directory:** ${ctx.workingDirectory}`);
+    lines.push(`**Connector:** ${ctx.connector.type}`);
+    lines.push(`**Mode:** ${ctx.interactionMode}`);
+    lines.push(`**Active:** ${ctx.active ? "yes" : "no"}`);
+    if (!ctx.connector.available) {
+        lines.push(`**Connector Status:** unavailable`);
+    }
+    // Errors from the last iteration
+    const lastIteration = ctx.iterations[ctx.iterations.length - 1];
+    if (lastIteration && lastIteration.errors.length > 0) {
+        lines.push("");
+        lines.push("### Errors to Resolve");
+        for (const err of lastIteration.errors) {
+            const loc = err.filePath
+                ? err.line
+                    ? ` (${err.filePath}:${err.line})`
+                    : ` (${err.filePath})`
+                : "";
+            lines.push(`- [${err.category}]${loc}: ${err.message}`);
+        }
+    }
+    // Human feedback
+    const pendingFeedback = ctx.allFeedback.filter((fb) => !fb.iterationRef || fb.iterationRef >= ctx.iterations.length - 1);
+    if (pendingFeedback.length > 0) {
+        lines.push("");
+        lines.push("### Human Feedback");
+        for (const fb of pendingFeedback) {
+            lines.push(`- [${fb.type}]: ${fb.text}`);
+        }
+    }
+    // Recent commands from the last iteration
+    if (lastIteration && lastIteration.commandResults.length > 0) {
+        lines.push("");
+        lines.push("### Recent Commands");
+        for (const cmd of lastIteration.commandResults.slice(-5)) {
+            const status = cmd.success ? "OK" : `FAIL(${cmd.exitCode})`;
+            lines.push(`- \`${cmd.command}\` → ${status}`);
+            if (cmd.stdout?.trim()) {
+                lines.push(`  stdout: ${truncate(cmd.stdout.trim(), 200)}`);
+            }
+            if (cmd.stderr?.trim()) {
+                lines.push(`  stderr: ${truncate(cmd.stderr.trim(), 200)}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+export function createWorkspaceProvider(options) {
+    const dir = options?.workspaceDir ?? DEFAULT_AGENT_WORKSPACE_DIR;
+    const maxChars = options?.maxCharsPerFile ?? DEFAULT_MAX_CHARS;
+    return {
+        name: "workspaceContext",
+        description: "Workspace init files (AGENTS.md, TOOLS.md, IDENTITY.md, etc.) and coding agent context",
+        position: 10,
+        async get(_runtime, message, _state) {
+            const channelType = message.content?.channelType;
+            if (channelType === ChannelType.VOICE_DM ||
+                channelType === ChannelType.VOICE_GROUP) {
+                return {
+                    text: "",
+                    data: {
+                        workspaceDir: dir,
+                        skipped: "voice_channel",
+                    },
+                };
+            }
+            try {
+                const allFiles = await getFiles(dir);
+                const meta = message.metadata;
+                const sessionKey = typeof meta?.sessionKey === "string" ? meta.sessionKey : undefined;
+                const files = filterInitFilesForSession(allFiles, sessionKey);
+                const text = buildContext(files, maxChars);
+                return {
+                    text,
+                    data: {
+                        workspaceDir: dir,
+                    },
+                };
+            }
+            catch (err) {
+                logger.warn(`[workspace-provider] Failed to load workspace context: ${err instanceof Error ? err.message : err}`);
+                return {
+                    text: `[Workspace context unavailable: ${err instanceof Error ? err.message : err}]`,
+                    data: {},
+                };
+            }
+        },
+    };
+}

package/packages/agent/src/providers/workspace.d.ts

@@ -0,0 +1,54 @@
+export interface RunCommandResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export interface RunCommandOptions {
+    cwd?: string;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Runs a command with an optional timeout.
+ * Returns { code, stdout, stderr }.
+ * Rejects if the process cannot be spawned or the timeout fires.
+ */
+export declare function runCommandWithTimeout(argv: string[], opts?: RunCommandOptions): Promise<RunCommandResult>;
+export declare function resolveDefaultAgentWorkspaceDir(env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare const DEFAULT_AGENT_WORKSPACE_DIR: string;
+declare const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
+declare const DEFAULT_TOOLS_FILENAME = "TOOLS.md";
+declare const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
+declare const DEFAULT_USER_FILENAME = "USER.md";
+declare const DEFAULT_HEARTBEAT_FILENAME = "HEARTBEAT.md";
+declare const DEFAULT_INIT_FILENAME = "INIT.md";
+declare const DEFAULT_MEMORY_FILENAME = "MEMORY.md";
+declare const DEFAULT_MEMORY_ALT_FILENAME = "memory.md";
+export type WorkspaceInitFileName = typeof DEFAULT_AGENTS_FILENAME | typeof DEFAULT_TOOLS_FILENAME | typeof DEFAULT_IDENTITY_FILENAME | typeof DEFAULT_USER_FILENAME | typeof DEFAULT_HEARTBEAT_FILENAME | typeof DEFAULT_INIT_FILENAME | typeof DEFAULT_MEMORY_FILENAME | typeof DEFAULT_MEMORY_ALT_FILENAME;
+export type WorkspaceInitFile = {
+    name: WorkspaceInitFileName;
+    path: string;
+    content?: string;
+    missing: boolean;
+};
+/**
+ * Returns true if the file content matches the built-in boilerplate template.
+ * Used to skip injecting generic placeholder docs into the prompt.
+ */
+export declare function isDefaultBoilerplate(name: string, content: string): boolean;
+export declare function ensureAgentWorkspace(params?: {
+    dir?: string;
+    ensureInitFiles?: boolean;
+}): Promise<{
+    dir: string;
+    agentsPath?: string;
+    toolsPath?: string;
+    identityPath?: string;
+    userPath?: string;
+    heartbeatPath?: string;
+    initPath?: string;
+}>;
+export declare function loadWorkspaceInitFiles(dir: string): Promise<WorkspaceInitFile[]>;
+export declare function filterInitFilesForSession(files: WorkspaceInitFile[], sessionKey?: string): WorkspaceInitFile[];
+export {};
+//# sourceMappingURL=workspace.d.ts.map

package/packages/agent/src/providers/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../../../../src/providers/workspace.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,GAAE,iBAAsB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAqD3B;AAED,wBAAgB,+BAA+B,CAC7C,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,OAAO,GAAE,MAAM,MAAmB,GACjC,MAAM,CAMR;AAED,eAAO,MAAM,2BAA2B,QAAoC,CAAC;AAC7E,QAAA,MAAM,uBAAuB,cAAc,CAAC;AAC5C,QAAA,MAAM,sBAAsB,aAAa,CAAC;AAC1C,QAAA,MAAM,yBAAyB,gBAAgB,CAAC;AAChD,QAAA,MAAM,qBAAqB,YAAY,CAAC;AACxC,QAAA,MAAM,0BAA0B,iBAAiB,CAAC;AAClD,QAAA,MAAM,qBAAqB,YAAY,CAAC;AACxC,QAAA,MAAM,uBAAuB,cAAc,CAAC;AAC5C,QAAA,MAAM,2BAA2B,cAAc,CAAC;AA2FhD,MAAM,MAAM,qBAAqB,GAC7B,OAAO,uBAAuB,GAC9B,OAAO,sBAAsB,GAC7B,OAAO,yBAAyB,GAChC,OAAO,qBAAqB,GAC5B,OAAO,0BAA0B,GACjC,OAAO,qBAAqB,GAC5B,OAAO,uBAAuB,GAC9B,OAAO,2BAA2B,CAAC;AAEvC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAI3E;AAyFD,wBAAsB,oBAAoB,CAAC,MAAM,CAAC,EAAE;IAClD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GAAG,OAAO,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC,CAuED;AA6CD,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAsD9B;AAOD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,iBAAiB,EAAE,EAC1B,UAAU,CAAC,EAAE,MAAM,GAClB,iBAAiB,EAAE,CAKrB"}

package/packages/agent/src/providers/workspace.js

@@ -0,0 +1,405 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import * as elizaCore from "@elizaos/core";
+import { resolveUserPath } from "../config/paths";
+/**
+ * Runs a command with an optional timeout.
+ * Returns { code, stdout, stderr }.
+ * Rejects if the process cannot be spawned or the timeout fires.
+ */
+export function runCommandWithTimeout(argv, opts = {}) {
+    const [cmd, ...args] = argv;
+    if (!cmd) {
+        return Promise.reject(new Error("runCommandWithTimeout: empty argv"));
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd: opts.cwd,
+            env: opts.env ?? process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        let timedOut = false;
+        let timer;
+        if (opts.timeoutMs && opts.timeoutMs > 0) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGKILL");
+            }, opts.timeoutMs);
+        }
+        child.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (exitCode) => {
+            if (timer)
+                clearTimeout(timer);
+            if (timedOut) {
+                reject(new Error(`Command timed out after ${opts.timeoutMs}ms: ${argv.join(" ")}`));
+                return;
+            }
+            resolve({
+                code: exitCode ?? 1,
+                stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+            });
+        });
+    });
+}
+export function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
+    const profile = env.ELIZA_PROFILE?.trim();
+    if (profile && profile.toLowerCase() !== "default") {
+        return path.join(homedir(), ".eliza", `workspace-${profile}`);
+    }
+    return path.join(homedir(), ".eliza", "workspace");
+}
+export const DEFAULT_AGENT_WORKSPACE_DIR = resolveDefaultAgentWorkspaceDir();
+const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
+const DEFAULT_TOOLS_FILENAME = "TOOLS.md";
+const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
+const DEFAULT_USER_FILENAME = "USER.md";
+const DEFAULT_HEARTBEAT_FILENAME = "HEARTBEAT.md";
+const DEFAULT_INIT_FILENAME = "INIT.md";
+const DEFAULT_MEMORY_FILENAME = "MEMORY.md";
+const DEFAULT_MEMORY_ALT_FILENAME = "memory.md";
+/** Inline workspace init templates — no external files needed. */
+const WORKSPACE_TEMPLATES = {
+    [DEFAULT_AGENTS_FILENAME]: `# Agents
+
+You are an autonomous AI agent powered by ElizaOS.
+
+## Capabilities
+
+- Respond to user messages conversationally
+- Execute actions and use available tools
+- Access and manage knowledge from your workspace
+- Maintain context across conversations
+
+## Guidelines
+
+- Be helpful, concise, and accurate
+- Ask for clarification when instructions are ambiguous
+- Use tools when they would help accomplish the user's goal
+- Respect the user's preferences and communication style
+`,
+    [DEFAULT_TOOLS_FILENAME]: `# Tools
+
+Available tools and capabilities for the agent.
+
+## Built-in Tools
+
+The agent has access to tools provided by enabled plugins.
+Each plugin may register actions, providers, and evaluators
+that extend the agent's capabilities.
+
+## Usage
+
+Tools are invoked automatically when the agent determines
+they would help accomplish the user's goal. No manual
+configuration is required.
+`,
+    [DEFAULT_IDENTITY_FILENAME]: `# Identity
+
+Your character and personality settings.
+
+Customize this file to define your agent's personality,
+tone, and behavior style.
+`,
+    [DEFAULT_USER_FILENAME]: `# User
+
+User context and preferences.
+
+This file stores information about the user to help
+personalize interactions.
+`,
+    [DEFAULT_HEARTBEAT_FILENAME]: `# Heartbeat
+
+The heartbeat system enables autonomous agent behavior.
+
+## Scheduling
+
+When autonomy is enabled, the agent periodically evaluates
+whether to take proactive actions based on its goals,
+pending tasks, and environmental changes.
+
+## Triggers
+
+- Scheduled intervals (configurable)
+- External events from connected channels
+- System notifications and alerts
+`,
+    [DEFAULT_INIT_FILENAME]: `# Init
+
+Initial workspace setup for a new agent.
+
+## Getting Started
+
+This workspace was automatically created for your agent.
+You can customize it by editing the markdown files in this
+directory:
+
+- **AGENTS.md** — Agent behavior and capabilities
+- **TOOLS.md** — Available tools and plugins
+- **IDENTITY.md** — Character and personality
+- **USER.md** — User context and preferences
+- **HEARTBEAT.md** — Autonomous behavior settings
+
+## Configuration
+
+Agent configuration is managed through \`~/.eliza/eliza.json\`
+or the Eliza Control UI.
+`,
+};
+/**
+ * Returns true if the file content matches the built-in boilerplate template.
+ * Used to skip injecting generic placeholder docs into the prompt.
+ */
+export function isDefaultBoilerplate(name, content) {
+    const template = WORKSPACE_TEMPLATES[name];
+    if (!template)
+        return false;
+    return content.trim() === template.trim();
+}
+const coreWorkspaceHelpers = elizaCore;
+function isSubagentSessionKey(sessionKey) {
+    if (typeof coreWorkspaceHelpers.isSubagentSessionKey === "function") {
+        return coreWorkspaceHelpers.isSubagentSessionKey(sessionKey);
+    }
+    // Older @elizaos/core versions do not expose subagent helpers.
+    // Treat all sessions as primary sessions in that case.
+    return false;
+}
+function logWarn(message) {
+    if (coreWorkspaceHelpers.logger &&
+        typeof coreWorkspaceHelpers.logger.warn === "function") {
+        coreWorkspaceHelpers.logger.warn(message);
+        return;
+    }
+    console.warn(message);
+}
+async function writeFileIfMissing(filePath, content) {
+    try {
+        await fs.writeFile(filePath, content, {
+            encoding: "utf-8",
+            flag: "wx",
+        });
+    }
+    catch (err) {
+        if (err.code !== "EEXIST") {
+            throw err;
+        }
+    }
+}
+async function hasGitRepo(dir) {
+    try {
+        await fs.stat(path.join(dir, ".git"));
+        return true;
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return false;
+        }
+        throw err;
+    }
+}
+async function isGitAvailable() {
+    try {
+        const result = await runCommandWithTimeout(["git", "--version"], {
+            timeoutMs: 2_000,
+        });
+        return result.code === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureGitRepo(dir, isBrandNewWorkspace) {
+    if (!isBrandNewWorkspace) {
+        return;
+    }
+    if (await hasGitRepo(dir)) {
+        return;
+    }
+    if (!(await isGitAvailable())) {
+        return;
+    }
+    try {
+        await runCommandWithTimeout(["git", "init"], {
+            cwd: dir,
+            timeoutMs: 10_000,
+        });
+    }
+    catch (err) {
+        logWarn(`[workspace] git init failed: ${err instanceof Error ? err.message : err}`);
+    }
+}
+export async function ensureAgentWorkspace(params) {
+    const rawDir = params?.dir?.trim()
+        ? params.dir.trim()
+        : DEFAULT_AGENT_WORKSPACE_DIR;
+    const dir = resolveUserPath(rawDir);
+    await fs.mkdir(dir, { recursive: true });
+    if (!params?.ensureInitFiles) {
+        return { dir };
+    }
+    const agentsPath = path.join(dir, DEFAULT_AGENTS_FILENAME);
+    const toolsPath = path.join(dir, DEFAULT_TOOLS_FILENAME);
+    const identityPath = path.join(dir, DEFAULT_IDENTITY_FILENAME);
+    const userPath = path.join(dir, DEFAULT_USER_FILENAME);
+    const heartbeatPath = path.join(dir, DEFAULT_HEARTBEAT_FILENAME);
+    const initPath = path.join(dir, DEFAULT_INIT_FILENAME);
+    const isBrandNewWorkspace = await (async () => {
+        const paths = [
+            agentsPath,
+            toolsPath,
+            identityPath,
+            userPath,
+            heartbeatPath,
+        ];
+        const existing = await Promise.all(paths.map(async (p) => {
+            try {
+                await fs.access(p);
+                return true;
+            }
+            catch (err) {
+                if (err.code === "ENOENT") {
+                    return false;
+                }
+                throw err;
+            }
+        }));
+        return existing.every((v) => !v);
+    })();
+    const agentsTemplate = WORKSPACE_TEMPLATES[DEFAULT_AGENTS_FILENAME];
+    const toolsTemplate = WORKSPACE_TEMPLATES[DEFAULT_TOOLS_FILENAME];
+    const identityTemplate = WORKSPACE_TEMPLATES[DEFAULT_IDENTITY_FILENAME];
+    const userTemplate = WORKSPACE_TEMPLATES[DEFAULT_USER_FILENAME];
+    const heartbeatTemplate = WORKSPACE_TEMPLATES[DEFAULT_HEARTBEAT_FILENAME];
+    const initTemplate = WORKSPACE_TEMPLATES[DEFAULT_INIT_FILENAME];
+    const writeOps = [
+        writeFileIfMissing(agentsPath, agentsTemplate),
+        writeFileIfMissing(toolsPath, toolsTemplate),
+        writeFileIfMissing(identityPath, identityTemplate),
+        writeFileIfMissing(userPath, userTemplate),
+        writeFileIfMissing(heartbeatPath, heartbeatTemplate),
+    ];
+    if (isBrandNewWorkspace) {
+        writeOps.push(writeFileIfMissing(initPath, initTemplate));
+    }
+    await Promise.all(writeOps);
+    await ensureGitRepo(dir, isBrandNewWorkspace);
+    return {
+        dir,
+        agentsPath,
+        toolsPath,
+        identityPath,
+        userPath,
+        heartbeatPath,
+        initPath,
+    };
+}
+async function resolveMemoryInitEntries(resolvedDir) {
+    const candidates = [
+        DEFAULT_MEMORY_FILENAME,
+        DEFAULT_MEMORY_ALT_FILENAME,
+    ];
+    const entries = [];
+    for (const name of candidates) {
+        const filePath = path.join(resolvedDir, name);
+        try {
+            await fs.access(filePath);
+            entries.push({ name, filePath });
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+    }
+    if (entries.length <= 1) {
+        return entries;
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const entry of entries) {
+        let key = entry.filePath;
+        try {
+            key = await fs.realpath(entry.filePath);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(entry);
+    }
+    return deduped;
+}
+export async function loadWorkspaceInitFiles(dir) {
+    const resolvedDir = resolveUserPath(dir);
+    const entries = [
+        {
+            name: DEFAULT_AGENTS_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_AGENTS_FILENAME),
+        },
+        {
+            name: DEFAULT_TOOLS_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_TOOLS_FILENAME),
+        },
+        {
+            name: DEFAULT_IDENTITY_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_IDENTITY_FILENAME),
+        },
+        {
+            name: DEFAULT_USER_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_USER_FILENAME),
+        },
+        {
+            name: DEFAULT_HEARTBEAT_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_HEARTBEAT_FILENAME),
+        },
+        {
+            name: DEFAULT_INIT_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_INIT_FILENAME),
+        },
+    ];
+    entries.push(...(await resolveMemoryInitEntries(resolvedDir)));
+    const result = await Promise.all(entries.map(async (entry) => {
+        try {
+            const content = await fs.readFile(entry.filePath, "utf-8");
+            return {
+                name: entry.name,
+                path: entry.filePath,
+                content,
+                missing: false,
+            };
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return { name: entry.name, path: entry.filePath, missing: true };
+            }
+            throw err;
+        }
+    }));
+    return result;
+}
+const SUBAGENT_INIT_ALLOWLIST = new Set([
+    DEFAULT_AGENTS_FILENAME,
+    DEFAULT_TOOLS_FILENAME,
+]);
+export function filterInitFilesForSession(files, sessionKey) {
+    if (!sessionKey || !isSubagentSessionKey(sessionKey)) {
+        return files;
+    }
+    return files.filter((file) => SUBAGENT_INIT_ALLOWLIST.has(file.name));
+}

package/packages/agent/src/runtime/agent-event-service.d.ts

@@ -0,0 +1,35 @@
+import type { UUID } from "@elizaos/core";
+export interface AgentEventPayloadLike {
+    runId: string;
+    seq: number;
+    stream: string;
+    ts: number;
+    data: Record<string, unknown>;
+    sessionKey?: string;
+    agentId?: string;
+    roomId?: UUID;
+}
+export interface HeartbeatEventPayloadLike {
+    ts: number;
+    status: string;
+    to?: string;
+    preview?: string;
+    durationMs?: number;
+    hasMedia?: boolean;
+    reason?: string;
+    channel?: string;
+    silent?: boolean;
+    indicatorType?: string;
+}
+export interface AgentEventServiceLike {
+    subscribe: (listener: (event: AgentEventPayloadLike) => void) => () => void;
+    subscribeHeartbeat: (listener: (event: HeartbeatEventPayloadLike) => void) => () => void;
+    getLastHeartbeat?: () => HeartbeatEventPayloadLike | null;
+}
+type RuntimeWithServiceGetter = {
+    getService: (serviceType: string) => unknown | null;
+};
+export declare const AGENT_EVENT_SERVICE_TYPES: readonly ["agent_event", "AGENT_EVENT"];
+export declare function getAgentEventService(runtime: RuntimeWithServiceGetter | null | undefined): AgentEventServiceLike | null;
+export {};
+//# sourceMappingURL=agent-event-service.d.ts.map

package/packages/agent/src/runtime/agent-event-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-event-service.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/agent-event-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,IAAI,CAAC;CACf;AAED,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC5E,kBAAkB,EAAE,CAClB,QAAQ,EAAE,CAAC,KAAK,EAAE,yBAAyB,KAAK,IAAI,KACjD,MAAM,IAAI,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,yBAAyB,GAAG,IAAI,CAAC;CAC3D;AAED,KAAK,wBAAwB,GAAG;IAC9B,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;CACrD,CAAC;AAEF,eAAO,MAAM,yBAAyB,yCAG5B,CAAC;AAEX,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,wBAAwB,GAAG,IAAI,GAAG,SAAS,GACnD,qBAAqB,GAAG,IAAI,CAc9B"}

package/packages/agent/src/runtime/agent-event-service.js

@@ -0,0 +1,16 @@
+export const AGENT_EVENT_SERVICE_TYPES = [
+    "agent_event",
+    "AGENT_EVENT",
+];
+export function getAgentEventService(runtime) {
+    if (!runtime)
+        return null;
+    for (const serviceType of AGENT_EVENT_SERVICE_TYPES) {
+        const service = runtime.getService(serviceType);
+        if (service &&
+            typeof service.subscribe === "function") {
+            return service;
+        }
+    }
+    return null;
+}