@elizaos/python 2.0.0-alpha.10

package/elizaos/advanced_memory/providers.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from elizaos.types import Provider, ProviderResult
+
+
+async def long_term_memory_get(runtime, message, _state=None) -> ProviderResult:
+    svc = runtime.get_service("memory")
+    if svc is None:
+        return ProviderResult(text="", values={"longTermMemories": ""}, data={"memoryCount": 0})
+
+    entity_id = message.entity_id
+    if entity_id == runtime.agent_id:
+        return ProviderResult(text="", values={"longTermMemories": ""}, data={"memoryCount": 0})
+
+    memories = await svc.get_long_term_memories(entity_id, None, 25)
+    if not memories:
+        return ProviderResult(text="", values={"longTermMemories": ""}, data={"memoryCount": 0})
+
+    formatted = await svc.get_formatted_long_term_memories(entity_id)
+    text = f"# What I Know About You\n\n{formatted}"
+
+    category_counts: dict[str, int] = {}
+    for m in memories:
+        category_counts[m.category.value] = category_counts.get(m.category.value, 0) + 1
+    category_list = ", ".join(f"{k}: {v}" for k, v in category_counts.items())
+
+    return ProviderResult(
+        text=text,
+        values={"longTermMemories": text, "memoryCategories": category_list},
+        data={"memoryCount": len(memories), "categories": category_list},
+    )
+
+
+async def context_summary_get(runtime, message, _state=None) -> ProviderResult:
+    svc = runtime.get_service("memory")
+    if svc is None:
+        return ProviderResult(
+            text="",
+            values={"sessionSummaries": "", "sessionSummariesWithTopics": ""},
+            data={},
+        )
+
+    current = await svc.get_current_session_summary(message.room_id)
+    if current is None:
+        return ProviderResult(
+            text="",
+            values={"sessionSummaries": "", "sessionSummariesWithTopics": ""},
+            data={},
+        )
+
+    summary_only = (
+        f"**Previous Conversation** ({current.message_count} messages)\n{current.summary}"
+    )
+    summary_with_topics = (
+        summary_only + f"\n*Topics: {', '.join(current.topics)}*"
+        if current.topics
+        else summary_only
+    )
+    session_summaries = f"# Conversation Summary\n\n{summary_only}" if summary_only else ""
+    session_summaries_with_topics = (
+        f"# Conversation Summary\n\n{summary_with_topics}" if summary_with_topics else ""
+    )
+
+    return ProviderResult(
+        text=session_summaries_with_topics,
+        values={
+            "sessionSummaries": session_summaries,
+            "sessionSummariesWithTopics": session_summaries_with_topics,
+        },
+        data={
+            "summaryText": current.summary,
+            "messageCount": current.message_count,
+            "topics": ", ".join(current.topics),
+        },
+    )
+
+
+long_term_memory_provider = Provider(
+    name="LONG_TERM_MEMORY",
+    description="Persistent facts and preferences about the user",
+    position=50,
+    get=long_term_memory_get,
+)
+
+context_summary_provider = Provider(
+    name="SUMMARIZED_CONTEXT",
+    description="Provides summarized context from previous conversations",
+    position=96,
+    get=context_summary_get,
+)

package/elizaos/advanced_memory/types.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from uuid import UUID
+
+
+class LongTermMemoryCategory(str, Enum):
+    EPISODIC = "episodic"
+    SEMANTIC = "semantic"
+    PROCEDURAL = "procedural"
+
+
+@dataclass
+class MemoryConfig:
+    short_term_summarization_threshold: int = 16
+    short_term_retain_recent: int = 6
+    short_term_summarization_interval: int = 10
+    long_term_extraction_enabled: bool = True
+    long_term_vector_search_enabled: bool = False
+    long_term_confidence_threshold: float = 0.85
+    long_term_extraction_threshold: int = 30
+    long_term_extraction_interval: int = 10
+    summary_model_type: str = "TEXT_LARGE"
+    summary_max_tokens: int = 2500
+    summary_max_new_messages: int = 20
+
+
+@dataclass
+class LongTermMemory:
+    id: UUID
+    agent_id: UUID
+    entity_id: UUID
+    category: LongTermMemoryCategory
+    content: str
+    confidence: float = 1.0
+    source: str | None = None
+    metadata: dict[str, object] = field(default_factory=dict)
+
+
+@dataclass
+class SessionSummary:
+    id: UUID
+    agent_id: UUID
+    room_id: UUID
+    entity_id: UUID | None
+    summary: str
+    message_count: int
+    last_message_offset: int
+    topics: list[str] = field(default_factory=list)
+    metadata: dict[str, object] = field(default_factory=dict)
+
+
+@dataclass
+class SummaryResult:
+    summary: str
+    topics: list[str]
+    key_points: list[str]
+
+
+@dataclass
+class MemoryExtraction:
+    category: LongTermMemoryCategory
+    content: str
+    confidence: float

package/elizaos/advanced_planning/__init__.py

@@ -0,0 +1,10 @@
+"""Built-in advanced planning (gated by Character.advancedPlanning)."""
+
+from .planning_service import PlanningService
+from .plugin import advanced_planning_plugin, create_advanced_planning_plugin
+
+__all__ = [
+    "advanced_planning_plugin",
+    "create_advanced_planning_plugin",
+    "PlanningService",
+]

package/elizaos/advanced_planning/actions.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import re
+import time
+from uuid import uuid4
+
+from elizaos.types import Action, ActionResult
+
+
+async def _always_validate(_runtime, _message, _state=None) -> bool:
+    return True
+
+
+async def analyze_input_handler(
+    _runtime, message, _state=None, options=None, _callback=None, _responses=None
+):
+    abort_signal = getattr(options, "abort_signal", None)
+    if abort_signal is not None and getattr(abort_signal, "aborted", False):
+        raise RuntimeError("Analysis aborted")
+
+    text = message.content.text or ""
+    words = text.split() if text.strip() else []
+    sentiment = "neutral"
+    lower = text.lower()
+    if any(w in lower for w in ["urgent", "emergency", "critical"]):
+        sentiment = "urgent"
+    elif "good" in lower:
+        sentiment = "positive"
+    elif "bad" in lower:
+        sentiment = "negative"
+
+    return ActionResult(
+        success=True,
+        text=f"Analyzed {len(words)} words with {sentiment} sentiment",
+        data={
+            "wordCount": len(words),
+            "hasNumbers": bool(re.search(r"\d", text)),
+            "sentiment": sentiment,
+            "topics": [w.lower() for w in words if len(w) >= 5],
+            "timestamp": int(time.time() * 1000),
+        },
+    )
+
+
+async def process_analysis_handler(
+    _runtime, _message, _state=None, options=None, _callback=None, _responses=None
+):
+    previous = getattr(options, "previous_results", None) or []
+    prev0 = previous[0] if previous else None
+    analysis = getattr(prev0, "data", None) or {}
+    word_count = int(analysis.get("wordCount") or 0)
+    sentiment = str(analysis.get("sentiment") or "neutral")
+
+    decisions = {
+        "needsMoreInfo": word_count < 5,
+        "isComplex": word_count > 20,
+        "requiresAction": sentiment != "neutral" or word_count > 8,
+        "suggestedResponse": (
+            "Thank you for the positive feedback!"
+            if sentiment == "positive"
+            else "I understand your concerns and will help address them."
+            if sentiment == "negative"
+            else "I can help you with that."
+        ),
+    }
+
+    return ActionResult(
+        success=True,
+        text=str(decisions["suggestedResponse"]),
+        data={
+            "analysis": analysis,
+            "decisions": decisions,
+            "processedAt": int(time.time() * 1000),
+            "shouldContinue": not decisions["needsMoreInfo"],
+        },
+    )
+
+
+async def execute_final_handler(
+    _runtime, _message, _state=None, options=None, callback=None, _responses=None
+):
+    previous = getattr(options, "previous_results", None) or []
+    decisions = None
+    for r in previous:
+        data = getattr(r, "data", None) or {}
+        if "decisions" in data:
+            decisions = data.get("decisions")
+            break
+    if not isinstance(decisions, dict):
+        raise RuntimeError("No processing results available")
+
+    msg = str(decisions.get("suggestedResponse") or "Done")
+    if callback is not None:
+        await callback({"text": msg, "source": "chain_example"})
+
+    return ActionResult(success=True, text=msg, data={"action": "RESPOND", "message": msg})
+
+
+async def create_plan_validate(_runtime, message, _state=None) -> bool:
+    text = (message.content.text or "").lower()
+    return any(k in text for k in ["plan", "project", "comprehensive", "organize", "strategy"])
+
+
+async def create_plan_handler(
+    _runtime, _message, _state=None, _options=None, callback=None, _responses=None
+):
+    plan_id = str(uuid4())
+    if callback is not None:
+        await callback(
+            {
+                "text": "I've created a comprehensive project plan.",
+                "actions": ["CREATE_PLAN"],
+                "source": "planning",
+            }
+        )
+    return ActionResult(success=True, text="Created plan", data={"planId": plan_id})
+
+
+analyze_input_action = Action(
+    name="ANALYZE_INPUT",
+    description="Analyzes user input and extracts key information",
+    validate=_always_validate,
+    handler=analyze_input_handler,
+)
+
+process_analysis_action = Action(
+    name="PROCESS_ANALYSIS",
+    description="Processes the analysis results and makes decisions",
+    validate=_always_validate,
+    handler=process_analysis_handler,
+)
+
+execute_final_action = Action(
+    name="EXECUTE_FINAL",
+    description="Executes the final action based on processing results",
+    validate=_always_validate,
+    handler=execute_final_handler,
+)
+
+create_plan_action = Action(
+    name="CREATE_PLAN",
+    description="Creates a comprehensive project plan",
+    validate=create_plan_validate,
+    handler=create_plan_handler,
+)

package/elizaos/advanced_planning/message_classifier.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import time
+
+from elizaos.types import Provider, ProviderResult
+from elizaos.types.model import ModelType
+
+from .prompts import MESSAGE_CLASSIFIER_TEMPLATE
+
+
+async def get_message_classification(runtime, message, _state=None) -> ProviderResult:
+    text = message.content.text or ""
+
+    if not text.strip():
+        return ProviderResult(
+            text="Message classified as: general (empty message)",
+            data={
+                "classification": "general",
+                "confidence": 0.1,
+                "complexity": "simple",
+                "planningRequired": False,
+                "stakeholders": [],
+                "constraints": [],
+            },
+        )
+
+    try:
+        prompt = MESSAGE_CLASSIFIER_TEMPLATE.format(text=text)
+        response = await runtime.use_model(
+            ModelType.TEXT_SMALL,
+            {
+                "prompt": prompt,
+                "temperature": 0.3,
+                "maxTokens": 300,
+            },
+        )
+
+        response_text = str(response)
+        lines = response_text.splitlines()
+
+        def _parse_list(prefix: str) -> list[str]:
+            line = next((ln for ln in lines if ln.startswith(prefix)), "")
+            if not line:
+                return []
+            raw = line[len(prefix) :].strip()
+            if not raw:
+                return []
+            return [s.strip() for s in raw.split(",") if s.strip()]
+
+        complexity = next(
+            (ln[len("COMPLEXITY:") :].strip() for ln in lines if ln.startswith("COMPLEXITY:")),
+            "simple",
+        )
+        planning_type = next(
+            (ln[len("PLANNING:") :].strip() for ln in lines if ln.startswith("PLANNING:")),
+            "direct_action",
+        )
+        confidence_str = next(
+            (ln[len("CONFIDENCE:") :].strip() for ln in lines if ln.startswith("CONFIDENCE:")),
+            "0.5",
+        )
+        try:
+            confidence = float(confidence_str)
+        except Exception:
+            confidence = 0.5
+        confidence = max(0.0, min(1.0, confidence))
+
+        capabilities = _parse_list("CAPABILITIES:")
+        stakeholders = _parse_list("STAKEHOLDERS:")
+        constraints = _parse_list("CONSTRAINTS:")
+        dependencies = _parse_list("DEPENDENCIES:")
+
+        planning_required = planning_type != "direct_action" and complexity != "simple"
+
+        classification = "general"
+        lower = text.lower()
+        if "strategic" in lower or planning_type == "strategic_planning":
+            classification = "strategic"
+        elif "analyz" in lower:
+            classification = "analysis"
+        elif "process" in lower:
+            classification = "processing"
+        elif "execute" in lower:
+            classification = "execution"
+
+        return ProviderResult(
+            text=f"Message classified as: {classification} ({complexity} complexity, {planning_type}) with confidence: {confidence}",
+            data={
+                "classification": classification,
+                "confidence": confidence,
+                "originalText": text,
+                "complexity": complexity,
+                "planningType": planning_type,
+                "planningRequired": planning_required,
+                "capabilities": capabilities,
+                "stakeholders": stakeholders,
+                "constraints": constraints,
+                "dependencies": dependencies,
+                "analyzedAt": int(time.time() * 1000),
+                "modelUsed": "TEXT_SMALL",
+            },
+        )
+    except Exception as e:
+        return ProviderResult(
+            text="Message classified as: general with confidence: 0.5 (fallback)",
+            data={
+                "classification": "general",
+                "confidence": 0.5,
+                "originalText": text,
+                "complexity": "simple",
+                "planningRequired": False,
+                "planningType": "direct_action",
+                "capabilities": [],
+                "stakeholders": [],
+                "constraints": [],
+                "dependencies": [],
+                "error": str(e),
+                "fallback": True,
+            },
+        )
+
+
+message_classifier_provider = Provider(
+    name="messageClassifier",
+    description="Classifies messages by complexity and planning requirements",
+    get=get_message_classification,
+)