@elizaos/app-core 2.0.0-alpha.215 → 2.0.0-alpha.223

package/apps/app-companion/src/actions/emote.js

@@ -5,7 +5,7 @@
  * companion app. Session gating is applied at the plugin level
  * (`gatePluginSessionForHostedApp`).
  */
-import { hasRoleAccess } from "@elizaos/agent/security/access";
+import { hasRoleAccess } from "@elizaos/agent/security";
 import { AGENT_EMOTE_BY_ID, AGENT_EMOTE_CATALOG } from "../emotes/catalog.js";
 /** API port for posting emote requests (matches dashboard static server default). */
 const API_PORT = process.env.API_PORT || process.env.SERVER_PORT || "2138";

package/apps/app-elizamaker/src/twitter-verify.js

@@ -10,7 +10,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { logger } from "@elizaos/core";
 import { resolveStateDir } from "@elizaos/agent/config/paths";
-import { createIntegrationTelemetrySpan } from "@elizaos/agent/diagnostics/integration-observability";
+import { createIntegrationTelemetrySpan } from "@elizaos/agent/diagnostics";
 const WHITELIST_FILE = "whitelist.json";
 // ── Verification Message ─────────────────────────────────────────────────
 export function generateVerificationMessage(agentName, walletAddress) {

package/apps/app-lifeops/src/action.js

@@ -1,4 +1,4 @@
-import { hasAdminAccess } from "@elizaos/agent/security/access";
+import { hasAdminAccess } from "@elizaos/agent/security";
 import { LifeOpsService, LifeOpsServiceError } from "./lifeops/service.js";
 const URL_RE = /https?:\/\/[^\s)]+/i;
 function getMessageText(message) {

package/apps/app-lifeops/src/actions/app-blocker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app-blocker.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/app-blocker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAwMvB,eAAO,MAAM,eAAe,EAAE,MAAM,GAAG;IACrC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAmN1C,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,MA6D/B,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MA2ErC,CAAC"}
+{"version":3,"file":"app-blocker.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/app-blocker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AA2MvB,eAAO,MAAM,eAAe,EAAE,MAAM,GAAG;IACrC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAwN1C,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,MA6D/B,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MA2ErC,CAAC"}

package/apps/app-lifeops/src/actions/app-blocker.js

@@ -5,6 +5,7 @@ import { recentConversationTexts as collectRecentConversationTexts } from "./lif
 function getMessageText(message) {
     return typeof message.content?.text === "string" ? message.content.text : "";
 }
+const APP_BLOCK_INTENT_RE = /\b(block|blocking|blocked|unblock|unblocking|shield|app block|block apps|phone apps|focus mode|restrict apps)\b/i;
 function normalizeShouldAct(value) {
     if (typeof value === "boolean") {
         return value;
@@ -159,7 +160,7 @@ export const blockAppsAction = {
     suppressPostActionContinuation: true,
     validate: async (runtime, message) => {
         const access = await getAppBlockerAccess(runtime, message);
-        return access.allowed;
+        return access.allowed && APP_BLOCK_INTENT_RE.test(getMessageText(message));
     },
     handler: async (runtime, message, state, options) => {
         const access = await getAppBlockerAccess(runtime, message);
@@ -215,12 +216,17 @@ export const blockAppsAction = {
             explicitPackageNames.length === 0 &&
             !appTokens) {
             return {
-                success: true,
+                success: false,
                 text: llmPlan.response ??
                     (status.platform === "ios"
                         ? "Select the iPhone apps in the mobile app picker first, then I can start the block."
                         : "Tell me which installed apps to block so I can match them exactly on your device."),
-                data: { noop: true },
+                values: {
+                    success: false,
+                    error: "PLANNER_SHOULDACT_FALSE",
+                    noop: true,
+                },
+                data: { noop: true, error: "PLANNER_SHOULDACT_FALSE" },
             };
         }
         const packageNames = explicitPackageNames.length > 0
@@ -330,7 +336,7 @@ export const unblockAppsAction = {
     descriptionCompressed: "Admin: remove app block, unshield all apps.",
     validate: async (runtime, message) => {
         const access = await getAppBlockerAccess(runtime, message);
-        return access.allowed;
+        return access.allowed && APP_BLOCK_INTENT_RE.test(getMessageText(message));
     },
     handler: async (runtime, message) => {
         const access = await getAppBlockerAccess(runtime, message);
@@ -387,7 +393,7 @@ export const getAppBlockStatusAction = {
     descriptionCompressed: "Admin: check if app block is active.",
     validate: async (runtime, message) => {
         const access = await getAppBlockerAccess(runtime, message);
-        return access.allowed;
+        return access.allowed && APP_BLOCK_INTENT_RE.test(getMessageText(message));
     },
     handler: async (runtime, message) => {
         const access = await getAppBlockerAccess(runtime, message);

package/apps/app-lifeops/src/actions/approval.d.ts

@@ -0,0 +1,21 @@
+/**
+ * APPROVE_REQUEST / REJECT_REQUEST actions.
+ *
+ * These resolve a pending `ApprovalRequest` from the LifeOps approval queue
+ * (WS6). Parameter extraction is LLM-driven: the handler asks TEXT_LARGE to
+ * pick the target request id and a resolution reason from the incoming
+ * message plus a snapshot of the queue. The prompt is multilingual — the
+ * model is instructed to understand any language and to echo the reason in
+ * the user's language.
+ */
+import type { Action, ActionResult, HandlerCallback, IAgentRuntime } from "@elizaos/core";
+import { type ApprovalQueue, type ApprovalRequest } from "../lifeops/approval-queue.types.js";
+export declare function executeApprovedRequest(args: {
+    runtime: IAgentRuntime;
+    queue: ApprovalQueue;
+    request: ApprovalRequest;
+    callback?: HandlerCallback;
+}): Promise<ActionResult>;
+export declare const approveRequestAction: Action;
+export declare const rejectRequestAction: Action;
+//# sourceMappingURL=approval.d.ts.map

package/apps/app-lifeops/src/actions/approval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/approval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,MAAM,EAEN,YAAY,EACZ,eAAe,EACf,aAAa,EAEd,MAAM,eAAe,CAAC;AAIvB,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EAErB,MAAM,oCAAoC,CAAC;AAoG5C,wBAAsB,sBAAsB,CAAC,IAAI,EAAE;IACjD,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B,GAAG,OAAO,CAAC,YAAY,CAAC,CAoGxB;AAgFD,eAAO,MAAM,oBAAoB,EAAE,MA6ClC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,MA6CjC,CAAC"}

package/apps/app-lifeops/src/actions/approval.js

@@ -0,0 +1,340 @@
+/**
+ * APPROVE_REQUEST / REJECT_REQUEST actions.
+ *
+ * These resolve a pending `ApprovalRequest` from the LifeOps approval queue
+ * (WS6). Parameter extraction is LLM-driven: the handler asks TEXT_LARGE to
+ * pick the target request id and a resolution reason from the incoming
+ * message plus a snapshot of the queue. The prompt is multilingual — the
+ * model is instructed to understand any language and to echo the reason in
+ * the user's language.
+ */
+import { ModelType, logger, parseJSONObjectFromText } from "@elizaos/core";
+import { hasOwnerAccess } from "@elizaos/agent/security";
+import { createApprovalQueue } from "../lifeops/approval-queue.js";
+import { ApprovalNotFoundError, ApprovalStateTransitionError, } from "../lifeops/approval-queue.types.js";
+import { executeApprovedBookTravel } from "./book-travel.js";
+import { dispatchCrossChannelSend, } from "./cross-channel-send.js";
+import { LifeOpsService } from "../lifeops/service.js";
+import { INTERNAL_URL } from "./lifeops-google-helpers.js";
+function formatPending(requests) {
+    if (requests.length === 0)
+        return "(no pending requests)";
+    return requests
+        .map((r, i) => {
+        const payloadSummary = JSON.stringify(r.payload);
+        return `${i + 1}. id=${r.id} action=${r.action} channel=${r.channel} reason=${r.reason} payload=${payloadSummary}`;
+    })
+        .join("\n");
+}
+async function extractResolution(runtime, userText, intent, pending) {
+    if (pending.length === 0) {
+        return { requestId: null, reason: null };
+    }
+    if (typeof runtime.useModel !== "function") {
+        if (pending.length === 1) {
+            return {
+                requestId: pending[0].id,
+                reason: userText.trim() || `user ${intent}d`,
+            };
+        }
+        return { requestId: null, reason: null };
+    }
+    const prompt = `You are resolving an approval queue decision.
+The user wants to ${intent} one of the pending requests below.
+Understand the user's message in any language. Echo the reason in the user's language.
+
+User message:
+"""
+${userText}
+"""
+
+Pending requests:
+${formatPending(pending)}
+
+Respond as strict JSON with exactly these keys:
+{
+  "requestId": "<id of the single targeted request, or null if ambiguous>",
+  "reason": "<short human-readable reason in the user's language, or null if none given>"
+}`;
+    const raw = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
+    const parsed = parseJSONObjectFromText(typeof raw === "string" ? raw : "");
+    if (!parsed || typeof parsed !== "object") {
+        return { requestId: null, reason: null };
+    }
+    const record = parsed;
+    const requestId = typeof record.requestId === "string" && record.requestId.length > 0
+        ? record.requestId
+        : null;
+    const reason = typeof record.reason === "string" && record.reason.length > 0
+        ? record.reason
+        : null;
+    return { requestId, reason };
+}
+function denied(reason) {
+    return {
+        text: "",
+        success: false,
+        data: { error: reason },
+    };
+}
+function approvalChannelToCrossChannelSend(channel) {
+    switch (channel) {
+        case "telegram":
+        case "discord":
+        case "imessage":
+        case "sms":
+            return channel;
+        default:
+            return null;
+    }
+}
+export async function executeApprovedRequest(args) {
+    if (args.request.action === "book_travel") {
+        return executeApprovedBookTravel(args);
+    }
+    const service = new LifeOpsService(args.runtime);
+    if (args.request.action === "send_email") {
+        const payload = args.request.payload;
+        if (payload.action !== "send_email") {
+            throw new Error(`[approval] action/payload mismatch: action=send_email, payload.action=${payload.action}`);
+        }
+        await args.queue.markExecuting(args.request.id);
+        if (payload.replyToMessageId) {
+            await service.sendGmailReply(INTERNAL_URL, {
+                messageId: payload.replyToMessageId,
+                bodyText: payload.body,
+                subject: payload.subject || undefined,
+                to: payload.to.length > 0 ? [...payload.to] : undefined,
+                cc: payload.cc.length > 0 ? [...payload.cc] : undefined,
+                confirmSend: true,
+            });
+        }
+        else {
+            await service.sendGmailMessage(INTERNAL_URL, {
+                to: [...payload.to],
+                cc: [...payload.cc],
+                bcc: [...payload.bcc],
+                subject: payload.subject,
+                bodyText: payload.body,
+                confirmSend: true,
+            });
+        }
+        const done = await args.queue.markDone(args.request.id);
+        const text = payload.to.length > 0
+            ? `Approved and sent email to ${payload.to.join(", ")}.`
+            : "Approved and sent the Gmail reply.";
+        await args.callback?.({ text });
+        return {
+            text,
+            success: true,
+            data: {
+                requestId: done.id,
+                state: done.state,
+                action: done.action,
+            },
+        };
+    }
+    if (args.request.action === "send_message") {
+        const channel = approvalChannelToCrossChannelSend(args.request.channel);
+        if (!channel) {
+            return denied("UNSUPPORTED_APPROVAL_CHANNEL");
+        }
+        const payload = args.request.payload;
+        if (payload.action !== "send_message") {
+            throw new Error(`[approval] action/payload mismatch: action=send_message, payload.action=${payload.action}`);
+        }
+        await args.queue.markExecuting(args.request.id);
+        const dispatch = await dispatchCrossChannelSend({
+            runtime: args.runtime,
+            service,
+            channel,
+            target: payload.recipient,
+            body: payload.body,
+        });
+        if (!dispatch.success) {
+            return dispatch;
+        }
+        const done = await args.queue.markDone(args.request.id);
+        const text = `Approved and sent ${channel} message.`;
+        await args.callback?.({ text });
+        return {
+            text,
+            success: true,
+            data: {
+                requestId: done.id,
+                state: done.state,
+                action: done.action,
+                channel,
+            },
+        };
+    }
+    logger.info(`[ApprovalAction] approved ${args.request.id} without executor`);
+    const text = `Approved request ${args.request.id}.`;
+    await args.callback?.({ text });
+    return {
+        text,
+        success: true,
+        data: {
+            requestId: args.request.id,
+            state: args.request.state,
+            action: args.request.action,
+        },
+    };
+}
+async function resolveApprovalRequest(runtime, message, intent, callback) {
+    if (!(await hasOwnerAccess(runtime, message))) {
+        return denied("PERMISSION_DENIED");
+    }
+    const subjectUserId = typeof message.entityId === "string" ? message.entityId : "";
+    if (!subjectUserId) {
+        return denied("MISSING_SUBJECT_USER");
+    }
+    const queue = createApprovalQueue(runtime, { agentId: runtime.agentId });
+    const pending = await queue.list({
+        subjectUserId,
+        state: "pending",
+        action: null,
+        limit: 20,
+    });
+    const userText = typeof message.content?.text === "string" ? message.content.text : "";
+    const extracted = await extractResolution(runtime, userText, intent, pending);
+    if (!extracted.requestId) {
+        const text = pending.length === 0
+            ? "There are no pending approval requests."
+            : "Which request? Please reference it by id or describe it.";
+        if (callback)
+            await callback({ text });
+        return {
+            text,
+            success: false,
+            data: { error: "REQUEST_ID_NOT_RESOLVED", pendingCount: pending.length },
+        };
+    }
+    const resolution = {
+        resolvedBy: subjectUserId,
+        resolutionReason: extracted.reason ?? `user ${intent}d`,
+    };
+    try {
+        const updated = intent === "approve"
+            ? await queue.approve(extracted.requestId, resolution)
+            : await queue.reject(extracted.requestId, resolution);
+        if (intent === "approve") {
+            return executeApprovedRequest({
+                runtime,
+                queue,
+                request: updated,
+                callback,
+            });
+        }
+        logger.info(`[ApprovalAction] ${intent} ${updated.id} by ${subjectUserId}`);
+        const text = `Rejected request ${updated.id}.`;
+        if (callback)
+            await callback({ text });
+        return {
+            text,
+            success: true,
+            data: {
+                requestId: updated.id,
+                state: updated.state,
+                action: updated.action,
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof ApprovalNotFoundError) {
+            return denied("REQUEST_NOT_FOUND");
+        }
+        if (error instanceof ApprovalStateTransitionError) {
+            return denied("INVALID_STATE_TRANSITION");
+        }
+        throw error;
+    }
+}
+export const approveRequestAction = {
+    name: "APPROVE_REQUEST",
+    similes: [
+        "APPROVE",
+        "CONFIRM_REQUEST",
+        "ACCEPT_REQUEST",
+        "YES_DO_IT",
+        "GO_AHEAD",
+    ],
+    description: "Approve a pending action that the agent queued for human confirmation (send message, schedule event, book travel, etc.). Understands any language.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime, message, _state, _options, callback) => resolveApprovalRequest(runtime, message, "approve", callback),
+    parameters: [],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Yeah, go ahead and send that draft to Marco.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Approved request req-8821.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "sounds good, do it",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Approved request req-8912.",
+                },
+            },
+        ],
+    ],
+};
+export const rejectRequestAction = {
+    name: "REJECT_REQUEST",
+    similes: [
+        "REJECT",
+        "DENY_REQUEST",
+        "DECLINE_REQUEST",
+        "CANCEL_REQUEST",
+        "NO_DONT",
+    ],
+    description: "Reject a pending action that the agent queued for human confirmation. Understands any language.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime, message, _state, _options, callback) => resolveApprovalRequest(runtime, message, "reject", callback),
+    parameters: [],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "No, don't send that. Let's hold off.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Rejected request req-8821.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Skip the one about the dinner reservation — we'll do it another day.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Rejected request req-9014.",
+                },
+            },
+        ],
+    ],
+};

package/apps/app-lifeops/src/actions/autofill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autofill.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/autofill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAEL,KAAK,MAAM,EAMZ,MAAM,eAAe,CAAC;AA2BvB,iBAAe,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAK3E;AAED,iBAAe,eAAe,CAC5B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,iBAAe,kBAAkB,CAC/B,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAY5B;AA2FD,eAAO,MAAM,sBAAsB,EAAE,MAsKpC,CAAC;AAOF,eAAO,MAAM,0BAA0B,EAAE,MAiHxC,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,MA8DzC,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;CAKtB,CAAC"}
+{"version":3,"file":"autofill.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/autofill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAEL,KAAK,MAAM,EAMZ,MAAM,eAAe,CAAC;AA6BvB,iBAAe,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAK3E;AAED,iBAAe,eAAe,CAC5B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,iBAAe,kBAAkB,CAC/B,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAY5B;AA2FD,eAAO,MAAM,sBAAsB,EAAE,MAkLpC,CAAC;AAOF,eAAO,MAAM,0BAA0B,EAAE,MA6HxC,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,MA8DzC,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;CAKtB,CAAC"}

package/apps/app-lifeops/src/actions/autofill.js

@@ -19,8 +19,10 @@
  * credential.
  */
 import { logger, } from "@elizaos/core";
-import { hasOwnerAccess } from "@elizaos/agent/security/access";
+import { hasOwnerAccess } from "@elizaos/agent/security";
 import { DEFAULT_AUTOFILL_WHITELIST, extractRegistrableDomain, isUrlWhitelisted, normalizeAutofillDomain, } from "../lifeops/autofill-whitelist.js";
+import { requireFeatureEnabled } from "../lifeops/feature-flags.js";
+import { FeatureNotEnabledError } from "../lifeops/feature-flags.types.js";
 const FIELD_PURPOSES = ["email", "password", "name", "phone", "custom"];
 const WHITELIST_CACHE_KEY = "eliza:lifeops-autofill-whitelist";
 const DEVICE_BUS_URL_ENV = "MILADY_DEVICE_BUS_URL";
@@ -40,8 +42,9 @@ async function loadUserDomains(runtime) {
     return cached.filter((v) => typeof v === "string");
 }
 async function saveUserDomains(runtime, domains) {
-    if (!hasRuntimeCache(runtime))
-        return;
+    if (!hasRuntimeCache(runtime)) {
+        throw new Error("AUTOFILL_WHITELIST_CACHE_UNAVAILABLE");
+    }
     await runtime.setCache(WHITELIST_CACHE_KEY, domains);
 }
 async function effectiveWhitelist(runtime) {
@@ -128,6 +131,18 @@ export const requestFieldFillAction = {
         if (!(await hasOwnerAccess(runtime, message))) {
             return failure("REQUEST_FIELD_FILL", "PERMISSION_DENIED");
         }
+        try {
+            await requireFeatureEnabled(runtime, "browser.automation");
+        }
+        catch (error) {
+            if (error instanceof FeatureNotEnabledError) {
+                return failure("REQUEST_FIELD_FILL", error.code, {
+                    featureKey: error.featureKey,
+                    message: error.message,
+                });
+            }
+            throw error;
+        }
         const params = options?.parameters ?? {};
         const tabUrl = (params.tabUrl ?? "").toString().trim();
         if (!tabUrl)
@@ -308,7 +323,17 @@ export const addAutofillWhitelistAction = {
             };
         }
         const next = [...existingNormalized, normalized];
-        await saveUserDomains(runtime, next);
+        try {
+            await saveUserDomains(runtime, next);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            logger.warn({ action: "ADD_AUTOFILL_WHITELIST", domain: normalized, detail }, `[ADD_AUTOFILL_WHITELIST] failed to persist ${normalized}: ${detail}`);
+            return failure("ADD_AUTOFILL_WHITELIST", "PERSISTENCE_UNAVAILABLE", {
+                domain: normalized,
+                detail,
+            });
+        }
         logger.info({ action: "ADD_AUTOFILL_WHITELIST", domain: normalized }, `[ADD_AUTOFILL_WHITELIST] added ${normalized} to user whitelist`);
         return {
             text: `Added ${normalized} to the autofill whitelist.`,

package/apps/app-lifeops/src/actions/book-travel.d.ts

@@ -0,0 +1,10 @@
+import type { Action, ActionResult, HandlerCallback, IAgentRuntime } from "@elizaos/core";
+import type { ApprovalQueue, ApprovalRequest } from "../lifeops/approval-queue.types.js";
+export declare function executeApprovedBookTravel(args: {
+    runtime: IAgentRuntime;
+    queue: ApprovalQueue;
+    request: ApprovalRequest;
+    callback?: HandlerCallback;
+}): Promise<ActionResult>;
+export declare const bookTravelAction: Action;
+//# sourceMappingURL=book-travel.d.ts.map

package/apps/app-lifeops/src/actions/book-travel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"book-travel.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/book-travel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAEN,YAAY,EACZ,eAAe,EAEf,aAAa,EAGd,MAAM,eAAe,CAAC;AAIvB,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EAChB,MAAM,oCAAoC,CAAC;AA8Q5C,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B,GAAG,OAAO,CAAC,YAAY,CAAC,CAgExB;AAED,eAAO,MAAM,gBAAgB,EAAE,MAsT9B,CAAC"}