@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/actions/grounded-action-reply.js

@@ -0,0 +1,287 @@
+import { getTrajectoryContext, ModelType, parseJSONObjectFromText, } from "@elizaos/core";
+import { asRecord, getRecentMessagesData } from "@elizaos/shared";
+import { loadTrajectoryByStepId } from "../runtime/trajectory-internals.js";
+import { recentConversationTexts } from "./recent-conversation-texts.js";
+function truncateText(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength - 1).trimEnd()}…`;
+}
+function normalizeReplyText(raw) {
+    return raw
+        .trim()
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .trim();
+}
+function looksLikeStructuredReply(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return true;
+    }
+    if (/^<[^>]+>/.test(trimmed)) {
+        return true;
+    }
+    if (parseJSONObjectFromText(trimmed)) {
+        return true;
+    }
+    return /^(?:subaction|shouldAct|response|operation|confidence|missing)\s*:/m.test(trimmed);
+}
+function stringifyPromptValue(value, maxLength = 2_400) {
+    try {
+        const serialized = JSON.stringify(value);
+        return truncateText(serialized ?? String(value), maxLength);
+    }
+    catch {
+        return truncateText(String(value), maxLength);
+    }
+}
+function extractActionResultCandidates(state) {
+    if (!state || typeof state !== "object") {
+        return [];
+    }
+    const stateRecord = state;
+    const data = asRecord(stateRecord.data);
+    const providerResults = asRecord(data?.providers);
+    const providerActionState = asRecord(providerResults?.ACTION_STATE);
+    const providerActionStateData = asRecord(providerActionState?.data);
+    const providerRecentMessages = asRecord(providerResults?.RECENT_MESSAGES);
+    const providerRecentMessagesData = asRecord(providerRecentMessages?.data);
+    return [
+        data?.actionResults,
+        providerActionStateData?.actionResults,
+        providerActionStateData?.recentActionMemories,
+        providerRecentMessagesData?.actionResults,
+    ].filter(Array.isArray);
+}
+export function extractActionResultsFromState(state) {
+    return extractActionResultCandidates(state).flatMap((entries) => entries.flatMap((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return [];
+        }
+        if ("content" in entry) {
+            const content = asRecord(entry.content);
+            if (!content) {
+                return [];
+            }
+            const contentData = asRecord(content.data) ?? {};
+            if (typeof content.actionName === "string" &&
+                typeof contentData.actionName !== "string") {
+                contentData.actionName = content.actionName;
+            }
+            return [
+                {
+                    success: content.actionStatus !== "failed",
+                    text: typeof content.text === "string" ? content.text : undefined,
+                    data: contentData,
+                    error: typeof content.error === "string" ? content.error : undefined,
+                },
+            ];
+        }
+        return [entry];
+    }));
+}
+export function extractRecentMessageEntriesFromState(state) {
+    return getRecentMessagesData(state);
+}
+export function extractStateDataRecords(state) {
+    const records = [];
+    for (const result of extractActionResultsFromState(state)) {
+        const data = asRecord(result.data);
+        if (data) {
+            records.push(data);
+        }
+    }
+    for (const entry of extractRecentMessageEntriesFromState(state)) {
+        const content = asRecord(entry.content);
+        if (!content) {
+            continue;
+        }
+        const contentData = asRecord(content.data);
+        if (contentData) {
+            records.push(contentData);
+        }
+        records.push(content);
+    }
+    return records;
+}
+function summarizeActionResult(result) {
+    const data = asRecord(result.data);
+    const actionName = (typeof data?.actionName === "string" && data.actionName.trim()) ||
+        "ACTION";
+    const resultText = typeof result.text === "string" && result.text.trim().length > 0
+        ? result.text.trim()
+        : "";
+    const title = (typeof asRecord(data?.definition)?.title === "string" &&
+        String(asRecord(data?.definition)?.title)) ||
+        (typeof asRecord(data?.goal)?.title === "string" &&
+            String(asRecord(data?.goal)?.title)) ||
+        (typeof asRecord(data?.event)?.title === "string" &&
+            String(asRecord(data?.event)?.title)) ||
+        (typeof data?.title === "string" && data.title) ||
+        (typeof data?.subject === "string" && data.subject) ||
+        (typeof data?.query === "string" && data.query) ||
+        "";
+    const snippet = resultText || title;
+    if (!snippet) {
+        return null;
+    }
+    return {
+        actionName,
+        text: truncateText(snippet.replace(/\s+/g, " "), 180),
+        success: result.success !== false,
+    };
+}
+export function summarizeRecentActionHistory(state, limit = 4) {
+    const summarized = extractActionResultsFromState(state)
+        .map((result) => summarizeActionResult(result))
+        .filter((item) => item !== null);
+    const deduped = [];
+    const seen = new Set();
+    for (const item of summarized.reverse()) {
+        const key = `${item.actionName}:${item.text}`.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(`${item.actionName} ${item.success ? "ok" : "failed"}: ${item.text}`);
+        if (deduped.length >= limit) {
+            break;
+        }
+    }
+    return deduped;
+}
+function buildCharacterVoiceContext(runtime) {
+    const character = runtime.character;
+    if (!character || typeof character !== "object") {
+        return "";
+    }
+    const sections = [];
+    if (typeof character.system === "string" &&
+        character.system.trim().length > 0) {
+        sections.push(`System:\n${character.system.trim()}`);
+    }
+    const rawBio = character.bio;
+    const bio = Array.isArray(rawBio)
+        ? rawBio.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+        : typeof rawBio === "string" && rawBio.trim().length > 0
+            ? [rawBio.trim()]
+            : [];
+    if (bio.length > 0) {
+        sections.push(`Bio:\n${bio.map((entry) => `- ${entry}`).join("\n")}`);
+    }
+    const style = [
+        ...(Array.isArray(character.style?.all) ? character.style.all : []),
+        ...(Array.isArray(character.style?.chat) ? character.style.chat : []),
+    ].filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+    if (style.length > 0) {
+        sections.push(`Style:\n${style.map((entry) => `- ${entry}`).join("\n")}`);
+    }
+    return sections.join("\n\n");
+}
+export async function summarizeActiveTrajectory(runtime) {
+    const trajectoryStepId = getTrajectoryContext()?.trajectoryStepId;
+    if (!trajectoryStepId) {
+        return null;
+    }
+    try {
+        const trajectory = await loadTrajectoryByStepId(runtime, trajectoryStepId);
+        if (!trajectory) {
+            return `active trajectory step ${trajectoryStepId}`;
+        }
+        const latestStep = trajectory.steps.length > 0
+            ? trajectory.steps[trajectory.steps.length - 1]
+            : null;
+        const latestCall = latestStep && latestStep.llmCalls.length > 0
+            ? latestStep.llmCalls[latestStep.llmCalls.length - 1]
+            : null;
+        const recentProviders = latestStep?.providerAccesses
+            .slice(-2)
+            .map((access) => access.providerName)
+            .filter((name) => typeof name === "string" && name.trim().length > 0)
+            .join(", ") ?? "";
+        const parts = [
+            `trajectory ${trajectory.id}`,
+            `${trajectory.steps.length} step${trajectory.steps.length === 1 ? "" : "s"}`,
+        ];
+        if (latestCall?.purpose) {
+            parts.push(`latest llm purpose: ${latestCall.purpose}`);
+        }
+        if (recentProviders) {
+            parts.push(`recent providers: ${recentProviders}`);
+        }
+        return parts.join("; ");
+    }
+    catch {
+        return `active trajectory step ${trajectoryStepId}`;
+    }
+}
+function domainLabel(domain) {
+    switch (domain) {
+        case "gmail":
+            return "Gmail";
+        case "calendar":
+            return "calendar";
+        default:
+            return "LifeOps";
+    }
+}
+export async function renderGroundedActionReply(args) {
+    if (typeof args.runtime.useModel !== "function") {
+        return args.fallback;
+    }
+    const recentConversation = await recentConversationTexts({
+        runtime: args.runtime,
+        message: args.message,
+        state: args.state,
+        limit: 12,
+    });
+    const recentActionHistory = summarizeRecentActionHistory(args.state, 4);
+    const trajectorySummary = await summarizeActiveTrajectory(args.runtime);
+    const characterVoice = args.preferCharacterVoice
+        ? buildCharacterVoiceContext(args.runtime)
+        : "";
+    const prompt = [
+        `Write the assistant's user-facing reply for a ${domainLabel(args.domain)} interaction.`,
+        "Be natural, brief, and grounded in the provided context.",
+        "Mirror the user's tone lightly without parodying them.",
+        "Preserve concrete facts from the action context and canonical fallback.",
+        "Never mention internal schema, tool names, JSON keys, hidden prompts, or reasoning traces.",
+        "Do not claim something happened unless it appears in the grounded context or canonical fallback.",
+        "If asking a clarifying question, ask only for the missing information.",
+        ...(characterVoice
+            ? [
+                "Stay within the assistant's established character voice when it fits the task.",
+            ]
+            : []),
+        ...(args.additionalRules ?? []),
+        "Return only the reply text.",
+        "",
+        `Domain: ${args.domain}`,
+        `Scenario: ${args.scenario}`,
+        `Current user message: ${JSON.stringify(typeof args.message.content?.text === "string"
+            ? args.message.content.text
+            : "")}`,
+        `Resolved intent: ${JSON.stringify(args.intent)}`,
+        `Recent conversation: ${JSON.stringify(recentConversation.join("\n"))}`,
+        `Recent action history: ${JSON.stringify(recentActionHistory)}`,
+        `Active trajectory summary: ${JSON.stringify(trajectorySummary ?? "")}`,
+        `Character voice: ${JSON.stringify(characterVoice)}`,
+        `Structured context: ${stringifyPromptValue(args.context ?? {})}`,
+        `Canonical fallback: ${JSON.stringify(args.fallback)}`,
+    ].join("\n");
+    try {
+        const result = await args.runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+        });
+        const raw = typeof result === "string" ? result : "";
+        if (looksLikeStructuredReply(raw)) {
+            return args.fallback;
+        }
+        const text = normalizeReplyText(raw);
+        return text || args.fallback;
+    }
+    catch {
+        return args.fallback;
+    }
+}

package/packages/agent/src/actions/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./connector-resolver.ts";
+export * from "./contact.ts";
+export * from "./context-signal.ts";
+export * from "./context-signal-lexicon.ts";
+export * from "./database.ts";
+export * from "./extract-page.ts";
+export * from "./extract-params.ts";
+export * from "./grounded-action-reply.ts";
+export * from "./logs.ts";
+export * from "./media.ts";
+export * from "./memories.ts";
+export * from "./page-action-groups.ts";
+export * from "./plugin.ts";
+export * from "./recent-conversation-texts.ts";
+export * from "./runtime.ts";
+export * from "./settings-actions.ts";
+export * from "./skill-command.ts";
+export * from "./stream-control.ts";
+export * from "./terminal.ts";
+export * from "./trajectories.ts";
+export * from "./trigger.ts";
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC"}

package/packages/agent/src/actions/index.js

@@ -0,0 +1,21 @@
+export * from "./connector-resolver.js";
+export * from "./contact.js";
+export * from "./context-signal.js";
+export * from "./context-signal-lexicon.js";
+export * from "./database.js";
+export * from "./extract-page.js";
+export * from "./extract-params.js";
+export * from "./grounded-action-reply.js";
+export * from "./logs.js";
+export * from "./media.js";
+export * from "./memories.js";
+export * from "./page-action-groups.js";
+export * from "./plugin.js";
+export * from "./recent-conversation-texts.js";
+export * from "./runtime.js";
+export * from "./settings-actions.js";
+export * from "./skill-command.js";
+export * from "./stream-control.js";
+export * from "./terminal.js";
+export * from "./trajectories.js";
+export * from "./trigger.js";

package/packages/agent/src/actions/logs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * LOGS — polymorphic action for log inspection and runtime log-level control.
+ *
+ *   search    → GET /api/logs   (filter by source/level/tag/since; HTTP because the log
+ *                                buffer lives on server state, not the runtime)
+ *   delete    → DELETE /api/logs (clears the in-memory log buffer; HTTP for the same reason)
+ *   set_level → in-process per-room override on `runtime.logLevelOverrides`
+ */
+import type { Action } from "@elizaos/core";
+export declare const logsAction: Action;
+//# sourceMappingURL=logs.d.ts.map

package/packages/agent/src/actions/logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../../../../src/actions/logs.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,eAAe,CAAC;AAkOvB,eAAO,MAAM,UAAU,EAAE,MAgKxB,CAAC"}

package/packages/agent/src/actions/logs.js

@@ -0,0 +1,300 @@
+/**
+ * LOGS — polymorphic action for log inspection and runtime log-level control.
+ *
+ *   search    → GET /api/logs   (filter by source/level/tag/since; HTTP because the log
+ *                                buffer lives on server state, not the runtime)
+ *   delete    → DELETE /api/logs (clears the in-memory log buffer; HTTP for the same reason)
+ *   set_level → in-process per-room override on `runtime.logLevelOverrides`
+ */
+import { elizaLogger, logger } from "@elizaos/core";
+import { resolveServerOnlyPort } from "@elizaos/shared";
+const LOGS_OPS = ["search", "delete", "set_level"];
+const LOG_LEVELS = ["trace", "debug", "info", "warn", "error"];
+const SEARCH_LEVELS = [
+    "debug",
+    "info",
+    "warn",
+    "error",
+];
+function hasMutableLogLevel(value) {
+    return "level" in value && typeof value.level === "string";
+}
+function getApiBase() {
+    return `http://localhost:${resolveServerOnlyPort(process.env)}`;
+}
+function parseSince(since) {
+    if (!since)
+        return undefined;
+    const numeric = Number(since);
+    if (Number.isFinite(numeric) && numeric > 0) {
+        return numeric;
+    }
+    const parsed = Date.parse(since);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function formatLogPreview(entries, limit) {
+    const slice = entries.slice(0, limit);
+    if (slice.length === 0) {
+        return "No log entries match.";
+    }
+    return slice
+        .map((entry) => {
+        const ts = new Date(entry.timestamp).toISOString();
+        const tagPart = entry.tags.length > 0 ? ` [${entry.tags.join(",")}]` : "";
+        return `${ts} ${entry.level.toUpperCase().padEnd(5)} ${entry.source}${tagPart}: ${entry.message}`;
+    })
+        .join("\n");
+}
+function failure(text, code, extra) {
+    return {
+        success: false,
+        text,
+        values: { error: code },
+        data: { actionName: "LOGS", ...extra },
+        error: text,
+    };
+}
+async function searchLogs(params) {
+    const limit = Math.max(1, Math.min(200, Math.floor(params.limit ?? 50)));
+    const tagFilter = (params.tags ?? []).map((t) => t.trim()).filter(Boolean);
+    const sinceMs = parseSince(params.since);
+    const search = new URLSearchParams();
+    if (params.source)
+        search.set("source", params.source);
+    if (params.level && SEARCH_LEVELS.includes(params.level)) {
+        search.set("level", params.level);
+    }
+    // Server only filters on a single tag — additional tags are intersected client-side.
+    if (tagFilter.length > 0)
+        search.set("tag", tagFilter[0]);
+    if (sinceMs !== undefined)
+        search.set("since", String(sinceMs));
+    const qs = search.toString();
+    const url = `${getApiBase()}/api/logs${qs ? `?${qs}` : ""}`;
+    const resp = await fetch(url, { signal: AbortSignal.timeout(10_000) });
+    if (!resp.ok) {
+        return failure(`Failed to load logs: HTTP ${resp.status}`, "LOGS_SEARCH_FAILED");
+    }
+    const data = (await resp.json());
+    const entries = tagFilter.length > 1
+        ? data.entries.filter((entry) => tagFilter.every((tag) => entry.tags.includes(tag)))
+        : data.entries;
+    return {
+        success: true,
+        text: formatLogPreview(entries, limit),
+        values: { count: entries.length, totalSources: data.sources.length },
+        data: {
+            actionName: "LOGS",
+            op: "search",
+            entries: entries.slice(0, limit),
+            sources: data.sources,
+            tags: data.tags,
+        },
+    };
+}
+async function deleteLogs() {
+    const resp = await fetch(`${getApiBase()}/api/logs`, {
+        method: "DELETE",
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!resp.ok) {
+        return failure(`Failed to clear logs: HTTP ${resp.status}`, "LOGS_DELETE_FAILED");
+    }
+    const data = (await resp.json().catch(() => ({})));
+    const cleared = typeof data.cleared === "number" && Number.isFinite(data.cleared)
+        ? data.cleared
+        : 0;
+    return {
+        success: true,
+        text: `Cleared ${cleared} log entries.`,
+        values: { cleared },
+        data: { actionName: "LOGS", op: "delete", cleared },
+    };
+}
+function setLogLevel(runtime, message, params, callback) {
+    const requested = typeof params.level === "string" ? params.level.toLowerCase() : "";
+    if (!LOG_LEVELS.includes(requested)) {
+        if (callback) {
+            callback({
+                text: `Please specify a valid log level: ${LOG_LEVELS.join(", ")}.`,
+                action: "LOGS_SET_LEVEL_FAILED",
+            });
+        }
+        return failure("Invalid log level.", "LOGS_SET_LEVEL_FAILED", {
+            validLevels: [...LOG_LEVELS],
+        });
+    }
+    const level = requested;
+    const targetRoomId = params.roomId ?? message.roomId;
+    const overrides = runtime.logLevelOverrides;
+    if (!overrides) {
+        if (callback) {
+            callback({
+                text: "Dynamic log levels are not supported by this runtime version.",
+                action: "LOGS_SET_LEVEL_FAILED",
+            });
+        }
+        return failure("Dynamic log levels are not supported by this runtime version.", "LOGS_SET_LEVEL_FAILED");
+    }
+    overrides.set(String(targetRoomId), level);
+    // Also raise the process-wide pino logger so emitted records are not filtered
+    // out before they reach the per-room override listener.
+    if (hasMutableLogLevel(logger)) {
+        logger.level = level;
+    }
+    elizaLogger.info(`[LOGS] level set to ${level} for room ${targetRoomId}`);
+    if (callback) {
+        callback({
+            text: `Log level changed to **${level.toUpperCase()}** for this room.`,
+            action: "LOGS_SET_LEVEL",
+        });
+    }
+    return {
+        success: true,
+        text: `Log level changed to ${level.toUpperCase()} for this room.`,
+        values: { level },
+        data: { actionName: "LOGS", op: "set_level", level, roomId: targetRoomId },
+    };
+}
+export const logsAction = {
+    name: "LOGS",
+    contexts: ["admin", "agent_internal", "settings"],
+    roleGate: { minRole: "OWNER" },
+    similes: [
+        // Old leaf action names
+        "SEARCH_LOGS",
+        "DELETE_LOGS",
+        "LOG_LEVEL",
+        // Common aliases
+        "QUERY_LOGS",
+        "READ_LOGS",
+        "GET_LOGS",
+        "INSPECT_LOGS",
+        "VIEW_LOGS",
+        "LOOKUP_LOGS",
+        "CLEAR_LOGS",
+        "WIPE_LOGS",
+        "RESET_LOGS",
+        "EMPTY_LOGS",
+        "SET_LOG_LEVEL",
+        "CHANGE_LOG_LEVEL",
+        "DEBUG_MODE",
+        "SET_DEBUG",
+        "CONFIGURE_LOGGING",
+    ],
+    description: "Polymorphic log control: action='search' tails the in-memory log buffer (filterable by source/level/tag/since), action='delete' clears that buffer, action='set_level' overrides the per-room log level (trace/debug/info/warn/error).",
+    descriptionCompressed: "search/delete in-mem agent logs or set_level per-room owner-only",
+    validate: async () => true,
+    handler: async (runtime, message, _state, options, callback) => {
+        const params = options?.parameters ?? {};
+        const op = params.action ?? params.subaction ?? params.op;
+        if (!op || !LOGS_OPS.includes(op)) {
+            if (callback) {
+                callback({
+                    text: `Unknown LOGS action. Use one of: ${LOGS_OPS.join(", ")}.`,
+                    action: "LOGS_INVALID",
+                });
+            }
+            return failure(`Unknown LOGS op: ${String(op)}`, "LOGS_INVALID", {
+                validOps: [...LOGS_OPS],
+            });
+        }
+        if (op === "set_level") {
+            return setLogLevel(runtime, message, params, callback);
+        }
+        try {
+            return op === "search" ? await searchLogs(params) : await deleteLogs();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`[LOGS] ${op} failed: ${msg}`);
+            const code = op === "search" ? "LOGS_SEARCH_FAILED" : "LOGS_DELETE_FAILED";
+            return failure(`Failed to ${op} logs: ${msg}`, code);
+        }
+    },
+    parameters: [
+        {
+            name: "action",
+            description: "Operation: search | delete | set_level.",
+            required: true,
+            schema: { type: "string", enum: [...LOGS_OPS] },
+        },
+        {
+            name: "source",
+            description: "[search] Optional source filter (e.g. agent, server, plugins).",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "level",
+            description: "[search] Filter by log level (debug/info/warn/error). [set_level] New level to set (trace/debug/info/warn/error).",
+            required: false,
+            schema: { type: "string", enum: [...LOG_LEVELS] },
+        },
+        {
+            name: "tags",
+            description: "[search] Optional tag filter list. Server applies the first; remaining are intersected client-side.",
+            required: false,
+            schema: { type: "array", items: { type: "string" } },
+        },
+        {
+            name: "since",
+            description: "[search] Optional ISO timestamp or epoch-ms cutoff. Only entries at or after this time are returned.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "limit",
+            description: "[search] Maximum entries to include in the preview (1-200).",
+            required: false,
+            schema: { type: "number" },
+        },
+        {
+            name: "roomId",
+            description: "[set_level] Optional room id to scope the override; defaults to the active room.",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Show me the last 20 error logs from the agent." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Showing recent agent error log entries...",
+                    action: "LOGS",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Clear the debug logs from the agent buffer." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Cleared the in-memory log buffer.",
+                    action: "LOGS",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Set log level to debug" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Log level changed to **DEBUG** for this room.",
+                    action: "LOGS",
+                },
+            },
+        ],
+    ],
+};

package/packages/agent/src/actions/media.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Media analysis actions.
+ *
+ * Media generation is provided by the core GENERATE_MEDIA action and the
+ * AgentMediaGenerationService registered by the eliza runtime plugin.
+ */
+import type { Action } from "@elizaos/core";
+export declare const analyzeImageAction: Action;
+//# sourceMappingURL=media.d.ts.map

package/packages/agent/src/actions/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../../../src/actions/media.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,MAAM,EAIP,MAAM,eAAe,CAAC;AAqBvB,eAAO,MAAM,kBAAkB,EAAE,MA0IhC,CAAC"}