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

package/dist/packages/agent/src/actions/extract-page.js

@@ -0,0 +1,153 @@
+import { logger } from "@elizaos/core";
+import { extractHostedCloudPage, isHostedCloudToolingConfigured, } from "../services/hosted-tools.js";
+function getMessageText(message) {
+    const content = message?.content;
+    if (typeof content === "string") {
+        return content;
+    }
+    return typeof content?.text === "string" ? content.text : "";
+}
+function extractFirstUrl(value) {
+    const match = value.match(/https?:\/\/[^\s<>"'`]+/i);
+    return match?.[0] ?? null;
+}
+function formatExtractPreview(markdown, html) {
+    const source = markdown?.trim() || html?.trim() || "";
+    if (!source) {
+        return "No page content was returned.";
+    }
+    return source.slice(0, 1_500);
+}
+export const extractPageAction = {
+    name: "EXTRACT_PAGE",
+    contexts: ["web", "browser", "documents"],
+    roleGate: { minRole: "OWNER" },
+    similes: ["SCRAPE_PAGE", "FETCH_PAGE", "READ_WEB_PAGE", "EXTRACT_WEB_PAGE"],
+    description: "Extract page content through Eliza Cloud hosted tools. Returns cleaned markdown plus optional HTML, links, screenshot data, and page metadata.",
+    descriptionCompressed: "extract page content through Eliza Cloud host tool return clean markdown plus optional HTML, link, screenshot data, page metadata",
+    validate: async (_runtime, _message, _state) => {
+        return isHostedCloudToolingConfigured(process.env);
+    },
+    handler: async (_runtime, message, _state, options) => {
+        if (!isHostedCloudToolingConfigured(process.env)) {
+            return {
+                text: "Page extraction requires Eliza Cloud hosted tools to be configured.",
+                success: false,
+                values: { success: false, error: "CLOUD_TOOLS_NOT_CONFIGURED" },
+                data: { actionName: "EXTRACT_PAGE" },
+            };
+        }
+        const params = options?.parameters;
+        const messageText = getMessageText(message);
+        const url = params?.url?.trim() || extractFirstUrl(messageText) || "";
+        if (!url) {
+            return {
+                text: "Please provide a page URL to extract.",
+                success: false,
+                values: { success: false, error: "EMPTY_URL" },
+                data: { actionName: "EXTRACT_PAGE" },
+            };
+        }
+        try {
+            logger.info(`[extract-page] Hosted extract: "${url}"`);
+            const result = await extractHostedCloudPage({
+                formats: params?.formats,
+                onlyMainContent: params?.onlyMainContent,
+                timeoutMs: params?.timeoutMs,
+                url,
+                waitFor: params?.waitFor,
+            });
+            return {
+                text: `Extracted ${result.url}\n\n${formatExtractPreview(result.markdown, result.html)}`,
+                success: true,
+                values: {
+                    success: true,
+                    linkCount: result.links.length,
+                    provider: result.provider,
+                },
+                data: {
+                    actionName: "EXTRACT_PAGE",
+                    ...result,
+                },
+            };
+        }
+        catch (error) {
+            const messageText = error instanceof Error ? error.message : "Hosted extraction failed";
+            logger.warn(`[extract-page] Hosted extract failed: ${messageText}`);
+            return {
+                text: `Page extraction failed: ${messageText}`,
+                success: false,
+                values: { success: false, error: "EXTRACT_FAILED" },
+                data: { actionName: "EXTRACT_PAGE", url },
+            };
+        }
+    },
+    parameters: [
+        {
+            name: "url",
+            description: "Page URL to extract",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "formats",
+            description: "Requested output formats",
+            required: false,
+            schema: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: ["html", "links", "markdown", "screenshot"],
+                },
+            },
+        },
+        {
+            name: "onlyMainContent",
+            description: "Prefer primary page content only",
+            required: false,
+            schema: { type: "boolean" },
+        },
+        {
+            name: "waitFor",
+            description: "Wait before extracting, in milliseconds",
+            required: false,
+            schema: { type: "number" },
+        },
+        {
+            name: "timeoutMs",
+            description: "Maximum extraction timeout in milliseconds",
+            required: false,
+            schema: { type: "number" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Pull the main content from https://example.com/blog/post-42 for me.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Extracted https://example.com/blog/post-42\n\n# Post 42 — a short summary of the article body.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Give me the text off this docs page: https://docs.elizaos.ai/guide",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Extracted https://docs.elizaos.ai/guide\n\n# Guide — intro paragraph and first section.",
+                },
+            },
+        ],
+    ],
+};

package/dist/packages/agent/src/actions/extract-params.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Self-correcting LLM-based parameter extraction for action handlers.
+ *
+ * Project policy:
+ *   - The action planner is the *primary* extractor of params.
+ *   - Handlers MUST NOT use regex / string matching for intent inference.
+ *   - But planners get params wrong frequently — small models drop fields,
+ *     misname keys, send strings as numbers, etc.
+ *   - When that happens, the action handler runs its OWN small LLM call
+ *     scoped to the conversation + action's parameter schema. The handler
+ *     never falls back to regex; it falls back to the LLM.
+ *
+ * This module provides one helper, `extractActionParamsViaLlm`, which any
+ * action handler can call when its incoming `params` are missing required
+ * fields. The handler prefers planner-supplied values (planner is
+ * authoritative); the helper only fills in missing slots.
+ *
+ * Usage in a handler:
+ *
+ *   const filled = await extractActionParamsViaLlm<MyParams>({
+ *     runtime, message, state,
+ *     actionName: "MESSAGE",
+ *     actionDescription: "Cross-channel inbox: triage / digest / respond / search...",
+ *     paramSchema: triageMessagesAction.parameters,
+ *     existingParams: planParams,
+ *     requiredFields: ["subaction"],
+ *   });
+ *   if (!filled.subaction) {
+ *     return cleanError("MISSING_SUBACTION");
+ *   }
+ *
+ * The helper:
+ *   - Inspects which required fields are missing from `existingParams`
+ *   - If none are missing, returns existingParams unchanged (no model call)
+ *   - Otherwise builds a focused JSON-extraction prompt with the action's
+ *     name, description, schema, the recent conversation, and the current
+ *     message
+ *   - Calls `runtime.useModel(ModelType.TEXT_SMALL)` and parses the JSON
+ *   - Merges extracted values UNDER existing planner values (planner wins
+ *     on every field)
+ *   - Returns silently with whatever was extractable; handler decides what
+ *     to do if the result is still incomplete.
+ */
+import { type IAgentRuntime, type Memory, ModelType, type State } from "@elizaos/core";
+/**
+ * Schema descriptor for a single action parameter — matches the shape used
+ * by Action.parameters, with the fields the extractor needs.
+ */
+export interface ParamSchemaDescriptor {
+    name: string;
+    description: string;
+    required?: boolean;
+    schema?: {
+        type?: string;
+        enum?: readonly string[] | string[];
+    };
+}
+export interface ExtractActionParamsArgs<T extends object = Record<string, unknown>> {
+    runtime: IAgentRuntime;
+    message: Memory;
+    state?: State;
+    /** Canonical action name (used in the prompt + log lines). */
+    actionName: string;
+    /** Plain-English description of what the action does. */
+    actionDescription: string;
+    /** Action.parameters schema (or a subset of it). */
+    paramSchema: readonly ParamSchemaDescriptor[];
+    /** Whatever the planner already supplied. */
+    existingParams: Partial<T>;
+    /**
+     * Names of fields the handler needs to proceed. If all of these are
+     * already present and non-null in existingParams, the helper short-
+     * circuits without calling the model.
+     */
+    requiredFields: ReadonlyArray<keyof T & string>;
+    /** Override the model tier (default: TEXT_SMALL). */
+    modelType?: (typeof ModelType)[keyof typeof ModelType];
+    /** Override how many recent messages to feed into the prompt (default 8). */
+    recentMessagesLimit?: number;
+}
+/**
+ * Run a small LLM extraction call to fill in missing required params from
+ * the conversation. Planner-supplied values always win; the helper only
+ * fills slots that are still missing.
+ */
+export declare function extractActionParamsViaLlm<T extends object = Record<string, unknown>>(args: ExtractActionParamsArgs<T>): Promise<Partial<T>>;
+//# sourceMappingURL=extract-params.d.ts.map

package/dist/packages/agent/src/actions/extract-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-params.d.ts","sourceRoot":"","sources":["../../../../../src/actions/extract-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAGL,KAAK,aAAa,EAElB,KAAK,MAAM,EACX,SAAS,EAET,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AAGvB;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC;CACjE;AAED,MAAM,WAAW,uBAAuB,CACtC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAE1C,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,8DAA8D;IAC9D,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,WAAW,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC9C,6CAA6C;IAC7C,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3B;;;;OAIG;IACH,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;IAChD,qDAAqD;IACrD,SAAS,CAAC,EAAE,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;IACvD,6EAA6E;IAC7E,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAID;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,IAAI,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAuEvD"}

package/dist/packages/agent/src/actions/extract-params.js

@@ -0,0 +1,187 @@
+/**
+ * Self-correcting LLM-based parameter extraction for action handlers.
+ *
+ * Project policy:
+ *   - The action planner is the *primary* extractor of params.
+ *   - Handlers MUST NOT use regex / string matching for intent inference.
+ *   - But planners get params wrong frequently — small models drop fields,
+ *     misname keys, send strings as numbers, etc.
+ *   - When that happens, the action handler runs its OWN small LLM call
+ *     scoped to the conversation + action's parameter schema. The handler
+ *     never falls back to regex; it falls back to the LLM.
+ *
+ * This module provides one helper, `extractActionParamsViaLlm`, which any
+ * action handler can call when its incoming `params` are missing required
+ * fields. The handler prefers planner-supplied values (planner is
+ * authoritative); the helper only fills in missing slots.
+ *
+ * Usage in a handler:
+ *
+ *   const filled = await extractActionParamsViaLlm<MyParams>({
+ *     runtime, message, state,
+ *     actionName: "MESSAGE",
+ *     actionDescription: "Cross-channel inbox: triage / digest / respond / search...",
+ *     paramSchema: triageMessagesAction.parameters,
+ *     existingParams: planParams,
+ *     requiredFields: ["subaction"],
+ *   });
+ *   if (!filled.subaction) {
+ *     return cleanError("MISSING_SUBACTION");
+ *   }
+ *
+ * The helper:
+ *   - Inspects which required fields are missing from `existingParams`
+ *   - If none are missing, returns existingParams unchanged (no model call)
+ *   - Otherwise builds a focused JSON-extraction prompt with the action's
+ *     name, description, schema, the recent conversation, and the current
+ *     message
+ *   - Calls `runtime.useModel(ModelType.TEXT_SMALL)` and parses the JSON
+ *   - Merges extracted values UNDER existing planner values (planner wins
+ *     on every field)
+ *   - Returns silently with whatever was extractable; handler decides what
+ *     to do if the result is still incomplete.
+ */
+import { composePrompt, extractActionParamsTemplate, logger, ModelType, parseJSONObjectFromText, } from "@elizaos/core";
+import { getRecentMessagesData } from "@elizaos/shared";
+const DEFAULT_RECENT_MESSAGES_LIMIT = 8;
+/**
+ * Run a small LLM extraction call to fill in missing required params from
+ * the conversation. Planner-supplied values always win; the helper only
+ * fills slots that are still missing.
+ */
+export async function extractActionParamsViaLlm(args) {
+    const { runtime, message, state, actionName, actionDescription, paramSchema, existingParams, requiredFields, modelType = ModelType.TEXT_SMALL, recentMessagesLimit = DEFAULT_RECENT_MESSAGES_LIMIT, } = args;
+    const missing = requiredFields.filter((field) => {
+        const value = existingParams[field];
+        return value === undefined || value === null || value === "";
+    });
+    if (missing.length === 0) {
+        return existingParams;
+    }
+    const currentMessageText = typeof message.content?.text === "string"
+        ? message.content.text.trim()
+        : "";
+    const recentConversation = collectRecentConversation(state, recentMessagesLimit);
+    const prompt = buildExtractionPrompt({
+        actionName,
+        actionDescription,
+        paramSchema,
+        existingParams,
+        missingFields: missing,
+        currentMessageText,
+        recentConversation,
+    });
+    let response;
+    try {
+        const raw = await runtime.useModel(modelType, {
+            prompt,
+            stopSequences: [],
+        });
+        response = typeof raw === "string" ? raw : String(raw ?? "");
+    }
+    catch (err) {
+        logger.warn(`[${actionName}] LLM param extraction failed: ${err instanceof Error ? err.message : String(err)}`);
+        return existingParams;
+    }
+    const extracted = parseExtraction(response);
+    if (!extracted) {
+        return existingParams;
+    }
+    // Merge: extracted fills in missing slots only. Planner values always win
+    // on collisions because the planner saw the full action surface.
+    const merged = { ...extracted };
+    for (const [key, value] of Object.entries(existingParams)) {
+        if (value !== undefined && value !== null && value !== "") {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+function collectRecentConversation(state, limit) {
+    if (!state)
+        return "";
+    const messages = getRecentMessagesData(state).slice(-limit);
+    if (messages.length === 0)
+        return "";
+    return messages
+        .map((m) => {
+        const content = m.content && typeof m.content === "object"
+            ? m.content
+            : null;
+        const text = typeof content?.text === "string" ? content.text.trim() : "";
+        const speaker = getMemorySpeakerName(m);
+        return text ? `${speaker}: ${text}` : null;
+    })
+        .filter((line) => line !== null)
+        .join("\n");
+}
+function getMemorySpeakerName(memory) {
+    const metadata = memory.metadata;
+    if (!metadata)
+        return "user";
+    if ("sender" in metadata &&
+        metadata.sender &&
+        typeof metadata.sender === "object" &&
+        "name" in metadata.sender &&
+        typeof metadata.sender.name === "string") {
+        return metadata.sender.name;
+    }
+    if ("entityName" in metadata && typeof metadata.entityName === "string") {
+        return metadata.entityName;
+    }
+    if ("entityUserName" in metadata &&
+        typeof metadata.entityUserName === "string") {
+        return metadata.entityUserName;
+    }
+    return "user";
+}
+function buildExtractionPrompt(args) {
+    const { actionName, actionDescription, paramSchema, existingParams, missingFields, currentMessageText, recentConversation, } = args;
+    const schemaLines = paramSchema
+        .map((p) => {
+        const enumPart = p.schema?.enum
+            ? ` [one of: ${p.schema.enum.join(" | ")}]`
+            : "";
+        const typePart = p.schema?.type ? ` (${p.schema.type})` : "";
+        const requiredPart = missingFields.includes(p.name) ? " [REQUIRED]" : "";
+        return `  - ${p.name}${typePart}${enumPart}${requiredPart}: ${p.description}`;
+    })
+        .join("\n");
+    const existingJson = JSON.stringify(existingParams ?? {}, null, 0);
+    const recentConversationBlock = recentConversation
+        ? `Recent conversation (oldest first):\n${recentConversation}`
+        : "(no recent conversation context)";
+    return composePrompt({
+        state: {
+            actionName,
+            actionDescription,
+            schemaLines,
+            existingJson,
+            missingFields: missingFields.join(", "),
+            recentConversationBlock,
+            currentMessageText: currentMessageText || "(empty)",
+        },
+        template: extractActionParamsTemplate,
+    });
+}
+function parseExtraction(text) {
+    if (!text.trim())
+        return null;
+    try {
+        const parsed = parseJSONObjectFromText(text);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            // Drop null-valued fields so they don't overwrite planner-supplied
+            // values during the merge step.
+            const out = {};
+            for (const [k, v] of Object.entries(parsed)) {
+                if (v !== null)
+                    out[k] = v;
+            }
+            return out;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}

package/dist/packages/agent/src/actions/grounded-action-reply.d.ts

@@ -0,0 +1,22 @@
+import type { ActionResult, IAgentRuntime, Memory, State } from "@elizaos/core";
+type GroundedReplyDomain = "lifeops" | "gmail" | "calendar";
+type RenderGroundedActionReplyArgs = {
+    runtime: IAgentRuntime;
+    message: Memory;
+    state: State | undefined;
+    intent: string;
+    domain: GroundedReplyDomain;
+    scenario: string;
+    fallback: string;
+    context?: Record<string, unknown>;
+    additionalRules?: string[];
+    preferCharacterVoice?: boolean;
+};
+export declare function extractActionResultsFromState(state: State | undefined): ActionResult[];
+export declare function extractRecentMessageEntriesFromState(state: State | undefined): Memory[];
+export declare function extractStateDataRecords(state: State | undefined): Record<string, unknown>[];
+export declare function summarizeRecentActionHistory(state: State | undefined, limit?: number): string[];
+export declare function summarizeActiveTrajectory(runtime: IAgentRuntime): Promise<string | null>;
+export declare function renderGroundedActionReply(args: RenderGroundedActionReplyArgs): Promise<string>;
+export {};
+//# sourceMappingURL=grounded-action-reply.d.ts.map

package/dist/packages/agent/src/actions/grounded-action-reply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounded-action-reply.d.ts","sourceRoot":"","sources":["../../../../../src/actions/grounded-action-reply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAUhF,KAAK,mBAAmB,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;AAE5D,KAAK,6BAA6B,GAAG;IACnC,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,mBAAmB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAoEF,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,KAAK,GAAG,SAAS,GACvB,YAAY,EAAE,CAmChB;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,KAAK,GAAG,SAAS,GACvB,MAAM,EAAE,CAEV;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,KAAK,GAAG,SAAS,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAuB3B;AAiCD,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,KAAK,SAAI,GACR,MAAM,EAAE,CAsBV;AA4CD,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA0CxB;AAaD,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,6BAA6B,GAClC,OAAO,CAAC,MAAM,CAAC,CA8DjB"}