Context Compaction

import uuid

conversation_id = str(uuid.uuid4())

# Record messages before any compaction call.
# Each message must carry the user_id and customer_id that scope the conversation.
await sdk.conversation.record_message(
    conversation_id=conversation_id,
    role="user",
    content="I'd like to plan a trip to Japan in April.",
    user_id="user_alice",
    customer_id="acme_corp",
)
await sdk.conversation.record_message(
    conversation_id=conversation_id,
    role="assistant",
    content="Great choice! April is cherry blossom season. Would you prefer Tokyo or Kyoto?",
    user_id="user_alice",
    customer_id="acme_corp",
)

result = await sdk.conversation.context.get_context_for_prompt(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c"
)

if result.available:
    # Inject into your LLM system prompt
    system_prompt = f"""You are a helpful assistant.

## Conversation History
{result.formatted_context}"""
else:
    # No compacted context yet: use context.fetch() or trigger compact()
    system_prompt = "You are a helpful assistant."

result = await sdk.conversation.context.get_context_for_prompt(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    style="structured"  # "narrative" and "bullet_points" return identical output for now
)

result = await sdk.conversation.context.get_context_for_prompt(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c"
)

if not result.available:
    # Option 1: Fall back to retrieval-based context
    context = await sdk.conversation.context.fetch(
        conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
        search_query=[user_message],
        mode="fast"
    )

    # Option 2: Trigger compaction, then retry
    await sdk.conversation.context.compact(
        conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
        strategy="adaptive"
    )

compaction = await sdk.conversation.context.compact(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    strategy="adaptive",
    target_tokens=2000,
    force=False
)

print(f"Compaction ID: {compaction.compaction_id}")
print(f"Status: {compaction.status}")

compacted = await sdk.conversation.context.get_compacted(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    version=None,            # None = latest version
    format="structured",
)

if compacted:
    print(f"Compacted context: {compacted.compacted_context[:200]}...")
    print(f"Compression ratio: {compacted.compression_ratio:.0%}")
    for fact in compacted.facts:
        print(f"- {fact}")
else:
    print("No compaction exists for this conversation yet.")

status = await sdk.conversation.context.get_compaction_status(
    conversation_id="3f6b1a2c-4d5e-6f7a-8b9c-0d1e2f3a4b5c"
)

print(f"Status: {status.status}")              # e.g. "completed", "in_progress", "none"
print(f"Compaction ID: {status.compaction_id}")
print(f"Latest version: {status.latest_version}")
print(f"Compression ratio: {status.compression_ratio}")
print(f"Validation score: {status.validation_score}")
print(f"Completed at: {status.completed_at}")
print(f"Latest created at: {status.latest_created_at}")

async def chat_with_memory(conversation_id: str, user_message: str):
    """Chat using compacted memory context."""

    # Get compacted context (cached locally, safe to call every turn)
    compacted = await sdk.conversation.context.get_context_for_prompt(
        conversation_id=conversation_id,
        style="structured"
    )

    # Also fetch query-specific context for this message
    recent = await sdk.conversation.context.fetch(
        conversation_id=conversation_id,
        search_query=[user_message],
        max_results=5,
        mode="fast"
    )

    recent_facts = "\n".join(
        f"- {fact.content}" for fact in recent.facts if fact.confidence >= 0.8
    )

    # Build system prompt
    history_section = ""
    if compacted.available:
        history_section = f"""
## Conversation History (Compacted)
{compacted.formatted_context}
"""
        if compacted.is_stale:
            # Optionally trigger re-compaction in the background
            await sdk.conversation.context.compact(
                conversation_id=conversation_id,
                strategy="adaptive"
            )

    system_prompt = f"""You are a helpful assistant with memory of past conversations.
{history_section}
## Recently Relevant Facts
{recent_facts if recent_facts else "None specifically relevant to this query."}

Use this context to personalize your responses."""

    # Pass to your LLM
    # response = await llm.generate(system_prompt, user_message)
    return system_prompt

async def get_optimized_context(conversation_id: str, token_budget: int = 2000) -> str:
    """Get compacted context for a conversation, re-compacting if needed."""

    # Check current compaction status (CompactionStatusResponse: use dot access)
    status = await sdk.conversation.context.get_compaction_status(
        conversation_id=conversation_id
    )

    if status.status == "completed":
        # Existing compaction is available: retrieve it
        compacted = await sdk.conversation.context.get_compacted(
            conversation_id=conversation_id,
            format="structured"
        )
        if compacted:
            return compacted.compacted_context

    # No completed compaction yet: trigger one
    trigger = await sdk.conversation.context.compact(
        conversation_id=conversation_id,
        strategy="adaptive",
        target_tokens=token_budget
    )

    print(f"Compaction {trigger.compaction_id} triggered, "
          f"status={trigger.status}, "
          f"~{trigger.estimated_completion_seconds}s to complete")

    # Poll until ready, then fetch the result
    while True:
        status = await sdk.conversation.context.get_compaction_status(
            conversation_id=conversation_id
        )
        if status.status in ("completed", "failed"):
            break
        await asyncio.sleep(1)

    if status.status == "failed":
        raise RuntimeError(f"Compaction failed: {status.error_message}")

    compacted = await sdk.conversation.context.get_compacted(
        conversation_id=conversation_id,
        format="structured"
    )

    if compacted.quality_warning:
        print(f"Compaction quality warning set")

    print(f"Compacted {compacted.original_token_count} tokens → "
          f"{compacted.compacted_token_count} tokens "
          f"({compacted.compression_ratio:.0%} ratio, "
          f"validation: {compacted.validation_score})")

    return compacted.compacted_context


async def chat_with_compacted_memory(conversation_id: str, user_message: str):
    """Chat using compacted memory context."""

    # Get optimized context within token budget
    memory_context = await get_optimized_context(
        conversation_id=conversation_id,
        token_budget=2000
    )

    # Also fetch recent high-relevance context for this specific query
    recent = await sdk.conversation.context.fetch(
        conversation_id=conversation_id,
        search_query=[user_message],
        max_results=5,
        mode="fast"
    )

    # Build system prompt with both compacted history and recent context
    recent_facts = "\n".join(
        f"- {fact.content}" for fact in recent.facts if fact.confidence >= 0.8
    )

    system_prompt = f"""You are a helpful assistant with memory of past conversations.

## Conversation History (Compacted)
{memory_context}

## Recently Relevant Facts
{recent_facts if recent_facts else "None specifically relevant to this query."}

Use this context to personalize your responses."""

    # Pass to your LLM
    # response = await llm.generate(system_prompt, user_message)
    return system_prompt