pip install praisonaiagents

from praisonaiagents.compaction import ContextCompactor

# Create a compactor
compactor = ContextCompactor(
    max_tokens=8000,
    strategy="summarize"
)

# Compact messages when needed
compacted = compactor.compact(messages)

from praisonaiagents import CompactionConfig
from praisonaiagents.compaction import ContextCompactor

# With config object (recommended)
compactor = ContextCompactor(
    config=CompactionConfig(
        max_tokens=8000,
        structured_template=True,
        compaction_prefix="[CUSTOM FRAME] ..."
    )
)

# Or with individual parameters
compactor = ContextCompactor(
    max_tokens=8000,
    preserve_recent=5
)

from praisonaiagents import CompactionConfig

config = CompactionConfig(
    max_tokens=8000,
    structured_template=True,
    compaction_prefix="[REFERENCE ONLY] Earlier conversation summary...",
    iterative_update=True
)

from praisonaiagents.compaction import COMPACTION_PREFIX, SUMMARY_TEMPLATE

# Default anti-injection prefix
print(COMPACTION_PREFIX)

# Structured summary template with placeholders:
# {active_task}, {completed}, {in_progress}, {pending}, {files}, {remaining}
print(SUMMARY_TEMPLATE)

from praisonaiagents.compaction import CompactionStrategy

CompactionStrategy.SUMMARIZE  # Summarize old messages
CompactionStrategy.TRUNCATE   # Remove oldest messages
CompactionStrategy.SLIDING    # Sliding window approach

from praisonaiagents.compaction import CompactionResult

result = compactor.compact(messages)
print(result.original_tokens)
print(result.compacted_tokens)
print(result.messages)

from praisonaiagents.compaction import ToolResultPrunerProtocol
from typing import List, Dict, Tuple

class CustomPruner:
    def prune(self, messages: List[Dict], max_tool_result_size: int = 500) -> Tuple[List[Dict], int]:
        """
        Prune tool results from messages.
        
        Args:
            messages: List of message dictionaries
            max_tool_result_size: Maximum size for tool results
            
        Returns:
            Tuple of (processed_messages, pruned_count)
        """
        processed = []
        pruned_count = 0
        
        for msg in messages:
            if msg.get("role") == "tool" and len(msg.get("content", "")) > max_tool_result_size:
                # Custom pruning logic
                pruned_count += 1
            processed.append(msg)
            
        return processed, pruned_count

from praisonaiagents.compaction import MessageFormatterProtocol
from typing import List, Dict

class CustomFormatter:
    def format_for_summary(self, messages: List[Dict]) -> str:
        """
        Format messages for LLM summarization.
        
        Args:
            messages: List of message dictionaries
            
        Returns:
            Formatted string for summarization
        """
        formatted = []
        for i, msg in enumerate(messages):
            role = msg.get("role", "unknown")
            content = msg.get("content", "")
            formatted.append(f"{i+1}. [{role}]: {content[:200]}...")
        
        return "\n".join(formatted)

from praisonaiagents.compaction import SummaryBuilderProtocol
from typing import List, Dict

class CustomSummaryBuilder:
    def build_structured_summary(self, messages: List[Dict]) -> str:
        """
        Build a structured summary from messages.
        
        Args:
            messages: List of message dictionaries
            
        Returns:
            Structured summary string
        """
        return "## Custom Summary Format\nKey points extracted..."
    
    def merge_summaries(self, previous: str, current: str) -> str:
        """
        Merge previous and current summaries for iterative updates.
        
        Args:
            previous: Previous summary content
            current: Current summary content
            
        Returns:
            Merged summary
        """
        return f"{current}\n\n[Previous]: {previous[:200]}..."

from praisonaiagents.compaction import ContextCompactor

compactor = ContextCompactor(max_tokens=8000)

# Inject custom implementations
compactor.tool_pruner = CustomPruner()
compactor.message_formatter = CustomFormatter()
compactor.summary_builder = CustomSummaryBuilder()

# Now compactor uses your custom logic
result = compactor.compact(messages)

from praisonaiagents.compaction import ContextCompactor

compactor = ContextCompactor(max_tokens=4000)

messages = [
    {"role": "system", "content": "You are helpful."},
    {"role": "user", "content": "Long conversation..."},
    # ... many more messages
]

if compactor.needs_compaction(messages):
    # Sync compaction
    compacted, result = compactor.compact(messages)
    
    # With focus topic
    compacted, result = compactor.compact(messages, focus_topic="error handling")
    
    print(f"Saved {result.savings_pct:.1f}% tokens")
    print(f"Tool results pruned: {result.tool_results_pruned}")

import asyncio
from praisonaiagents.compaction import ContextCompactor

async def llm_summarize(prompt):
    # Your LLM call here
    return "Summary of the conversation..."

compactor = ContextCompactor(
    max_tokens=4000,
    llm_summarize_fn=llm_summarize
)

async def main():
    # Async compaction with focus
    compacted, result = await compactor.compact_async(
        messages,
        focus_topic="database optimization"
    )
    
    print(f"Previous summary reused: {result.previous_summary_reused}")
    print(f"Anti-thrashing triggered: {result.was_skipped_due_to_low_savings}")

asyncio.run(main())

from praisonaiagents import Agent
from praisonaiagents.compaction import ContextCompactor

compactor = ContextCompactor(
    max_tokens=8000,
    strategy="summarize"
)

agent = Agent(
    name="Assistant",
    context=ManagerConfig(auto_compact=True, strategy="summarize")
)

# Agent automatically compacts context when needed

from praisonaiagents.compaction import ContextCompactor

compactor = ContextCompactor(
    max_tokens=4000,
    strategy="summarize",
    preserve_recent=10  # Keep last 10 messages
)

# Old messages are summarized into a single message
result = compactor.compact(long_conversation)

from praisonaiagents.compaction import ContextCompactor

compactor = ContextCompactor(
    max_tokens=4000,
    strategy="sliding"
)

# Keeps most recent messages within token budget