# From: src/solace_agent_mesh/agent/adk/app_llm_agent.py
class AppLlmAgent(LlmAgent):
    """
    Custom LlmAgent subclass that includes a reference to the hosting
    SamAgentComponent.

    This allows tools and callbacks within the ADK agent's execution context
    to access host-level configurations and services.
    """
    host_component: Any = Field(None, exclude=True)

# From agent tools/callbacks
from solace_agent_mesh.common import a2a

# Create a message to send to another agent
message = a2a.create_user_message(
    parts=[a2a.create_text_part("Analyze this data for insights")],
    metadata={"source_agent": "research_agent"}
)

# Send request to peer agent
request = a2a.create_send_streaming_message_request(
    message=message,
    task_id="subtask_123"
)

# Publish to peer agent's request topic
topic = a2a.get_agent_request_topic(namespace, "analysis_agent")
component.publish_a2a_message(
    payload=request.model_dump(exclude_none=True),
    topic=topic,
    user_properties={
        "clientId": component.agent_name,
        "replyTo": a2a.get_agent_response_topic(
            namespace, 
            component.agent_name, 
            "subtask_123"
        )
    }
)

async def _create_compaction_event(
    component: "SamAgentComponent",
    session: ADKSession,
    compaction_threshold: float = 0.25,
) -> tuple[int, str]:
    """
    Create a compaction event using percentage-based progressive summarization.
    
    Strategy:
    1. Calculate total token count across all conversation events
    2. Determine target compaction size (total_tokens * compaction_threshold)
    3. Find user turn boundary closest to target percentage
    4. Extract previous summary and create fake event for LlmEventSummarizer
    5. Pass [FakeSummaryEvent, NewEvents] to LLM for progressive re-compression
    6. Persist compaction event to DB (append-only, old events remain)
    """

from solace_agent_mesh.agent.utils.artifact_helpers import (
    save_artifact_with_metadata
)

# Save artifact from agent code
await save_artifact_with_metadata(
    artifact_service=component.shared_artifact_service,
    app_name=component.agent_name,
    user_id=session.user_id,
    session_id=session.id,
    filename="analysis_report.md",
    content=report_content.encode('utf-8'),
    mime_type="text/markdown",
    description="Research findings report",
    metadata={"generated_by": "research_agent"}
)

Here's the analysis report:

{{ARTIFACT:analysis_report.md}}

The data shows interesting patterns...

tools:
  - type: mcp
    name: filesystem
    command: node
    args:
      - /path/to/filesystem-server/index.js
    env:
      ALLOWED_DIRECTORIES: /workspace,/data

async def run_adk_async_task(
    component: "SamAgentComponent",
    task_context: "TaskExecutionContext",
    adk_session: ADKSession,
    adk_content: adk_types.Content,
    run_config: RunConfig,
    a2a_context: dict[str, Any],
) -> bool:
    """
    Runs the ADK Runner asynchronously and processes events:
    - User messages
    - Model responses  
    - Tool calls (function_call events)
    - Tool results (function_response events)
    - Long-running tool tracking
    """
    pending_long_running_tools: set[str] = set()
    
    async for event in adk_event_generator:
        # Process different event types
        if event.content:
            # Stream text/data to gateway
            await component.process_intermediate_event(...)