@elizaos/agent 0.25.9 → 2.0.0-alpha.151

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

@@ -0,0 +1,637 @@
+import { logger } from "../logger";
+import { Service } from "../types/service";
+import { stringToUuid } from "../utils";
+function getContactDisplayName(contactInfo) {
+    const displayName = contactInfo.customFields.displayName;
+    return typeof displayName === "string" && displayName.trim().length > 0
+        ? displayName.trim()
+        : null;
+}
+/** Helper to convert ContactInfo to Metadata for storage */
+function contactInfoToMetadata(contactInfo) {
+    return {
+        entityId: contactInfo.entityId,
+        categories: contactInfo.categories,
+        tags: contactInfo.tags,
+        preferences: contactInfo.preferences,
+        customFields: contactInfo.customFields,
+        privacyLevel: contactInfo.privacyLevel,
+        lastModified: contactInfo.lastModified,
+    };
+}
+/** Helper to convert Metadata back to ContactInfo */
+function metadataToContactInfo(data) {
+    return {
+        entityId: data.entityId,
+        categories: data.categories,
+        tags: data.tags,
+        preferences: data.preferences,
+        customFields: data.customFields ?? {},
+        privacyLevel: data.privacyLevel,
+        lastModified: data.lastModified,
+    };
+}
+// Entity lifecycle event types
+export var EntityLifecycleEvent;
+(function (EntityLifecycleEvent) {
+    EntityLifecycleEvent["CREATED"] = "entity:created";
+    EntityLifecycleEvent["UPDATED"] = "entity:updated";
+    EntityLifecycleEvent["MERGED"] = "entity:merged";
+    EntityLifecycleEvent["RESOLVED"] = "entity:resolved";
+})(EntityLifecycleEvent || (EntityLifecycleEvent = {}));
+/**
+ * Calculate relationship strength based on interaction patterns
+ */
+export function calculateRelationshipStrength({ interactionCount, lastInteractionAt, messageQuality = 5, relationshipType = "acquaintance", sharedConversationWindows = 0, }) {
+    // Base score from interaction count (max 40 points)
+    const interactionScore = Math.min(interactionCount * 2, 40);
+    // Shared conversation windows in the same room within an hour are a
+    // stronger social signal than isolated messages. Cap to avoid swamping
+    // explicit relationship/context signals.
+    const sharedConversationScore = Math.min(sharedConversationWindows * 4, 16);
+    // Recency score (max 30 points)
+    let recencyScore = 0;
+    if (lastInteractionAt) {
+        const daysSinceLastInteraction = (Date.now() - new Date(lastInteractionAt).getTime()) /
+            (1000 * 60 * 60 * 24);
+        if (daysSinceLastInteraction < 1)
+            recencyScore = 30;
+        else if (daysSinceLastInteraction < 7)
+            recencyScore = 25;
+        else if (daysSinceLastInteraction < 30)
+            recencyScore = 20;
+        else if (daysSinceLastInteraction < 90)
+            recencyScore = 10;
+        else
+            recencyScore = 5;
+    }
+    // Quality score (max 20 points)
+    const qualityScore = (messageQuality / 10) * 20;
+    // Relationship type bonus (max 10 points)
+    const relationshipBonus = {
+        family: 10,
+        friend: 8,
+        colleague: 6,
+        acquaintance: 4,
+        unknown: 0,
+    };
+    // Calculate total strength
+    const totalStrength = interactionScore +
+        recencyScore +
+        qualityScore +
+        sharedConversationScore +
+        (relationshipBonus[relationshipType] ?? 0);
+    // Return clamped value between 0 and 100
+    return Math.max(0, Math.min(100, Math.round(totalStrength)));
+}
+function toMessageTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
+export function countSharedConversationWindows(messages, leftEntityId, rightEntityId, windowMs = 1000 * 60 * 60) {
+    const relevantMessages = messages
+        .filter((message) => (message.entityId === leftEntityId ||
+        message.entityId === rightEntityId) &&
+        toMessageTimestamp(message.createdAt) !== null)
+        .sort((left, right) => (toMessageTimestamp(left.createdAt) ?? 0) -
+        (toMessageTimestamp(right.createdAt) ?? 0));
+    if (relevantMessages.length < 2) {
+        return 0;
+    }
+    const rooms = new Map();
+    for (const message of relevantMessages) {
+        const roomKey = typeof message.roomId === "string" ? message.roomId : "__shared__";
+        if (!rooms.has(roomKey)) {
+            rooms.set(roomKey, []);
+        }
+        rooms.get(roomKey)?.push(message);
+    }
+    let windowCount = 0;
+    for (const roomMessages of rooms.values()) {
+        let currentWindowStart = null;
+        let seenLeft = false;
+        let seenRight = false;
+        const flushWindow = () => {
+            if (seenLeft && seenRight) {
+                windowCount += 1;
+            }
+            currentWindowStart = null;
+            seenLeft = false;
+            seenRight = false;
+        };
+        for (const message of roomMessages) {
+            const createdAt = toMessageTimestamp(message.createdAt);
+            if (createdAt === null) {
+                continue;
+            }
+            if (currentWindowStart === null ||
+                createdAt - currentWindowStart > windowMs) {
+                if (currentWindowStart !== null) {
+                    flushWindow();
+                }
+                currentWindowStart = createdAt;
+            }
+            if (message.entityId === leftEntityId) {
+                seenLeft = true;
+            }
+            if (message.entityId === rightEntityId) {
+                seenRight = true;
+            }
+        }
+        if (currentWindowStart !== null) {
+            flushWindow();
+        }
+    }
+    return windowCount;
+}
+export class RelationshipsService extends Service {
+    static serviceType = "relationships";
+    capabilityDescription = "Comprehensive contact and relationship management service";
+    // In-memory caches for performance
+    contactInfoCache = new Map();
+    analyticsCache = new Map();
+    categoriesCache = [];
+    static CONTACT_CACHE_LIMIT = 2000;
+    static ANALYTICS_CACHE_LIMIT = 2000;
+    setCacheWithLimit(cache, key, value, limit) {
+        if (cache.has(key)) {
+            cache.delete(key);
+        }
+        cache.set(key, value);
+        if (cache.size > limit) {
+            const firstKey = cache.keys().next().value;
+            if (firstKey !== undefined) {
+                cache.delete(firstKey);
+            }
+        }
+    }
+    getRelationshipsWorldId() {
+        return stringToUuid(`relationships-world-${this.runtime.agentId}`);
+    }
+    getRelationshipsRoomId() {
+        return stringToUuid(`relationships-${this.runtime.agentId}`);
+    }
+    isRelationshipsContactComponent(component) {
+        return (component.type === "contact_info" &&
+            component.agentId === this.runtime.agentId &&
+            component.worldId === this.getRelationshipsWorldId() &&
+            component.sourceEntityId === this.runtime.agentId);
+    }
+    async getStoredContactComponent(entityId) {
+        if (typeof this.runtime.getComponent === "function") {
+            return await this.runtime.getComponent(entityId, "contact_info", this.getRelationshipsWorldId(), this.runtime.agentId);
+        }
+        const components = await this.runtime.getComponents(entityId);
+        return (components.find((component) => this.isRelationshipsContactComponent(component)) ?? null);
+    }
+    cacheContactInfoFromEntities(entities) {
+        for (const entity of entities) {
+            if (!entity.id || !entity.components) {
+                continue;
+            }
+            const contactComponent = entity.components.find((component) => this.isRelationshipsContactComponent(component));
+            if (!contactComponent?.data) {
+                continue;
+            }
+            const contactInfo = metadataToContactInfo(contactComponent.data);
+            this.setCacheWithLimit(this.contactInfoCache, entity.id, contactInfo, RelationshipsService.CONTACT_CACHE_LIMIT);
+        }
+    }
+    async initialize(runtime) {
+        this.runtime = runtime;
+        const relationshipsWorldId = this.getRelationshipsWorldId();
+        const relationshipsRoomId = this.getRelationshipsRoomId();
+        // Ensure the synthetic relationships world exists so component FK constraints pass
+        if (typeof this.runtime.ensureWorldExists === "function") {
+            try {
+                await this.runtime.ensureWorldExists({
+                    id: relationshipsWorldId,
+                    name: "Relationships World",
+                    agentId: this.runtime.agentId,
+                });
+            }
+            catch (err) {
+                logger.warn(`[RelationshipsService] Failed to ensure relationships world: ${err}`);
+            }
+        }
+        // Components are stored in a synthetic room inside the relationships world.
+        if (typeof this.runtime.ensureRoomExists === "function") {
+            try {
+                await this.runtime.ensureRoomExists({
+                    id: relationshipsRoomId,
+                    name: "Relationships",
+                    source: "relationships",
+                    type: "API",
+                    channelId: `relationships-${this.runtime.agentId}`,
+                    worldId: relationshipsWorldId,
+                });
+            }
+            catch (err) {
+                logger.warn(`[RelationshipsService] Failed to ensure relationships room: ${err}`);
+            }
+        }
+        // Initialize default categories
+        this.categoriesCache = [
+            { id: "friend", name: "Friend", color: "#4CAF50" },
+            { id: "family", name: "Family", color: "#2196F3" },
+            { id: "colleague", name: "Colleague", color: "#FF9800" },
+            { id: "acquaintance", name: "Acquaintance", color: "#9E9E9E" },
+            { id: "vip", name: "VIP", color: "#9C27B0" },
+            { id: "business", name: "Business", color: "#795548" },
+        ];
+        // Load existing contact info from components
+        await this.loadContactInfoFromComponents();
+        // Service initialized
+        logger.info("[RelationshipsService] Initialized successfully");
+    }
+    async stop() {
+        // Clean up caches
+        this.contactInfoCache.clear();
+        this.analyticsCache.clear();
+        this.categoriesCache = [];
+        // Service stopped
+        logger.info("[RelationshipsService] Stopped successfully");
+    }
+    static async start(runtime) {
+        const service = new RelationshipsService();
+        await service.initialize(runtime);
+        return service;
+    }
+    async loadContactInfoFromComponents() {
+        this.contactInfoCache.clear();
+        const relationshipsWorldId = this.getRelationshipsWorldId();
+        // Load contacts from the synthetic relationships world where they are stored.
+        if (typeof this.runtime.queryEntities === "function") {
+            try {
+                const entities = await this.runtime.queryEntities({
+                    componentType: "contact_info",
+                    worldId: relationshipsWorldId,
+                    includeAllComponents: true,
+                });
+                if (entities.length > 0) {
+                    this.cacheContactInfoFromEntities(entities);
+                }
+                logger.info(`[RelationshipsService] Loaded ${this.contactInfoCache.size} contacts from components`);
+                return;
+            }
+            catch (err) {
+                logger.warn(`[RelationshipsService] Failed to query contact components: ${err}`);
+            }
+        }
+        else {
+            logger.warn("[RelationshipsService] runtime.queryEntities is not available; starting with an empty contact cache");
+        }
+        // Start with an empty cache — contacts will be populated as they are added.
+        // This avoids crashing on fresh databases or adapters that do not yet
+        // support queryEntities.
+        logger.info("[RelationshipsService] Starting with empty contact cache (contacts will load on demand)");
+    }
+    // Contact Management Methods
+    async addContact(entityId, categories = ["acquaintance"], preferences, customFields) {
+        const contactInfo = {
+            entityId,
+            categories,
+            tags: [],
+            preferences: preferences ?? {},
+            customFields: customFields ?? {},
+            privacyLevel: "private",
+            lastModified: new Date().toISOString(),
+        };
+        // Save as component
+        await this.runtime.createComponent({
+            id: stringToUuid(`contact-${entityId}-${this.runtime.agentId}`),
+            type: "contact_info",
+            agentId: this.runtime.agentId,
+            entityId,
+            roomId: this.getRelationshipsRoomId(),
+            worldId: this.getRelationshipsWorldId(),
+            sourceEntityId: this.runtime.agentId,
+            data: contactInfoToMetadata(contactInfo),
+            createdAt: Date.now(),
+        });
+        this.setCacheWithLimit(this.contactInfoCache, entityId, contactInfo, RelationshipsService.CONTACT_CACHE_LIMIT);
+        // Emit entity lifecycle event
+        const entity = await this.runtime.getEntityById(entityId);
+        if (entity) {
+            await this.runtime.emitEvent(EntityLifecycleEvent.UPDATED, {
+                entityId: entity.id ?? "",
+                source: "relationships",
+            });
+        }
+        logger.info(`[RelationshipsService] Added contact ${entityId} with categories: ${categories.join(", ")}`);
+        return contactInfo;
+    }
+    async updateContact(entityId, updates) {
+        const existing = await this.getContact(entityId);
+        if (!existing) {
+            logger.warn(`[RelationshipsService] Contact ${entityId} not found`);
+            return null;
+        }
+        const updated = {
+            ...existing,
+            ...updates,
+            entityId, // Ensure entityId cannot be changed
+            lastModified: new Date().toISOString(),
+        };
+        // Update component
+        const contactComponent = await this.getStoredContactComponent(entityId);
+        if (contactComponent) {
+            await this.runtime.updateComponent({
+                ...contactComponent,
+                data: contactInfoToMetadata(updated),
+            });
+        }
+        this.setCacheWithLimit(this.contactInfoCache, entityId, updated, RelationshipsService.CONTACT_CACHE_LIMIT);
+        logger.info(`[RelationshipsService] Updated contact ${entityId}`);
+        return updated;
+    }
+    async getContact(entityId) {
+        // Check cache first
+        if (this.contactInfoCache.has(entityId)) {
+            const cached = this.contactInfoCache.get(entityId);
+            if (cached) {
+                return cached;
+            }
+        }
+        // Load from component if not in cache
+        const contactComponent = await this.getStoredContactComponent(entityId);
+        if (contactComponent?.data) {
+            const contactInfo = metadataToContactInfo(contactComponent.data);
+            this.setCacheWithLimit(this.contactInfoCache, entityId, contactInfo, RelationshipsService.CONTACT_CACHE_LIMIT);
+            return contactInfo;
+        }
+        return null;
+    }
+    async removeContact(entityId) {
+        const existing = await this.getContact(entityId);
+        if (!existing) {
+            logger.warn(`[RelationshipsService] Contact ${entityId} not found`);
+            return false;
+        }
+        // Remove component
+        const contactComponent = await this.getStoredContactComponent(entityId);
+        if (contactComponent) {
+            await this.runtime.deleteComponent(contactComponent.id);
+        }
+        // Remove from cache
+        this.contactInfoCache.delete(entityId);
+        logger.info(`[RelationshipsService] Removed contact ${entityId}`);
+        return true;
+    }
+    async searchContacts(criteria) {
+        const results = [];
+        for (const [, contactInfo] of this.contactInfoCache) {
+            let matches = true;
+            // Check categories
+            if (criteria.categories && criteria.categories.length > 0) {
+                const categorySet = new Set(contactInfo.categories);
+                matches =
+                    matches && criteria.categories.some((cat) => categorySet.has(cat));
+            }
+            // Check tags
+            if (criteria.tags && criteria.tags.length > 0) {
+                const tagSet = new Set(contactInfo.tags);
+                matches = matches && criteria.tags.some((tag) => tagSet.has(tag));
+            }
+            // Check privacy level
+            if (criteria.privacyLevel) {
+                matches = matches && contactInfo.privacyLevel === criteria.privacyLevel;
+            }
+            if (matches) {
+                results.push(contactInfo);
+            }
+        }
+        // If searchTerm is provided, further filter by entity names
+        if (criteria.searchTerm) {
+            const searchTermLower = criteria.searchTerm.toLowerCase();
+            const entities = await Promise.all(results.map((contact) => this.runtime.getEntityById(contact.entityId)));
+            const filteredResults = [];
+            for (let i = 0; i < results.length; i++) {
+                const entity = entities[i];
+                const entityNames = entity?.names ?? [];
+                const displayName = getContactDisplayName(results[i])?.toLowerCase();
+                if (entityNames.some((name) => name.toLowerCase().includes(searchTermLower)) ||
+                    displayName?.includes(searchTermLower) ||
+                    String(results[i].entityId).toLowerCase().includes(searchTermLower)) {
+                    filteredResults.push(results[i]);
+                }
+            }
+            return filteredResults;
+        }
+        return results;
+    }
+    // Relationship Analytics Methods
+    async analyzeRelationship(sourceEntityId, targetEntityId) {
+        const cacheKey = `${sourceEntityId}-${targetEntityId}`;
+        // Check cache first
+        if (this.analyticsCache.has(cacheKey)) {
+            const cached = this.analyticsCache.get(cacheKey);
+            if (cached) {
+                // Cache for 1 hour
+                if (cached.lastInteractionAt &&
+                    Date.now() - new Date(cached.lastInteractionAt).getTime() < 3600000) {
+                    return cached;
+                }
+            }
+        }
+        // Get relationship
+        const relationships = await this.runtime.getRelationships({
+            entityIds: [sourceEntityId],
+        });
+        const relationship = relationships.find((r) => r.targetEntityId === targetEntityId ||
+            r.sourceEntityId === targetEntityId);
+        // Get recent messages from rooms both entities share. `inReplyTo` stores a
+        // parent message id, not an entity id, so direct reply matching here is incorrect.
+        const [sourceRoomIds, targetRoomIds] = await Promise.all([
+            this.runtime.getRoomsForParticipant(sourceEntityId),
+            this.runtime.getRoomsForParticipant(targetEntityId),
+        ]);
+        const targetRoomIdSet = new Set(targetRoomIds.map((roomId) => String(roomId)));
+        const sharedRoomIds = sourceRoomIds.filter((roomId) => targetRoomIdSet.has(String(roomId)));
+        const sharedMessages = sharedRoomIds.length > 0
+            ? await this.runtime.getMemoriesByRoomIds({
+                tableName: "messages",
+                roomIds: sharedRoomIds,
+                limit: 200,
+            })
+            : [];
+        const interactions = sharedMessages
+            .filter((message) => message.entityId === sourceEntityId ||
+            message.entityId === targetEntityId)
+            .sort((a, b) => Number(a.createdAt ?? 0) - Number(b.createdAt ?? 0));
+        if (!relationship && interactions.length === 0) {
+            return null;
+        }
+        // Calculate metrics
+        const interactionCount = interactions.length;
+        const sharedConversationWindows = countSharedConversationWindows(interactions, sourceEntityId, targetEntityId);
+        const lastInteraction = interactions[interactions.length - 1];
+        const lastInteractionAt = lastInteraction?.createdAt
+            ? new Date(Number(lastInteraction.createdAt)).toISOString()
+            : relationship?.lastInteractionAt;
+        // Calculate average response time
+        let totalResponseTime = 0;
+        let responseCount = 0;
+        for (let i = 0; i < interactions.length - 1; i++) {
+            const current = interactions[i];
+            const next = interactions[i + 1];
+            if (current.entityId !== next.entityId &&
+                current.createdAt &&
+                next.createdAt) {
+                const timeDiff = Number(next.createdAt) - Number(current.createdAt);
+                totalResponseTime += timeDiff;
+                responseCount++;
+            }
+        }
+        const averageResponseTime = responseCount > 0 ? totalResponseTime / responseCount : undefined;
+        // Extract topics (simplified - could use NLP)
+        const topicsSet = new Set();
+        for (const msg of interactions) {
+            const text = msg.content.text || "";
+            // Simple keyword extraction - could be enhanced with NLP
+            const keywords = text.match(/\b[A-Z][a-z]+\b/g) || [];
+            for (const k of keywords) {
+                topicsSet.add(k);
+            }
+        }
+        // Calculate relationship strength
+        const strength = calculateRelationshipStrength({
+            interactionCount,
+            lastInteractionAt,
+            relationshipType: relationship?.relationshipType,
+            sharedConversationWindows,
+        });
+        const analytics = {
+            strength,
+            interactionCount,
+            sharedConversationWindows,
+            lastInteractionAt,
+            averageResponseTime,
+            sentimentScore: 0.7, // Placeholder - could integrate sentiment analysis
+            topicsDiscussed: Array.from(topicsSet).slice(0, 10),
+        };
+        // Update relationship with calculated strength
+        if (relationship &&
+            (relationship.strength !== strength ||
+                relationship.lastInteractionAt !== lastInteractionAt)) {
+            // Update relationship using components
+            const relationshipComponent = {
+                id: stringToUuid(`relationship-${relationship.id}`),
+                type: "relationship_update",
+                agentId: this.runtime.agentId,
+                entityId: relationship.sourceEntityId,
+                roomId: this.getRelationshipsRoomId(),
+                worldId: this.getRelationshipsWorldId(),
+                sourceEntityId: relationship.sourceEntityId,
+                data: {
+                    targetEntityId: relationship.targetEntityId,
+                    strength,
+                    lastInteractionAt,
+                    metadata: relationship.metadata,
+                },
+                createdAt: Date.now(),
+            };
+            await this.runtime.createComponent(relationshipComponent);
+        }
+        // Cache the result
+        this.setCacheWithLimit(this.analyticsCache, cacheKey, analytics, RelationshipsService.ANALYTICS_CACHE_LIMIT);
+        return analytics;
+    }
+    async getRelationshipInsights(entityId) {
+        const relationships = await this.runtime.getRelationships({
+            entityIds: [entityId],
+        });
+        const insights = {
+            strongestRelationships: [],
+            needsAttention: [],
+            recentInteractions: [],
+        };
+        const targets = relationships.map((rel) => rel.sourceEntityId === entityId ? rel.targetEntityId : rel.sourceEntityId);
+        const entities = await Promise.all(targets.map((target) => this.runtime.getEntityById(target)));
+        const analyticsResults = await Promise.all(targets.map((target, index) => entities[index] ? this.analyzeRelationship(entityId, target) : null));
+        for (let i = 0; i < relationships.length; i++) {
+            const entity = entities[i];
+            const analytics = analyticsResults[i];
+            if (!entity || !analytics)
+                continue;
+            // Strongest relationships
+            if (analytics.strength > 70) {
+                insights.strongestRelationships.push({ entity, analytics });
+            }
+            // Needs attention (no contact in 30+ days)
+            if (analytics.lastInteractionAt) {
+                const daysSince = (Date.now() - new Date(analytics.lastInteractionAt).getTime()) /
+                    (1000 * 60 * 60 * 24);
+                if (daysSince > 30) {
+                    insights.needsAttention.push({
+                        entity,
+                        daysSinceContact: Math.round(daysSince),
+                    });
+                }
+                // Recent interactions (last 7 days)
+                if (daysSince < 7) {
+                    insights.recentInteractions.push({
+                        entity,
+                        lastInteraction: analytics.lastInteractionAt,
+                    });
+                }
+            }
+        }
+        // Sort by relevance
+        insights.strongestRelationships.sort((a, b) => b.analytics.strength - a.analytics.strength);
+        insights.needsAttention.sort((a, b) => b.daysSinceContact - a.daysSinceContact);
+        insights.recentInteractions.sort((a, b) => new Date(b.lastInteraction).getTime() -
+            new Date(a.lastInteraction).getTime());
+        return insights;
+    }
+    // Category Management
+    async getCategories() {
+        return this.categoriesCache;
+    }
+    async addCategory(category) {
+        if (this.categoriesCache.find((c) => c.id === category.id)) {
+            throw new Error(`Category ${category.id} already exists`);
+        }
+        this.categoriesCache.push(category);
+        logger.info(`[RelationshipsService] Added category: ${category.name}`);
+    }
+    // Privacy Management
+    async setContactPrivacy(entityId, privacyLevel) {
+        const contact = await this.getContact(entityId);
+        if (!contact)
+            return false;
+        contact.privacyLevel = privacyLevel;
+        await this.updateContact(entityId, { privacyLevel });
+        logger.info(`[RelationshipsService] Set privacy level for ${entityId} to ${privacyLevel}`);
+        return true;
+    }
+    async canAccessContact(requestingEntityId, targetEntityId) {
+        const contact = await this.getContact(targetEntityId);
+        if (!contact)
+            return false;
+        // Agent always has access
+        if (requestingEntityId === this.runtime.agentId)
+            return true;
+        // Check privacy level
+        switch (contact.privacyLevel) {
+            case "public":
+                return true;
+            case "private":
+                // Only agent and the entity itself
+                return requestingEntityId === targetEntityId;
+            case "restricted":
+                // Only agent
+                return false;
+            default:
+                return false;
+        }
+    }
+}

package/packages/typescript/src/services/task-scheduler.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Per-daemon task scheduler: one timer, one getTasks(agentIds) per tick, dispatch to registered runtimes.
+ *
+ * WHY: With N runtimes, N local timers would do N getTasks() every second. This module batches: one
+ * getTasks(agentIds) for all dirty agents, then group by task.agentId and call runTick(tasks) per runtime.
+ * Opt-in: host calls startTaskScheduler(adapter); TaskService registers when daemon is present.
+ */
+import type { IDatabaseAdapter } from "../types/database";
+import type { UUID } from "../types/primitives";
+import type { IAgentRuntime } from "../types/runtime";
+import type { Task } from "../types/task";
+/** Minimal type so we don't import TaskService. WHY: avoids circular dependency (task.ts imports this module). */
+interface TaskServiceLike {
+    runTick(tasks: Task[]): Promise<void>;
+}
+/** WHY: host provides the adapter so the scheduler can call getTasks without going through a specific runtime. */
+export declare function startTaskScheduler(adapterInstance: IDatabaseAdapter): void;
+export declare function stopTaskScheduler(): void;
+/** Called by TaskService.startTimer() when getTaskSchedulerAdapter() != null. WHY: runtime opts into shared tick instead of local timer. */
+export declare function registerTaskSchedulerRuntime(runtime: IAgentRuntime, taskService: TaskServiceLike): void;
+/** Called by TaskService.stop(). WHY: daemon must not call runTick after runtime has stopped. */
+export declare function unregisterTaskSchedulerRuntime(agentId: UUID): void;
+/** Called by TaskService.markDirty() when daemon is present. WHY: next tick will include this agent in the batched getTasks. */
+export declare function markTaskSchedulerDirty(agentId: UUID): void;
+/** TaskService uses this to decide: register with daemon vs start local timer. */
+export declare function getTaskSchedulerAdapter(): IDatabaseAdapter | null;
+export {};
+//# sourceMappingURL=task-scheduler.d.ts.map

package/packages/typescript/src/services/task-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-scheduler.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/services/task-scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,kHAAkH;AAClH,UAAU,eAAe;IACxB,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAqDD,kHAAkH;AAClH,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,gBAAgB,GAAG,IAAI,CAM1E;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC;AAED,4IAA4I;AAC5I,wBAAgB,4BAA4B,CAC3C,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,eAAe,GAC1B,IAAI,CAIN;AAED,iGAAiG;AACjG,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAElE;AAED,gIAAgI;AAChI,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAE1D;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,IAAI,gBAAgB,GAAG,IAAI,CAEjE"}