@elizaos/agent 0.25.8 → 2.0.0-alpha.144

package/packages/agent/src/runtime/custom-actions.js

@@ -0,0 +1,507 @@
+/**
+ * Custom Actions runtime loader.
+ *
+ * Converts `CustomActionDef[]` from config into elizaOS `Action[]` objects
+ * so the agent can use them in conversations.
+ *
+ * @module runtime/custom-actions
+ */
+import { lookup as dnsLookup } from "node:dns/promises";
+import { request as requestHttp, } from "node:http";
+import { request as requestHttps } from "node:https";
+import net from "node:net";
+import { Readable } from "node:stream";
+import { logger, } from "@elizaos/core";
+import { loadElizaConfig } from "../config/config.js";
+import { resolveApiToken, resolveServerOnlyPort, } from "../config/runtime-env.js";
+import { isBlockedPrivateOrLinkLocalIp, normalizeHostLike, } from "../security/network-policy.js";
+/** Cached runtime reference for hot-registration of new actions. */
+let _runtime = null;
+/**
+ * Store the runtime reference so we can hot-register actions later.
+ * Called once from plugin.init().
+ */
+export function setCustomActionsRuntime(runtime) {
+    _runtime = runtime;
+}
+/**
+ * Hot-register a CustomActionDef into the running agent.
+ * Returns the elizaOS Action that was registered, or null if no runtime.
+ */
+export function registerCustomActionLive(def) {
+    if (!_runtime)
+        return null;
+    const action = defToAction(def);
+    _runtime.registerAction(action);
+    return action;
+}
+/** Valid handler types that we actually support. */
+const VALID_HANDLER_TYPES = new Set(["http", "shell", "code"]);
+let vmRunner = null;
+const CUSTOM_ACTION_FETCH_TIMEOUT_MS = 15_000;
+const CUSTOM_ACTION_SHELL_TIMEOUT_MS = 30_000;
+export class CustomActionTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CustomActionTimeoutError";
+    }
+}
+function getApiPort() {
+    return String(resolveServerOnlyPort(process.env));
+}
+async function fetchWithTimeout(input, init, timeoutMs) {
+    const timeoutMessage = `Terminal request timed out after ${timeoutMs}ms`;
+    return await new Promise((resolve, reject) => {
+        const controller = new AbortController();
+        let settled = false;
+        const timeoutHandle = setTimeout(() => {
+            controller.abort();
+            if (settled)
+                return;
+            settled = true;
+            reject(new CustomActionTimeoutError(timeoutMessage));
+        }, timeoutMs);
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutHandle);
+            callback();
+        };
+        fetch(input, {
+            ...init,
+            signal: controller.signal,
+        }).then((response) => settle(() => resolve(response)), (error) => {
+            if (controller.signal.aborted) {
+                settle(() => reject(new CustomActionTimeoutError(timeoutMessage)));
+                return;
+            }
+            settle(() => reject(error));
+        });
+    });
+}
+function resolveFetchInputUrl(input) {
+    if (typeof input === "string")
+        return input;
+    if (input instanceof URL)
+        return input.toString();
+    if (typeof Request !== "undefined" && input instanceof Request) {
+        return input.url;
+    }
+    return null;
+}
+async function safeCodeFetch(input, init) {
+    const url = resolveFetchInputUrl(input);
+    if (!url) {
+        throw new Error("Blocked: cannot make requests to internal network addresses");
+    }
+    const safety = await resolveUrlSafety(url);
+    if (safety.blocked) {
+        throw new Error("Blocked: cannot make requests to internal network addresses");
+    }
+    const requestInit = await buildPinnedFetchInit(input, init);
+    const response = safety.target
+        ? await fetchWithPinnedTarget(safety.target, requestInit, CUSTOM_ACTION_FETCH_TIMEOUT_MS)
+        : await fetch(input, requestInit);
+    if (response.status >= 300 && response.status < 400) {
+        throw new Error("Blocked: redirects are not allowed for code custom actions");
+    }
+    return response;
+}
+async function runCodeHandler(code, params) {
+    if (typeof process === "undefined" || !process.versions?.node) {
+        throw new Error("Code actions are only supported in Node runtimes.");
+    }
+    if (!vmRunner) {
+        vmRunner = (await import("node:vm"));
+    }
+    const script = `(async () => { ${code} })();`;
+    const context = Object.create(null);
+    context.params = Object.freeze({ ...params });
+    const wrapperScript = `(function(hostFetch) {
+    return function fetch(input, init) { return hostFetch(input, init); };
+  })`;
+    const wrapFetch = vmRunner.runInNewContext(wrapperScript, Object.create(null), {
+        filename: "eliza-fetch-wrapper",
+        timeout: 1_000,
+    });
+    context.fetch = wrapFetch(safeCodeFetch);
+    return await vmRunner.runInNewContext(`"use strict"; ${script}`, context, {
+        filename: "eliza-custom-action",
+        timeout: 30_000,
+    });
+}
+function shellEscape(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function isBlockedIp(ip) {
+    return isBlockedPrivateOrLinkLocalIp(ip);
+}
+function toRequestHeaders(headers) {
+    const normalized = {};
+    headers.forEach((value, key) => {
+        normalized[key] = value;
+    });
+    return normalized;
+}
+async function toRequestBodyBuffer(body) {
+    if (body === null || body === undefined)
+        return null;
+    if (typeof body === "string")
+        return Buffer.from(body);
+    if (body instanceof URLSearchParams)
+        return Buffer.from(body.toString());
+    if (body instanceof Blob)
+        return Buffer.from(await body.arrayBuffer());
+    if (body instanceof ArrayBuffer)
+        return Buffer.from(body);
+    if (ArrayBuffer.isView(body)) {
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    }
+    throw new Error("Unsupported request body type for custom action fetch");
+}
+function responseFromIncomingMessage(response) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(response.headers)) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                headers.append(key, item);
+        }
+        else if (typeof value === "string") {
+            headers.set(key, value);
+        }
+    }
+    const status = response.statusCode ?? 500;
+    const body = status === 204 || status === 205 || status === 304
+        ? null
+        : Readable.toWeb(response);
+    return new Response(body, {
+        status,
+        statusText: response.statusMessage,
+        headers,
+    });
+}
+async function requestWithPinnedAddress(input) {
+    const { url, init, target, timeoutMs } = input;
+    const method = (init.method ?? "GET").toUpperCase();
+    const headers = new Headers(init.headers);
+    const bodyBuffer = await toRequestBodyBuffer(init.body);
+    if (bodyBuffer && !headers.has("content-length")) {
+        headers.set("content-length", String(bodyBuffer.byteLength));
+    }
+    const requestFn = url.protocol === "https:" ? requestHttps : requestHttp;
+    const family = net.isIP(target.pinnedAddress) === 6 ? 6 : 4;
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const signal = init.signal;
+        let timeoutHandle = null;
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutHandle !== null)
+                clearTimeout(timeoutHandle);
+            signal?.removeEventListener("abort", onAbort);
+            callback();
+        };
+        const onAbort = () => {
+            request.destroy(new DOMException("Aborted", "AbortError"));
+        };
+        const requestOptions = {
+            protocol: url.protocol,
+            hostname: target.hostname,
+            port: url.port ? Number(url.port) : undefined,
+            method,
+            path: `${url.pathname}${url.search}`,
+            headers: toRequestHeaders(headers),
+            lookup: (_hostname, _options, callback) => {
+                callback(null, target.pinnedAddress, family);
+            },
+            ...(url.protocol === "https:"
+                ? { servername: target.hostname }
+                : undefined),
+        };
+        const request = requestFn(requestOptions, (response) => {
+            settle(() => resolve(responseFromIncomingMessage(response)));
+        });
+        request.on("error", (error) => {
+            settle(() => reject(error));
+        });
+        if (signal) {
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
+        }
+        timeoutHandle = setTimeout(() => {
+            request.destroy(new Error(`Custom action request timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        if (bodyBuffer) {
+            request.write(bodyBuffer);
+        }
+        request.end();
+    });
+}
+let pinnedFetchImpl = requestWithPinnedAddress;
+export function __setPinnedFetchImplForTests(impl) {
+    pinnedFetchImpl = impl ?? requestWithPinnedAddress;
+}
+async function resolveUrlSafety(url) {
+    try {
+        const parsed = new URL(url);
+        const hostname = normalizeHostLike(parsed.hostname);
+        if (!hostname)
+            return { blocked: true, target: null };
+        if ((hostname === "localhost" ||
+            hostname === "127.0.0.1" ||
+            hostname === "::1") &&
+            parsed.port === getApiPort()) {
+            return { blocked: false, target: null };
+        }
+        if (hostname === "localhost" ||
+            hostname === "127.0.0.1" ||
+            hostname === "::1" ||
+            hostname === "0.0.0.0" ||
+            hostname.endsWith(".local") ||
+            hostname === "[::1]" ||
+            hostname === "metadata.google.internal" ||
+            hostname === "169.254.169.254") {
+            return { blocked: true, target: null };
+        }
+        if (net.isIP(hostname)) {
+            if (isBlockedIp(hostname))
+                return { blocked: true, target: null };
+            return {
+                blocked: false,
+                target: {
+                    parsed,
+                    hostname,
+                    pinnedAddress: hostname,
+                },
+            };
+        }
+        const records = await dnsLookup(hostname, { all: true });
+        const addresses = Array.isArray(records) ? records : [records];
+        for (const entry of addresses) {
+            if (isBlockedIp(entry.address)) {
+                return { blocked: true, target: null };
+            }
+        }
+        return {
+            blocked: false,
+            target: {
+                parsed,
+                hostname,
+                pinnedAddress: addresses[0]?.address ?? "",
+            },
+        };
+    }
+    catch {
+        return { blocked: true, target: null };
+    }
+}
+async function buildPinnedFetchInit(input, init) {
+    if (typeof Request !== "undefined" && input instanceof Request) {
+        const headers = new Headers(input.headers);
+        if (init?.headers) {
+            const overrideHeaders = new Headers(init.headers);
+            overrideHeaders.forEach((value, key) => {
+                headers.set(key, value);
+            });
+        }
+        const method = init?.method ?? input.method;
+        const bodyFromInit = init?.body;
+        const bodyFromRequest = bodyFromInit !== undefined
+            ? undefined
+            : method === "GET" || method === "HEAD"
+                ? undefined
+                : await input.clone().arrayBuffer();
+        return {
+            ...init,
+            method,
+            headers,
+            body: bodyFromInit ?? bodyFromRequest,
+            signal: init?.signal ?? input.signal,
+            redirect: "manual",
+        };
+    }
+    return {
+        ...init,
+        redirect: "manual",
+    };
+}
+async function fetchWithPinnedTarget(target, init, timeoutMs) {
+    if (!target.pinnedAddress) {
+        throw new Error("Blocked: cannot make requests to internal network addresses");
+    }
+    return pinnedFetchImpl({
+        url: target.parsed,
+        init,
+        target,
+        timeoutMs,
+    });
+}
+function buildHandler(handler, paramDefs) {
+    if (!VALID_HANDLER_TYPES.has(handler.type)) {
+        return async () => ({
+            ok: false,
+            output: `Unsupported handler type: ${handler.type}`,
+        });
+    }
+    switch (handler.type) {
+        case "http":
+            return async (params) => {
+                let url = handler.url;
+                let body = handler.bodyTemplate ?? "";
+                const headers = { ...handler.headers };
+                for (const p of paramDefs) {
+                    const value = params[p.name] ?? "";
+                    url = url.replaceAll(`{{${p.name}}}`, encodeURIComponent(value));
+                    body = body.replaceAll(`{{${p.name}}}`, value);
+                }
+                const safety = await resolveUrlSafety(url);
+                if (safety.blocked) {
+                    return {
+                        ok: false,
+                        output: "Blocked: cannot make requests to internal network addresses",
+                    };
+                }
+                if (!headers["Content-Type"] && body) {
+                    headers["Content-Type"] = "application/json";
+                }
+                const fetchOpts = {
+                    method: handler.method || "GET",
+                    headers,
+                    redirect: "manual",
+                };
+                if (body && handler.method !== "GET" && handler.method !== "HEAD") {
+                    fetchOpts.body = body;
+                }
+                const response = safety.target
+                    ? await fetchWithPinnedTarget(safety.target, fetchOpts, CUSTOM_ACTION_FETCH_TIMEOUT_MS)
+                    : await fetch(url, fetchOpts);
+                if (response.status >= 300 && response.status < 400) {
+                    return {
+                        ok: false,
+                        output: "Blocked: redirects are not allowed for HTTP custom actions",
+                    };
+                }
+                const text = await response.text();
+                return { ok: response.ok, output: text.slice(0, 4000) };
+            };
+        case "shell":
+            return async (params) => {
+                let command = handler.command;
+                for (const p of paramDefs) {
+                    const value = params[p.name] ?? "";
+                    command = command.replaceAll(`{{${p.name}}}`, shellEscape(value));
+                }
+                const response = await fetchWithTimeout(`http://localhost:${getApiPort()}/api/terminal/run`, {
+                    method: "POST",
+                    headers: (() => {
+                        const headers = {
+                            "Content-Type": "application/json",
+                        };
+                        const token = resolveApiToken(process.env);
+                        if (token) {
+                            headers.Authorization = /^Bearer\s+/i.test(token)
+                                ? token
+                                : `Bearer ${token}`;
+                        }
+                        return headers;
+                    })(),
+                    body: JSON.stringify({
+                        command,
+                        clientId: "runtime-shell-action",
+                    }),
+                }, CUSTOM_ACTION_SHELL_TIMEOUT_MS);
+                if (!response.ok) {
+                    return {
+                        ok: false,
+                        output: `Terminal request failed: HTTP ${response.status}`,
+                    };
+                }
+                return { ok: true, output: `Executed: ${command}` };
+            };
+        case "code":
+            return async (params) => {
+                const result = await runCodeHandler(handler.code, params);
+                const output = result !== undefined ? String(result) : "Done";
+                return { ok: true, output: output.slice(0, 4000) };
+            };
+        default:
+            return async () => ({ ok: false, output: "Unknown handler type" });
+    }
+}
+function defToAction(def) {
+    const handler = buildHandler(def.handler, def.parameters);
+    return {
+        name: def.name,
+        similes: def.similes ?? [],
+        description: def.description,
+        validate: async (runtime, message) => {
+            if (def.requiredRole && def.requiredRole !== "GUEST") {
+                const { hasRoleAccess } = await import("../security/access.js");
+                const allowed = await hasRoleAccess(runtime, message, def.requiredRole);
+                if (!allowed)
+                    return false;
+            }
+            return true;
+        },
+        handler: async (_runtime, _message, _state, options) => {
+            try {
+                const opts = options;
+                const params = {};
+                for (const p of def.parameters) {
+                    const value = opts?.parameters?.[p.name];
+                    if (typeof value === "string") {
+                        params[p.name] = value;
+                    }
+                    else if (value !== undefined && value !== null) {
+                        params[p.name] = String(value);
+                    }
+                    else if (p.required) {
+                        return {
+                            text: `Missing required parameter: ${p.name}`,
+                            success: false,
+                        };
+                    }
+                }
+                const result = await handler(params);
+                return {
+                    text: result.output,
+                    success: result.ok,
+                    data: { actionId: def.id, params },
+                };
+            }
+            catch (err) {
+                return {
+                    text: `Action failed: ${String(err)}`,
+                    success: false,
+                };
+            }
+        },
+        parameters: def.parameters.map((p) => ({
+            name: p.name,
+            description: p.description,
+            required: p.required,
+            schema: { type: "string" },
+        })),
+    };
+}
+export function loadCustomActions() {
+    try {
+        const config = loadElizaConfig();
+        const defs = config.customActions ?? [];
+        return defs.filter((d) => d.enabled).map(defToAction);
+    }
+    catch (err) {
+        logger.warn(`[custom-actions] Failed to load custom actions from config: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+export function buildTestHandler(def) {
+    return buildHandler(def.handler, def.parameters);
+}

package/packages/agent/src/runtime/default-knowledge.d.ts

@@ -0,0 +1,20 @@
+import { type AgentRuntime } from "@elizaos/core";
+export interface DefaultKnowledgeFragmentDefinition {
+    text: string;
+    embedding?: number[];
+}
+export interface DefaultKnowledgeDocumentDefinition {
+    key: string;
+    version: number;
+    filename: string;
+    contentType: string;
+    text: string;
+    fragments: readonly DefaultKnowledgeFragmentDefinition[];
+    metadata?: Record<string, unknown>;
+}
+export declare const ELIZA_OVERVIEW_TEXT = "Eliza is an autonomous agent powered by elizaOS, the agent framework. Users can ask Eliza to write code, add new skills, and trigger recurring workflows with heartbeats that run at regular intervals. Eliza Cloud is an open source cloud backend that simplifies deploying and delivering Eliza.";
+export declare const ELIZA_HISTORY_TEXT = "ELIZA was created by Joseph Weizenbaum at MIT in the mid-1960s and is widely regarded as one of the earliest chatbots. Its best-known script, DOCTOR, used pattern matching to imitate a Rogerian psychotherapist and showed how simple language rules could feel surprisingly conversational. ELIZA helped define the history of chatbots and influenced later work on conversational agents.";
+export declare const ELIZA_CLOUD_BASICS_TEXT = "Eliza Cloud is the managed backend and app platform for Eliza when cloud mode is enabled. Builders can create an app, keep its appId, use Cloud login and redirect flows so app users can authenticate against Cloud, route chat and media APIs through Cloud, monetize app usage with inference markup and purchase-share settings, and deploy Docker containers when an app needs server-side execution.";
+export declare const DEFAULT_KNOWLEDGE_DOCUMENTS: readonly DefaultKnowledgeDocumentDefinition[];
+export declare function seedBundledKnowledge(runtime: AgentRuntime, documents?: readonly DefaultKnowledgeDocumentDefinition[]): Promise<void>;
+//# sourceMappingURL=default-knowledge.d.ts.map

package/packages/agent/src/runtime/default-knowledge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-knowledge.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/default-knowledge.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,YAAY,EAMlB,MAAM,eAAe,CAAC;AAOvB,MAAM,WAAW,kCAAkC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,kCAAkC;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,SAAS,kCAAkC,EAAE,CAAC;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,eAAO,MAAM,mBAAmB,wSACuQ,CAAC;AAExS,eAAO,MAAM,kBAAkB,mYACmW,CAAC;AAEnY,eAAO,MAAM,uBAAuB,+YAC0W,CAAC;AAE/Y,eAAO,MAAM,2BAA2B,EAAE,SAAS,kCAAkC,EAsClF,CAAC;AAuTJ,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,YAAY,EACrB,SAAS,GAAE,SAAS,kCAAkC,EAAgC,GACrF,OAAO,CAAC,IAAI,CAAC,CAIf"}