@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/services/approval.js

@@ -0,0 +1,399 @@
+/**
+ * ApprovalService
+ *
+ * A robust abstraction for task-based approvals in Eliza.
+ * Provides a interface for requesting approvals, handling choices,
+ * and managing approval workflows.
+ *
+ * Patterns supported:
+ * - Simple confirm/deny (e.g., "Post this tweet?")
+ * - Multi-option choices (e.g., "Select deployment target")
+ * - Timed approvals with expiration
+ * - Approval chains (e.g., "Approve step 1, then step 2")
+ */
+import { logger } from "../logger.js";
+import { Service, ServiceType } from "../types/service.js";
+/**
+ * Standard approval options for common patterns
+ */
+export const STANDARD_OPTIONS = {
+    CONFIRM: [
+        { name: "confirm", description: "Confirm and proceed", isDefault: false },
+        { name: "cancel", description: "Cancel the operation", isCancel: true },
+    ],
+    APPROVE_DENY: [
+        { name: "approve", description: "Approve the request" },
+        { name: "deny", description: "Deny the request", isCancel: true },
+    ],
+    YES_NO: [
+        { name: "yes", description: "Yes" },
+        { name: "no", description: "No", isCancel: true },
+    ],
+    ALLOW_ONCE_ALWAYS_DENY: [
+        { name: "allow-once", description: "Allow this one time" },
+        { name: "allow-always", description: "Always allow this" },
+        { name: "deny", description: "Deny the request", isCancel: true },
+    ],
+};
+/**
+ * ApprovalService provides a interface for task-based approvals.
+ */
+export class ApprovalService extends Service {
+    static serviceType = ServiceType.APPROVAL;
+    capabilityDescription = "Manages approval workflows using the task system";
+    pendingApprovals = new Map();
+    registeredWorkers = new Set();
+    /**
+     * Start the ApprovalService
+     */
+    static async start(runtime) {
+        const service = new ApprovalService(runtime);
+        return service;
+    }
+    /**
+     * Stop the ApprovalService
+     */
+    async stop() {
+        // Resolve all pending approvals with cancelled before clearing
+        for (const pending of this.pendingApprovals.values()) {
+            if (pending.timeoutHandle) {
+                clearTimeout(pending.timeoutHandle);
+            }
+            pending.resolve({
+                selectedOption: "cancel",
+                success: false,
+                timedOut: false,
+                cancelled: true,
+                taskId: pending.taskId,
+                resolvedAt: Date.now(),
+            });
+        }
+        this.pendingApprovals.clear();
+    }
+    /**
+     * Create an approval request and wait for a decision.
+     *
+     * @param request - The approval request parameters
+     * @returns Promise that resolves with the approval result
+     *
+     * @example
+     * ```typescript
+     * const result = await approvalService.requestApproval({
+     *   name: 'EXEC_APPROVAL',
+     *   description: 'Execute command: rm -rf /tmp/cache',
+     *   roomId: message.roomId,
+     *   options: STANDARD_OPTIONS.ALLOW_ONCE_ALWAYS_DENY,
+     *   timeoutMs: 120000,
+     *   timeoutDefault: 'deny',
+     *   onSelect: async (option, task, runtime) => {
+     *     if (option === 'allow-always') {
+     *       await addToAllowlist(command);
+     *     }
+     *   },
+     * });
+     *
+     * if (result.success && result.selectedOption !== 'deny') {
+     *   await executeCommand();
+     * }
+     * ```
+     */
+    async requestApproval(request) {
+        // Ensure task worker is registered for this approval type
+        await this.ensureWorkerRegistered(request);
+        // Create the approval task
+        const taskId = await this.runtime.createTask({
+            name: request.name,
+            description: request.description,
+            roomId: request.roomId,
+            entityId: request.entityId,
+            tags: ["AWAITING_CHOICE", "APPROVAL", ...(request.tags ?? [])],
+            metadata: {
+                options: request.options.map((opt) => ({
+                    name: opt.name,
+                    description: opt.description ?? "",
+                })),
+                approvalRequest: {
+                    timeoutMs: request.timeoutMs,
+                    timeoutDefault: request.timeoutDefault,
+                    allowedRoles: request.allowedRoles ?? ["OWNER", "ADMIN"],
+                    createdAt: Date.now(),
+                },
+                ...(request.metadata ?? {}),
+            },
+        });
+        logger.info({
+            src: "service:approval",
+            taskId,
+            name: request.name,
+            roomId: request.roomId,
+            options: request.options.map((o) => o.name),
+            timeoutMs: request.timeoutMs,
+        }, "Approval request created");
+        // Create pending approval tracker
+        return new Promise((resolve, reject) => {
+            const now = Date.now();
+            const pending = {
+                taskId,
+                request,
+                createdAt: now,
+                resolve,
+                reject,
+            };
+            // Set up timeout if specified
+            if (request.timeoutMs && request.timeoutMs > 0) {
+                pending.expiresAt = now + request.timeoutMs;
+                pending.timeoutHandle = setTimeout(() => this.handleTimeout(taskId), request.timeoutMs);
+            }
+            this.pendingApprovals.set(taskId, pending);
+        });
+    }
+    /**
+     * Request approval without waiting (fire and forget with callbacks).
+     * Useful when you don't need to block on the approval result.
+     */
+    async requestApprovalAsync(request) {
+        // Ensure task worker is registered for this approval type
+        await this.ensureWorkerRegistered(request);
+        // Create the approval task
+        const taskId = await this.runtime.createTask({
+            name: request.name,
+            description: request.description,
+            roomId: request.roomId,
+            entityId: request.entityId,
+            tags: ["AWAITING_CHOICE", "APPROVAL", ...(request.tags ?? [])],
+            metadata: {
+                options: request.options.map((opt) => ({
+                    name: opt.name,
+                    description: opt.description ?? "",
+                })),
+                approvalRequest: {
+                    timeoutMs: request.timeoutMs,
+                    timeoutDefault: request.timeoutDefault,
+                    allowedRoles: request.allowedRoles ?? ["OWNER", "ADMIN"],
+                    createdAt: Date.now(),
+                    isAsync: true,
+                },
+                onSelectCallback: !!request.onSelect,
+                onTimeoutCallback: !!request.onTimeout,
+                ...(request.metadata ?? {}),
+            },
+        });
+        logger.info({
+            src: "service:approval",
+            taskId,
+            name: request.name,
+            roomId: request.roomId,
+            async: true,
+        }, "Async approval request created");
+        // Store callbacks for async handling
+        if (request.onSelect || request.onTimeout) {
+            const pending = {
+                taskId,
+                request,
+                createdAt: Date.now(),
+                resolve: () => { },
+                reject: () => { },
+            };
+            if (request.timeoutMs && request.timeoutMs > 0) {
+                pending.expiresAt = Date.now() + request.timeoutMs;
+                pending.timeoutHandle = setTimeout(() => this.handleTimeout(taskId), request.timeoutMs);
+            }
+            this.pendingApprovals.set(taskId, pending);
+        }
+        return taskId;
+    }
+    /**
+     * Cancel a pending approval
+     */
+    async cancelApproval(taskId) {
+        const pending = this.pendingApprovals.get(taskId);
+        if (pending) {
+            if (pending.timeoutHandle) {
+                clearTimeout(pending.timeoutHandle);
+            }
+            pending.resolve({
+                selectedOption: "cancel",
+                success: false,
+                timedOut: false,
+                cancelled: true,
+                taskId,
+                resolvedAt: Date.now(),
+            });
+            this.pendingApprovals.delete(taskId);
+        }
+        // Delete the task
+        await this.runtime.deleteTask(taskId);
+        logger.info({ src: "service:approval", taskId }, "Approval cancelled");
+    }
+    /**
+     * Get all pending approvals for a room
+     */
+    async getPendingApprovals(roomId) {
+        const tasks = await this.runtime.getTasks({
+            roomId,
+            tags: ["AWAITING_CHOICE", "APPROVAL"],
+            agentIds: [this.runtime.agentId],
+        });
+        return tasks;
+    }
+    /**
+     * Handle timeout for a pending approval
+     */
+    async handleTimeout(taskId) {
+        const pending = this.pendingApprovals.get(taskId);
+        if (!pending)
+            return;
+        const { request } = pending;
+        logger.info({ src: "service:approval", taskId, name: request.name }, "Approval timed out");
+        // Call timeout callback if provided
+        const task = await this.runtime.getTask(taskId);
+        if (task && request.onTimeout) {
+            try {
+                await request.onTimeout(task, this.runtime);
+            }
+            catch (error) {
+                logger.error({ src: "service:approval", taskId, error }, "Error in timeout callback");
+            }
+        }
+        // Resolve with timeout default or cancel
+        const defaultOption = request.timeoutDefault ?? "cancel";
+        const isCancel = request.options.find((o) => o.name === defaultOption)?.isCancel ?? true;
+        pending.resolve({
+            selectedOption: defaultOption,
+            success: !isCancel,
+            timedOut: true,
+            cancelled: isCancel,
+            taskId,
+            resolvedAt: Date.now(),
+        });
+        this.pendingApprovals.delete(taskId);
+        // Delete the task
+        await this.runtime.deleteTask(taskId);
+    }
+    /**
+     * Handle selection from CHOOSE_OPTION action
+     * Called by the task worker when an option is selected
+     */
+    async handleSelection(taskId, selectedOption, resolvedBy) {
+        const pending = this.pendingApprovals.get(taskId);
+        // Clear timeout
+        if (pending?.timeoutHandle) {
+            clearTimeout(pending.timeoutHandle);
+        }
+        const task = await this.runtime.getTask(taskId);
+        if (!task) {
+            logger.warn({ src: "service:approval", taskId }, "Task not found for approval selection");
+            return;
+        }
+        const request = pending?.request;
+        const option = request?.options.find((o) => o.name === selectedOption);
+        const isCancel = option?.isCancel ??
+            (selectedOption === "cancel" || selectedOption === "ABORT");
+        logger.info({
+            src: "service:approval",
+            taskId,
+            selectedOption,
+            resolvedBy,
+            isCancel,
+        }, "Approval selection handled");
+        // Call onSelect callback if provided
+        if (request?.onSelect) {
+            try {
+                await request.onSelect(selectedOption, task, this.runtime);
+            }
+            catch (error) {
+                logger.error({ src: "service:approval", taskId, error }, "Error in onSelect callback");
+            }
+        }
+        // Resolve the pending promise
+        if (pending) {
+            pending.resolve({
+                selectedOption,
+                success: !isCancel,
+                timedOut: false,
+                cancelled: isCancel,
+                taskId,
+                resolvedBy,
+                resolvedAt: Date.now(),
+            });
+            this.pendingApprovals.delete(taskId);
+        }
+    }
+    /**
+     * Ensure task worker is registered for this approval type
+     */
+    async ensureWorkerRegistered(request) {
+        if (this.registeredWorkers.has(request.name)) {
+            return;
+        }
+        const worker = {
+            name: request.name,
+            canExecute: async (runtime, message, _state) => {
+                // Get the task to check allowed roles
+                const tasks = await runtime.getTasks({
+                    roomId: message.roomId,
+                    tags: ["AWAITING_CHOICE", "APPROVAL"],
+                    agentIds: [runtime.agentId],
+                });
+                const matchingTask = tasks.find((t) => t.name === request.name);
+                if (!matchingTask)
+                    return false;
+                const allowedRoles = matchingTask.metadata?.approvalRequest?.allowedRoles;
+                if (!allowedRoles || allowedRoles.length === 0) {
+                    return true; // No role restriction
+                }
+                // Import getUserServerRole dynamically to avoid circular dependency
+                const { getUserServerRole } = await import("../roles.js");
+                const room = await runtime.getRoom(message.roomId);
+                if (!room?.worldId) {
+                    return true; // Allow in DMs
+                }
+                const userRole = await getUserServerRole(runtime, message.entityId, room.worldId);
+                return allowedRoles.includes(userRole);
+            },
+            execute: async (runtime, options, task) => {
+                const selectedOption = options.option;
+                if (!task.id) {
+                    logger.error({ src: "service:approval" }, "Task has no ID");
+                    return undefined;
+                }
+                await this.handleSelection(task.id, selectedOption, options.resolvedBy);
+                // Delete the task after handling
+                await runtime.deleteTask(task.id);
+                return undefined;
+            },
+        };
+        this.runtime.registerTaskWorker(worker);
+        this.registeredWorkers.add(request.name);
+        logger.debug({ src: "service:approval", name: request.name }, "Registered approval task worker");
+    }
+}
+/**
+ * Helper function to create a simple confirm/deny approval
+ */
+export async function requestConfirmation(runtime, params) {
+    const service = runtime.getService(ServiceType.APPROVAL);
+    if (!service) {
+        logger.warn("ApprovalService not available, auto-denying");
+        return false;
+    }
+    const result = await service.requestApproval({
+        name: `CONFIRM_${Date.now()}`,
+        description: params.description,
+        roomId: params.roomId,
+        entityId: params.entityId,
+        options: STANDARD_OPTIONS.CONFIRM,
+        timeoutMs: params.timeoutMs,
+        timeoutDefault: "cancel",
+        onSelect: async (option, task, rt) => {
+            if (option === "confirm" && params.onConfirm) {
+                await params.onConfirm(task, rt);
+            }
+            else if (option === "cancel" && params.onCancel) {
+                await params.onCancel(task, rt);
+            }
+        },
+    });
+    return result.success && result.selectedOption === "confirm";
+}
+export default ApprovalService;

package/packages/typescript/src/services/embedding.d.ts

@@ -0,0 +1,29 @@
+import type { IAgentRuntime } from "../types/runtime";
+import { Service } from "../types/service";
+/**
+ * Service responsible for generating embeddings asynchronously
+ * This service listens for EMBEDDING_GENERATION_REQUESTED events
+ * and processes them in a queue to avoid blocking the main runtime
+ */
+export declare class EmbeddingGenerationService extends Service {
+    static serviceType: string;
+    capabilityDescription: string;
+    private batchQueue;
+    private isDisabled;
+    private static readonly EMBEDDING_DRAIN_TASK;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    initialize(): Promise<void>;
+    private handleEmbeddingRequest;
+    private generateEmbedding;
+    stop(): Promise<void>;
+    getQueueSize(): number;
+    getQueueStats(): {
+        high: number;
+        normal: number;
+        low: number;
+        total: number;
+    };
+    clearQueue(): void;
+}
+export default EmbeddingGenerationService;
+//# sourceMappingURL=embedding.d.ts.map

package/packages/typescript/src/services/embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/services/embedding.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAS3C;;;;GAIG;AACH,qBAAa,0BAA2B,SAAQ,OAAO;IACtD,MAAM,CAAC,WAAW,SAA0B;IAC5C,qBAAqB,SACqC;IAE1D,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAqB;WAEpD,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IA4BtD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAuEnB,sBAAsB;YA8CtB,iBAAiB;IAyEzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAmC3B,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;KACd;IAID,UAAU,IAAI,IAAI;CAYlB;AAED,eAAe,0BAA0B,CAAC"}

package/packages/typescript/src/services/embedding.js

@@ -0,0 +1,211 @@
+import { EventType } from "../types/events";
+import { ModelType } from "../types/model";
+import { Service } from "../types/service";
+import { BatchQueue } from "../utils/batch-queue";
+/**
+ * Service responsible for generating embeddings asynchronously
+ * This service listens for EMBEDDING_GENERATION_REQUESTED events
+ * and processes them in a queue to avoid blocking the main runtime
+ */
+export class EmbeddingGenerationService extends Service {
+    static serviceType = "embedding-generation";
+    capabilityDescription = "Handles asynchronous embedding generation for memories";
+    batchQueue = null;
+    isDisabled = false;
+    static EMBEDDING_DRAIN_TASK = "EMBEDDING_DRAIN";
+    static async start(runtime) {
+        runtime.logger.info({
+            src: "plugin:basic-capabilities:service:embedding",
+            agentId: runtime.agentId,
+        }, "Starting embedding generation service");
+        const embeddingModel = runtime.getModel(ModelType.TEXT_EMBEDDING);
+        if (!embeddingModel) {
+            runtime.logger.warn({
+                src: "plugin:basic-capabilities:service:embedding",
+                agentId: runtime.agentId,
+            }, "No TEXT_EMBEDDING model registered - service will not be initialized");
+            const noOpService = new EmbeddingGenerationService(runtime);
+            noOpService.isDisabled = true;
+            return noOpService;
+        }
+        const service = new EmbeddingGenerationService(runtime);
+        await service.initialize();
+        return service;
+    }
+    async initialize() {
+        if (this.isDisabled) {
+            this.runtime.logger.debug({
+                src: "plugin:basic-capabilities:service:embedding",
+                agentId: this.runtime.agentId,
+            }, "Service is disabled, skipping initialization");
+            return;
+        }
+        this.runtime.logger.info({
+            src: "plugin:basic-capabilities:service:embedding",
+            agentId: this.runtime.agentId,
+        }, "Initializing embedding generation service");
+        this.runtime.registerEvent(EventType.EMBEDDING_GENERATION_REQUESTED, this.handleEmbeddingRequest.bind(this));
+        // Uses shared `utils/batch-queue` (see `batch-queue.ts` header): same drain/retry/priority
+        // model as other services so we do not maintain another bespoke queue + task stack here.
+        // Task system owns WHEN (repeat EMBEDDING_DRAIN tick); we own WHAT (dequeue, embed, persist).
+        // No maxSize — bottleneck is embedding I/O, not queue length.
+        this.batchQueue = new BatchQueue({
+            name: EmbeddingGenerationService.EMBEDDING_DRAIN_TASK,
+            taskDescription: "Embedding generation drain",
+            batchSize: 10,
+            drainIntervalMs: 100,
+            getPriority: (item) => item.priority,
+            maxParallel: 10,
+            maxRetriesAfterFailure: 3,
+            process: (item) => this.generateEmbedding(item),
+            onExhausted: async (item, error) => {
+                await this.runtime.log({
+                    entityId: this.runtime.agentId,
+                    roomId: item.memory.roomId || this.runtime.agentId,
+                    type: "embedding_event",
+                    body: {
+                        runId: item.runId,
+                        memoryId: item.memory.id,
+                        status: "failed",
+                        error: error.message,
+                        source: "embeddingService",
+                    },
+                });
+                await this.runtime.emitEvent(EventType.EMBEDDING_GENERATION_FAILED, {
+                    runtime: this.runtime,
+                    memory: item.memory,
+                    error: error.message,
+                    source: "embeddingService",
+                });
+            },
+        });
+        await this.batchQueue.start(this.runtime);
+        this.runtime.logger.info({
+            src: "plugin:basic-capabilities:service:embedding",
+            agentId: this.runtime.agentId,
+        }, "Started embedding drain task");
+    }
+    async handleEmbeddingRequest(payload) {
+        if (this.isDisabled || !this.batchQueue) {
+            this.runtime.logger.debug({
+                src: "plugin:basic-capabilities:service:embedding",
+                agentId: this.runtime.agentId,
+            }, "Service is disabled or queue missing, skipping embedding request");
+            return;
+        }
+        const { memory, priority = "normal", runId } = payload;
+        if (memory.embedding) {
+            this.runtime.logger.debug({
+                src: "plugin:basic-capabilities:service:embedding",
+                agentId: this.runtime.agentId,
+                memoryId: memory.id,
+            }, "Memory already has embeddings, skipping");
+            return;
+        }
+        const queueItem = {
+            memory,
+            priority,
+            runId,
+        };
+        this.batchQueue.enqueue(queueItem);
+        this.runtime.logger.debug({
+            src: "plugin:basic-capabilities:service:embedding",
+            agentId: this.runtime.agentId,
+            queueSize: this.batchQueue.size,
+        }, "Added memory to queue");
+    }
+    async generateEmbedding(item) {
+        const { memory } = item;
+        const memoryContent = memory.content;
+        if (!memoryContent?.text) {
+            this.runtime.logger.warn({
+                src: "plugin:basic-capabilities:service:embedding",
+                agentId: this.runtime.agentId,
+                memoryId: memory.id,
+            }, "Memory has no text content");
+            return;
+        }
+        try {
+            const startTime = Date.now();
+            const embedding = await this.runtime.useModel(ModelType.TEXT_EMBEDDING, {
+                text: memory.content.text ?? "",
+            });
+            const duration = Date.now() - startTime;
+            this.runtime.logger.debug({
+                src: "plugin:basic-capabilities:service:embedding",
+                agentId: this.runtime.agentId,
+                memoryId: memory.id,
+                durationMs: duration,
+            }, "Generated embedding");
+            if (memory.id) {
+                await this.runtime.updateMemory({
+                    id: memory.id,
+                    embedding,
+                });
+                await this.runtime.log({
+                    entityId: this.runtime.agentId,
+                    roomId: memory.roomId || this.runtime.agentId,
+                    type: "embedding_event",
+                    body: {
+                        runId: item.runId,
+                        memoryId: memory.id,
+                        status: "completed",
+                        duration,
+                        source: "embeddingService",
+                    },
+                });
+                await this.runtime.emitEvent(EventType.EMBEDDING_GENERATION_COMPLETED, {
+                    runtime: this.runtime,
+                    memory: { ...memory, embedding },
+                    source: "embeddingService",
+                });
+            }
+        }
+        catch (error) {
+            this.runtime.logger.error({
+                src: "plugin:basic-capabilities:service:embedding",
+                agentId: this.runtime.agentId,
+                memoryId: memory.id,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to generate embedding");
+            throw error;
+        }
+    }
+    async stop() {
+        this.runtime.logger.info({
+            src: "plugin:basic-capabilities:service:embedding",
+            agentId: this.runtime.agentId,
+        }, "Stopping embedding generation service");
+        if (this.isDisabled || !this.batchQueue) {
+            this.runtime.logger.debug({
+                src: "plugin:basic-capabilities:service:embedding",
+                agentId: this.runtime.agentId,
+            }, "Service is disabled, nothing to stop");
+            return;
+        }
+        const remaining = this.batchQueue.size;
+        await this.batchQueue.dispose(this.runtime, { flushHighPriority: true });
+        this.runtime.logger.info({
+            src: "plugin:basic-capabilities:service:embedding",
+            agentId: this.runtime.agentId,
+            remainingItems: remaining,
+        }, "Stopped");
+        this.batchQueue = null;
+    }
+    getQueueSize() {
+        return this.batchQueue?.size ?? 0;
+    }
+    getQueueStats() {
+        return this.batchQueue?.stats() ?? { high: 0, normal: 0, low: 0, total: 0 };
+    }
+    clearQueue() {
+        const size = this.batchQueue?.size ?? 0;
+        this.batchQueue?.clear();
+        this.runtime.logger.info({
+            src: "plugin:basic-capabilities:service:embedding",
+            agentId: this.runtime.agentId,
+            clearedCount: size,
+        }, "Cleared queue");
+    }
+}
+export default EmbeddingGenerationService;

package/packages/typescript/src/services/followUp.d.ts

@@ -0,0 +1,48 @@
+import type { JsonValue, UUID } from "../types/primitives";
+import type { IAgentRuntime } from "../types/runtime";
+import { Service } from "../types/service";
+import type { Task } from "../types/task";
+import type { ContactInfo } from "./relationships.ts";
+export interface FollowUpTask {
+    entityId: UUID;
+    reason: string;
+    message?: string;
+    priority: "high" | "medium" | "low";
+    metadata?: Record<string, JsonValue | object>;
+}
+export interface FollowUpSuggestion {
+    entityId: UUID;
+    entityName: string;
+    reason: string;
+    daysSinceLastContact: number;
+    relationshipStrength: number;
+    suggestedMessage?: string;
+}
+export declare class FollowUpService extends Service {
+    static serviceType: "follow_up";
+    capabilityDescription: string;
+    private relationshipsService;
+    constructor(runtime?: IAgentRuntime);
+    initialize(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    scheduleFollowUp(entityId: UUID, scheduledAt: Date, reason: string, priority?: "high" | "medium" | "low", message?: string): Promise<Task>;
+    getUpcomingFollowUps(days?: number, includeOverdue?: boolean): Promise<Array<{
+        task: Task;
+        contact: ContactInfo;
+    }>>;
+    completeFollowUp(taskId: UUID, notes?: string): Promise<void>;
+    snoozeFollowUp(taskId: UUID, newDate: Date): Promise<void>;
+    getFollowUpSuggestions(): Promise<FollowUpSuggestion[]>;
+    private registerFollowUpWorker;
+    private generateFollowUpReason;
+    private generateFollowUpMessage;
+    scheduleMultipleFollowUps(followUps: Array<{
+        entityId: UUID;
+        scheduledAt: Date;
+        reason: string;
+        priority?: "high" | "medium" | "low";
+        message?: string;
+    }>): Promise<Task[]>;
+}
+//# sourceMappingURL=followUp.d.ts.map