@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/providers/workspace.js

@@ -0,0 +1,419 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as elizaCore from "@elizaos/core";
+import { resolveUserPath } from "../config/paths.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR, resolveDefaultAgentWorkspaceDir, shouldBootstrapWorkspaceInitFiles, shouldUseRuntimeCwdWorkspace, } from "../shared/workspace-resolution.js";
+export { DEFAULT_AGENT_WORKSPACE_DIR, resolveDefaultAgentWorkspaceDir, shouldBootstrapWorkspaceInitFiles, shouldUseRuntimeCwdWorkspace, };
+/**
+ * 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"),
+            });
+        });
+    });
+}
+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
+
+## Memory
+- Write important things to USER.md (facts about your person)
+- Write your own reflections to MEMORY.md (what you've learned, patterns you notice)
+- These files persist across conversations. Use them.
+- If you learn something new about your person, write it down immediately.
+
+## Personality
+Your personality, voice, and identity are defined in your character file
+(the system prompt). Edit that from the dashboard or settings, not here.
+`,
+    [DEFAULT_TOOLS_FILENAME]: `# Tools
+
+Tools are provided by your enabled plugins and invoked automatically.
+Check the connectors page in your dashboard to enable Discord, Telegram,
+and other integrations.
+`,
+    [DEFAULT_IDENTITY_FILENAME]: `# Identity
+
+Your personality and voice are defined in your character file (system prompt).
+Edit your character from the dashboard to change who you are.
+
+This file is for any additional context you want to maintain about yourself
+that goes beyond the character definition — things you've decided, preferences
+you've developed, or aspects of your identity that emerged over time.
+`,
+    [DEFAULT_USER_FILENAME]: `# User
+
+Your person. Learn about them over time and update this file.
+
+Nothing here yet — you just met. Pay attention and fill this in naturally.
+`,
+    [DEFAULT_HEARTBEAT_FILENAME]: `# Heartbeat
+
+Periodic check-in. Use this space for reminders, recurring checks,
+or things you want to follow up on during your next heartbeat cycle.
+`,
+    [DEFAULT_INIT_FILENAME]: `# Init
+
+Your workspace. These files are your runtime context:
+
+- **USER.md** — What you know about your person (fill this in over time)
+- **MEMORY.md** — Long-term memory (lessons, patterns, insights)
+- **AGENTS.md** — Operational notes and memory guidelines
+- **IDENTITY.md** — Emergent identity notes (your character file is the source of truth)
+- **TOOLS.md** — Available tools and plugins
+- **HEARTBEAT.md** — Reminders and periodic checks
+
+Your personality is defined in your character file (system prompt), editable
+from the dashboard. These workspace files are for runtime context that you
+build up over time through conversations.
+`,
+};
+const LEGACY_WORKSPACE_TEMPLATES = {
+    [DEFAULT_AGENTS_FILENAME]: [
+        `# Agents
+
+Autonomous 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.
+`,
+    ],
+};
+function normalizeBoilerplateText(value) {
+    return value
+        .replace(/\r\n?/g, "\n")
+        .trim()
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .toLowerCase();
+}
+/**
+ * Returns true if the file content matches the built-in boilerplate template.
+ * Used to skip injecting generic boilerplate docs into the prompt.
+ */
+export function isDefaultBoilerplate(name, content) {
+    const templates = [
+        WORKSPACE_TEMPLATES[name],
+        ...(LEGACY_WORKSPACE_TEMPLATES[name] ?? []),
+    ].filter((template) => typeof template === "string");
+    if (templates.length === 0)
+        return false;
+    const normalizedContent = normalizeBoilerplateText(content);
+    return templates.some((template) => normalizeBoilerplateText(template) === normalizedContent);
+}
+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);
+    }
+    else {
+        elizaCore.logger.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: ${String(err)}`);
+    }
+}
+export async function ensureAgentWorkspace(params) {
+    const rawDir = params?.dir?.trim()
+        ? params.dir.trim()
+        : resolveDefaultAgentWorkspaceDir();
+    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/runtime/actions/web-fetch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * WEB_FETCH — keyless inline HTTP GET of a public URL or data API.
+ *
+ * Gives every runtime (not just Anthropic, which gets server-side web_search
+ * via {@link installAnthropicWebSearch}) an inline live-info capability that
+ * needs no API key and no backing service. Because its similes include
+ * `LOOKUP_WEB` / `WEB_LOOKUP`, the core router's `findWebLookupActionName`
+ * picks it up with no core change, so non-Anthropic models can answer
+ * live-info questions inline instead of force-delegating to a coding agent.
+ *
+ * Enabled by default; `validate` honors the same `ELIZA_WEB_FETCH=0|false|off`
+ * capability gate as registration, so a disabled capability never runs. The
+ * fetch itself is hardened by the shared SSRF-guarded, https-only, GET-only
+ * helper.
+ *
+ * @module runtime/actions/web-fetch
+ */
+import { type Action } from "@elizaos/core";
+/**
+ * Capability gate: WEB_FETCH is enabled by default and opted out with
+ * `ELIZA_WEB_FETCH=0|false|off`, mirroring the registration-time check in
+ * `eliza.ts` and the `ELIZA_WEB_SEARCH` convention in `web-search-tools.ts`.
+ * Checked at `validate` time (not just registration) so a disabled capability
+ * never runs even when the action is registered by another path.
+ */
+export declare function isWebFetchEnabled(): boolean;
+export declare const webFetch: Action & Record<string, unknown>;
+//# sourceMappingURL=web-fetch.d.ts.map

package/runtime/actions/web-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../../src/runtime/actions/web-fetch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,KAAK,MAAM,EAQZ,MAAM,eAAe,CAAC;AAMvB;;;;;;GAMG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAG3C;AAwDD,eAAO,MAAM,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CA4HrD,CAAC"}

package/runtime/actions/web-fetch.js

@@ -0,0 +1,190 @@
+/**
+ * WEB_FETCH — keyless inline HTTP GET of a public URL or data API.
+ *
+ * Gives every runtime (not just Anthropic, which gets server-side web_search
+ * via {@link installAnthropicWebSearch}) an inline live-info capability that
+ * needs no API key and no backing service. Because its similes include
+ * `LOOKUP_WEB` / `WEB_LOOKUP`, the core router's `findWebLookupActionName`
+ * picks it up with no core change, so non-Anthropic models can answer
+ * live-info questions inline instead of force-delegating to a coding agent.
+ *
+ * Enabled by default; `validate` honors the same `ELIZA_WEB_FETCH=0|false|off`
+ * capability gate as registration, so a disabled capability never runs. The
+ * fetch itself is hardened by the shared SSRF-guarded, https-only, GET-only
+ * helper.
+ *
+ * @module runtime/actions/web-fetch
+ */
+import { logger, } from "@elizaos/core";
+import { performGuardedHttpGet } from "../custom-actions.js";
+/** Max characters of fetched text we return when no extract path matches. */
+const WEB_FETCH_SNIPPET_CHARS = 4_000;
+/**
+ * Capability gate: WEB_FETCH is enabled by default and opted out with
+ * `ELIZA_WEB_FETCH=0|false|off`, mirroring the registration-time check in
+ * `eliza.ts` and the `ELIZA_WEB_SEARCH` convention in `web-search-tools.ts`.
+ * Checked at `validate` time (not just registration) so a disabled capability
+ * never runs even when the action is registered by another path.
+ */
+export function isWebFetchEnabled() {
+    const raw = process.env.ELIZA_WEB_FETCH?.toLowerCase();
+    return !(raw === "0" || raw === "false" || raw === "off");
+}
+function readParams(options) {
+    const params = options
+        ?.parameters;
+    if (!params || typeof params !== "object")
+        return {};
+    const url = params.url;
+    const extract = params.extract;
+    return {
+        url: typeof url === "string" ? url.trim() : undefined,
+        extract: typeof extract === "string" ? extract.trim() : undefined,
+    };
+}
+/**
+ * Resolve a dotted JSON path (e.g. `data.price` or `items.0.name`) against a
+ * parsed JSON value. Returns undefined when any segment is missing.
+ */
+function resolveJsonPath(root, path) {
+    let current = root;
+    for (const segment of path.split(".")) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== "object")
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function stringifyValue(value) {
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+/**
+ * Apply the optional `extract` instruction: when the body parses as JSON and
+ * `extract` is a dotted path that resolves, return that field; otherwise fall
+ * back to a truncated text snippet of the raw body.
+ */
+function extractValue(body, extract) {
+    if (extract) {
+        try {
+            const parsed = JSON.parse(body);
+            const resolved = resolveJsonPath(parsed, extract);
+            if (resolved !== undefined)
+                return stringifyValue(resolved);
+        }
+        catch {
+            // Body was not JSON, or extract did not resolve — fall through to snippet.
+        }
+    }
+    return body.slice(0, WEB_FETCH_SNIPPET_CHARS);
+}
+export const webFetch = {
+    name: "WEB_FETCH",
+    similes: ["LOOKUP_WEB", "WEB_LOOKUP", "FETCH_URL", "HTTP_GET", "GET_URL"],
+    suppressInitialMessage: true,
+    description: "Fetch the contents of a public https URL or JSON data API and return the result inline. " +
+        "Use for live information — current data, status pages, public REST/JSON endpoints — when you already know (or can construct) the exact URL. " +
+        "No API key required. Requests are https-only, GET-only, and SSRF-guarded (internal/private hosts are blocked).",
+    parameters: [
+        {
+            name: "url",
+            description: "The absolute https URL to fetch (e.g. https://api.example.com/v1/price).",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "extract",
+            description: "Optional dotted JSON path selecting which field to return when the body is JSON (e.g. 'data.amount'). Omit to return a text snippet of the body.",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+    validate: async () => isWebFetchEnabled(),
+    handler: async (_runtime, _message, _state, options, callback) => {
+        const { url, extract } = readParams(options);
+        if (!url) {
+            const text = "Missing required parameter 'url'.";
+            callback?.({ text });
+            return { text, success: false, data: { actionName: "WEB_FETCH" } };
+        }
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(url);
+        }
+        catch {
+            const text = `Not a valid URL: ${url}`;
+            callback?.({ text });
+            return { text, success: false, data: { actionName: "WEB_FETCH", url } };
+        }
+        if (parsedUrl.protocol !== "https:") {
+            const text = `Refusing to fetch ${url}: only https URLs are allowed.`;
+            callback?.({ text });
+            return { text, success: false, data: { actionName: "WEB_FETCH", url } };
+        }
+        try {
+            const result = await performGuardedHttpGet(url, {
+                headers: { Accept: "application/json, text/plain, */*" },
+            });
+            if (result.blocked) {
+                const text = `Refusing to fetch ${url}: blocked host or disallowed redirect.`;
+                logger.warn(`[web-fetch] blocked ${url}`);
+                callback?.({ text });
+                return { text, success: false, data: { actionName: "WEB_FETCH", url } };
+            }
+            if (!result.ok) {
+                const text = `Fetch failed for ${url}: HTTP ${result.status}.`;
+                callback?.({ text });
+                return {
+                    text,
+                    success: false,
+                    data: { actionName: "WEB_FETCH", url, status: result.status },
+                };
+            }
+            const value = extractValue(result.text, extract);
+            const content = {
+                text: value,
+                actions: ["WEB_FETCH"],
+                data: { actionName: "WEB_FETCH", url, value },
+            };
+            callback?.(content);
+            return {
+                text: value,
+                success: true,
+                data: { actionName: "WEB_FETCH", url, value },
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn(`[web-fetch] error fetching ${url}: ${message}`);
+            const text = `Fetch failed for ${url}: ${message}`;
+            callback?.({ text });
+            return {
+                text,
+                success: false,
+                data: { actionName: "WEB_FETCH", url },
+                error: message,
+            };
+        }
+    },
+    examples: [
+        [
+            {
+                name: "{{user}}",
+                content: {
+                    text: "What does https://api.example.com/v1/status return?",
+                },
+            },
+            {
+                name: "{{agent}}",
+                content: {
+                    text: "Fetching that endpoint now:",
+                    action: "WEB_FETCH",
+                    actionParams: { url: "https://api.example.com/v1/status" },
+                },
+            },
+        ],
+    ],
+};

package/runtime/advanced-capabilities-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced-capabilities-config.d.ts","sourceRoot":"","sources":["../../src/runtime/advanced-capabilities-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,eAAO,MAAM,8BAA8B,iDAIjC,CAAC;AAEX,MAAM,MAAM,0BAA0B,GACpC,CAAC,OAAO,8BAA8B,CAAC,CAAC,MAAM,CAAC,CAAC;AAUlD,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,GACf,QAAQ,IAAI,0BAA0B,CAIxC;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,OAAO,CAST;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,OAAO,GACf,IAAI,CAkBN;AAED,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxB"}

package/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"}