@elizaos/python 2.0.0-alpha.10

package/elizaos/bootstrap/providers/contacts.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("CONTACTS")
+
+
+async def get_contacts_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    from elizaos.bootstrap.services.rolodex import RolodexService
+
+    rolodex_service = runtime.get_service("rolodex")
+    if not rolodex_service or not isinstance(rolodex_service, RolodexService):
+        return ProviderResult(text="", values={}, data={})
+
+    contacts = await rolodex_service.get_all_contacts()
+
+    if not contacts:
+        return ProviderResult(text="No contacts in rolodex.", values={"contactCount": 0}, data={})
+
+    contact_details: list[dict[str, str]] = []
+    for contact in contacts:
+        entity = await runtime.get_entity(contact.entity_id)
+        name = entity.name if entity and entity.name else "Unknown"
+        contact_details.append(
+            {
+                "id": str(contact.entity_id),
+                "name": name,
+                "categories": ",".join(contact.categories),
+                "tags": ",".join(contact.tags),
+            }
+        )
+
+    grouped: dict[str, list[dict[str, str]]] = {}
+    for detail in contact_details:
+        for cat in detail["categories"].split(","):
+            cat = cat.strip()
+            if cat:
+                grouped.setdefault(cat, []).append(detail)
+
+    text_summary = f"You have {len(contacts)} contacts in your rolodex:\n"
+
+    for category, items in grouped.items():
+        text_summary += f"\n{category.capitalize()}s ({len(items)}):\n"
+        for item in items:
+            text_summary += f"- {item['name']}"
+            if item["tags"]:
+                text_summary += f" [{item['tags']}]"
+            text_summary += "\n"
+
+    category_counts = {cat: len(items) for cat, items in grouped.items()}
+
+    return ProviderResult(
+        text=text_summary.strip(),
+        values={
+            "contactCount": len(contacts),
+            **category_counts,
+        },
+        data=category_counts,
+    )
+
+
+contacts_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_contacts_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/context_bench.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("CONTEXT_BENCH")
+
+
+async def get_context_bench(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    _ = runtime
+    _ = state
+    meta = getattr(message, "metadata", None)
+    bench_ctx = None
+    if meta is not None:
+        maybe = getattr(meta, "benchmarkContext", None)
+        if isinstance(maybe, str) and maybe.strip():
+            bench_ctx = maybe.strip()
+
+    if not bench_ctx:
+        return ProviderResult(
+            text="",
+            values={"benchmark_has_context": False},
+            data={},
+        )
+
+    return ProviderResult(
+        text=f"# Benchmark Context\n{bench_ctx}",
+        values={"benchmark_has_context": True},
+        data={"benchmarkContext": bench_ctx},
+    )
+
+
+context_bench_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_context_bench,
+    position=_spec.get("position"),
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/current_time.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("CURRENT_TIME")
+
+
+async def get_current_time_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    now = datetime.now(UTC)
+
+    iso_timestamp = now.isoformat()
+    human_readable = now.strftime("%A, %B %d, %Y at %H:%M:%S UTC")
+    date_only = now.strftime("%Y-%m-%d")
+    time_only = now.strftime("%H:%M:%S")
+    day_of_week = now.strftime("%A")
+    unix_timestamp = int(now.timestamp())
+
+    context_text = f"# Current Time\n- Date: {date_only}\n- Time: {time_only} UTC\n- Day: {day_of_week}\n- Full: {human_readable}\n- ISO: {iso_timestamp}"
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "currentTime": iso_timestamp,
+            "currentDate": date_only,
+            "dayOfWeek": day_of_week,
+            "unixTimestamp": unix_timestamp,
+        },
+        data={
+            "iso": iso_timestamp,
+            "date": date_only,
+            "time": time_only,
+            "dayOfWeek": day_of_week,
+            "humanReadable": human_readable,
+            "unixTimestamp": unix_timestamp,
+        },
+    )
+
+
+current_time_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_current_time_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/entities.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("ENTITIES")
+
+
+async def get_entities_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    room_id = message.room_id
+    sender_id = message.entity_id
+
+    sections: list[str] = []
+    entity_list: list[dict[str, str]] = []
+
+    if sender_id:
+        sender = await runtime.get_entity(sender_id)
+        if sender:
+            sender_info = {
+                "id": str(sender.id),
+                "name": sender.name or "Unknown",
+                "type": sender.entity_type or "user",
+                "role": "sender",
+            }
+            entity_list.append(sender_info)
+            sections.append(
+                f"- **{sender.name or 'Unknown'}** (sender): {sender.entity_type or 'user'}"
+            )
+
+    if room_id:
+        room = await runtime.get_room(room_id)
+        if room and room.world_id:
+            world = await runtime.get_world(room.world_id)
+            if world and world.metadata:
+                member_ids = world.metadata.get("members", [])
+                roles = world.metadata.get("roles", {})
+
+                for member_id in member_ids:
+                    if str(member_id) == str(sender_id):
+                        continue
+
+                    entity = await runtime.get_entity(member_id)
+                    if entity:
+                        role = roles.get(str(member_id), "member")
+                        entity_info = {
+                            "id": str(entity.id),
+                            "name": entity.name or "Unknown",
+                            "type": entity.entity_type or "user",
+                            "role": role,
+                        }
+                        entity_list.append(entity_info)
+                        sections.append(
+                            f"- **{entity.name or 'Unknown'}** ({role}): {entity.entity_type or 'user'}"
+                        )
+
+    agent_entity = await runtime.get_entity(runtime.agent_id)
+    if agent_entity:
+        agent_info = {
+            "id": str(agent_entity.id),
+            "name": agent_entity.name or runtime.character.name,
+            "type": "agent",
+            "role": "self",
+        }
+        entity_list.append(agent_info)
+        sections.append(f"- **{agent_entity.name or runtime.character.name}** (self): agent")
+
+    context_text = "# Entities in Context\n" + "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "entityCount": len(entity_list),
+            "hasSender": sender_id is not None,
+            "agentId": str(runtime.agent_id),
+        },
+        data={
+            "entities": entity_list,
+            "senderId": str(sender_id) if sender_id else None,
+            "agentId": str(runtime.agent_id),
+        },
+    )
+
+
+entities_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_entities_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/evaluators.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("EVALUATORS")
+
+
+async def get_evaluators(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    evaluator_info: list[dict[str, str]] = []
+
+    for evaluator in runtime.evaluators:
+        evaluator_info.append(
+            {
+                "name": evaluator.name,
+                "description": getattr(evaluator, "description", "No description"),
+            }
+        )
+
+    if not evaluator_info:
+        return ProviderResult(
+            text="No evaluators available.",
+            values={"evaluatorCount": 0},
+            data={"evaluators": []},
+        )
+
+    formatted_evaluators = "\n".join(f"- {e['name']}: {e['description']}" for e in evaluator_info)
+
+    text = f"# Available Evaluators\n{formatted_evaluators}"
+
+    return ProviderResult(
+        text=text,
+        values={
+            "evaluatorCount": len(evaluator_info),
+            "evaluatorNames": [e["name"] for e in evaluator_info],
+        },
+        data={
+            "evaluators": evaluator_info,
+        },
+    )
+
+
+evaluators_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_evaluators,
+    dynamic=_spec.get("dynamic", False),
+)

package/elizaos/bootstrap/providers/facts.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("FACTS")
+
+
+async def get_facts_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    sections: list[str] = []
+    facts_list: list[dict[str, str]] = []
+
+    entity_id = message.entity_id
+    room_id = message.room_id
+
+    if entity_id:
+        sender_facts = await runtime.get_memories(
+            entity_id=entity_id,
+            memory_type="fact",
+            limit=10,
+        )
+
+        if sender_facts:
+            sender = await runtime.get_entity(entity_id)
+            sender_name = sender.name if sender and sender.name else "User"
+            sections.append(f"\n## Facts about {sender_name}")
+
+            for fact in sender_facts:
+                if fact.content and fact.content.text:
+                    fact_text = fact.content.text
+                    if len(fact_text) > 200:
+                        fact_text = fact_text[:200] + "..."
+                    facts_list.append(
+                        {"entityId": str(entity_id), "entityName": sender_name, "fact": fact_text}
+                    )
+                    sections.append(f"- {fact_text}")
+
+    if room_id:
+        room_facts = await runtime.get_memories(
+            room_id=room_id,
+            memory_type="fact",
+            limit=5,
+        )
+
+        if room_facts:
+            sections.append("\n## Room Context Facts")
+            for fact in room_facts:
+                if fact.content and fact.content.text:
+                    fact_text = fact.content.text
+                    if len(fact_text) > 200:
+                        fact_text = fact_text[:200] + "..."
+                    facts_list.append({"roomId": str(room_id), "fact": fact_text})
+                    sections.append(f"- {fact_text}")
+
+    context_text = ""
+    if sections:
+        context_text = "# Known Facts" + "\n".join(sections)
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "factCount": len(facts_list),
+            "hasFacts": len(facts_list) > 0,
+        },
+        data={
+            "facts": facts_list,
+        },
+    )
+
+
+facts_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_facts_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/follow_ups.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("FOLLOW_UPS")
+
+
+async def get_follow_ups_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    from elizaos.bootstrap.services.follow_up import FollowUpService
+
+    follow_up_service = runtime.get_service("follow_up")
+    if not follow_up_service or not isinstance(follow_up_service, FollowUpService):
+        return ProviderResult(text="", values={}, data={})
+
+    upcoming = await follow_up_service.get_upcoming_follow_ups(days_ahead=7, include_overdue=True)
+
+    if not upcoming:
+        return ProviderResult(
+            text="No upcoming follow-ups scheduled.", values={"followUpCount": 0}, data={}
+        )
+
+    now = datetime.now(UTC)
+
+    overdue_items: list[dict[str, str]] = []
+    upcoming_items: list[dict[str, str]] = []
+
+    for task in upcoming:
+        scheduled = datetime.fromisoformat(task.scheduled_at.replace("Z", "+00:00"))
+        entity = await runtime.get_entity(task.entity_id)
+        name = entity.name if entity and entity.name else "Unknown"
+
+        item = {
+            "entityId": str(task.entity_id),
+            "name": name,
+            "scheduledAt": task.scheduled_at,
+            "reason": task.reason,
+            "priority": task.priority,
+        }
+
+        if scheduled < now:
+            days_overdue = (now - scheduled).days
+            item["daysOverdue"] = str(days_overdue)
+            overdue_items.append(item)
+        else:
+            days_until = (scheduled - now).days
+            item["daysUntil"] = str(days_until)
+            upcoming_items.append(item)
+
+    text_summary = f"You have {len(upcoming)} follow-up(s) scheduled:\n"
+
+    if overdue_items:
+        text_summary += f"\nOverdue ({len(overdue_items)}):\n"
+        for item in overdue_items:
+            text_summary += f"- {item['name']} ({item['daysOverdue']} days overdue)"
+            if item.get("reason"):
+                text_summary += f" - {item['reason']}"
+            text_summary += "\n"
+
+    if upcoming_items:
+        text_summary += f"\nUpcoming ({len(upcoming_items)}):\n"
+        for item in upcoming_items:
+            days = int(item["daysUntil"])
+            if days == 0:
+                time_str = "today"
+            elif days == 1:
+                time_str = "tomorrow"
+            else:
+                time_str = f"in {days} days"
+            text_summary += f"- {item['name']} ({time_str})"
+            if item.get("reason"):
+                text_summary += f" - {item['reason']}"
+            text_summary += "\n"
+
+    suggestions = await follow_up_service.get_follow_up_suggestions()
+    if suggestions:
+        text_summary += "\nSuggested follow-ups:\n"
+        for s in suggestions[:3]:
+            text_summary += (
+                f"- {s.entity_name} ({s.days_since_last_contact} days since last contact)\n"
+            )
+
+    return ProviderResult(
+        text=text_summary.strip(),
+        values={
+            "followUpCount": len(upcoming),
+            "overdueCount": len(overdue_items),
+            "upcomingCount": len(upcoming_items),
+            "suggestionsCount": len(suggestions),
+        },
+        data={
+            "followUpCount": len(upcoming),
+            "overdueCount": len(overdue_items),
+            "upcomingCount": len(upcoming_items),
+            "suggestionsCount": len(suggestions),
+        },
+    )
+
+
+follow_ups_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_follow_ups_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/knowledge.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("KNOWLEDGE")
+
+
+async def get_knowledge_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    sections: list[str] = []
+    knowledge_entries: list[dict[str, str]] = []
+
+    query_text = ""
+    if message.content and message.content.text:
+        query_text = message.content.text
+
+    if not query_text:
+        return ProviderResult(
+            text="", values={"knowledgeCount": 0, "hasKnowledge": False}, data={"entries": []}
+        )
+
+    relevant_knowledge = await runtime.search_knowledge(
+        query=query_text,
+        limit=5,
+    )
+
+    for entry in relevant_knowledge:
+        if entry.content and entry.content.text:
+            knowledge_text = entry.content.text
+            if len(knowledge_text) > 500:
+                knowledge_text = knowledge_text[:500] + "..."
+
+            entry_dict = {
+                "id": str(entry.id) if entry.id else "",
+                "text": knowledge_text,
+                "source": str(entry.metadata.get("source", "unknown"))
+                if entry.metadata
+                else "unknown",
+            }
+            knowledge_entries.append(entry_dict)
+            sections.append(f"- {knowledge_text}")
+
+    context_text = "# Relevant Knowledge\n" + "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "knowledgeCount": len(knowledge_entries),
+            "hasKnowledge": len(knowledge_entries) > 0,
+        },
+        data={
+            "entries": knowledge_entries,
+            "query": query_text,
+        },
+    )
+
+
+knowledge_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_knowledge_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/providers_list.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("PROVIDERS")
+
+
+async def get_providers_list(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    provider_info: list[dict[str, str | bool]] = []
+
+    for provider in runtime.providers:
+        provider_info.append(
+            {
+                "name": provider.name,
+                "description": getattr(provider, "description", "No description"),
+                "dynamic": getattr(provider, "dynamic", True),
+            }
+        )
+
+    if not provider_info:
+        return ProviderResult(
+            text="No providers available.",
+            values={"providerCount": 0},
+            data={"providers": []},
+        )
+
+    formatted_providers = "\n".join(f"- {p['name']}: {p['description']}" for p in provider_info)
+
+    text = f"# Available Providers\n{formatted_providers}"
+
+    return ProviderResult(
+        text=text,
+        values={
+            "providerCount": len(provider_info),
+            "providerNames": [p["name"] for p in provider_info],
+        },
+        data={
+            "providers": provider_info,
+        },
+    )
+
+
+providers_list_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_providers_list,
+    dynamic=_spec.get("dynamic", False),
+)