create-leafmesh 2.1.0__py3-none-any.whl

create_leafmesh/templates/agency/advisor_agent.py

@@ -0,0 +1,151 @@
+"""LLM Agent — Auto-discovered with @chain + @compose (OR fan-in advisor).
+
+auto_discover matches function name 'advisor_agent' to YAML agent config.
+
+Features showcased:
+  - @chain: sequential post-processing pipeline (validate_inputs -> score_priorities)
+  - @compose: inject helper functions into context (report shaping, alert shaping)
+  - wait_for: "processor_agent AND (researcher_agent OR fallback_researcher_agent)"
+  - OR fan-in: whichever research agent finishes first satisfies the expression
+  - optimization_strategy: "performance" — prioritizes quality over cost
+
+Execution flow:
+  1. Fan-in: SDK waits for processor_agent AND (researcher OR fallback_researcher)
+  2. fallback_researcher_agent is instant → OR resolves immediately
+  3. LLM analyzes combined upstream results
+  4. This function post-processes, picking the best research source
+  5. @compose injects shape_report and shape_alerts into context
+  6. @chain runs: validate_inputs -> score_priorities (sequential pipeline)
+
+Fan-in patterns (all supported by the SDK):
+  wait_for: "A AND B"                  — waits for both A and B
+  wait_for: "A OR B"                   — waits for either A or B (first wins)
+  wait_for: "A AND B?"                 — A required, B optional
+  wait_for: "A AND (B OR C)"           — A required + first of B or C (used here)
+  wait_for: "A AND (B OR C) AND D?"    — A required + first of B/C + D optional
+"""
+from leafmesh import chain, compose, LeafMeshLogger
+
+logger = LeafMeshLogger(__name__)
+
+
+def validate_inputs(result, context):
+    """Chain step 1: Validate that upstream data is present and well-formed."""
+    if not result.get("recommendations"):
+        result["recommendations"] = ["No specific recommendations available"]
+    if not result.get("risk_assessment"):
+        result["risk_assessment"] = "Unable to assess — insufficient data"
+    result["validated"] = True
+    return result
+
+
+def score_priorities(result, context):
+    """Chain step 2: Score and rank recommendations by priority."""
+    recs = result.get("recommendations", [])
+    result["priority_score"] = min(1.0, len(recs) * 0.2) if recs else 0.0
+    result["next_steps"] = recs[:3] if recs else ["Gather more data"]
+    result["scored"] = True
+    return result
+
+
+def shape_report(data, context):
+    """Compose helper: Shape output for report consumption."""
+    return {
+        "title": "Advisory Report",
+        "recommendations": data.get("recommendations", []),
+        "risk_assessment": data.get("risk_assessment", ""),
+        "priority_score": data.get("priority_score", 0),
+        "project": "{{project_name}}",
+    }
+
+
+def shape_alerts(data, context):
+    """Compose helper: Shape output for alerting systems."""
+    score = data.get("priority_score", 0)
+    return {
+        "alert_level": "high" if score > 0.7 else "medium" if score > 0.4 else "low",
+        "summary": data.get("risk_assessment", ""),
+        "action_required": score > 0.5,
+    }
+
+
+@chain(validate_inputs, score_priorities)
+@compose(report=shape_report, alerts=shape_alerts)
+async def advisor_agent(llm_response, input_data, context):
+    """Analyze upstream results and produce actionable recommendations.
+
+    At this point:
+      - Fan-in complete: processor_agent AND (researcher OR fallback) finished
+      - input_data["upstream_yields"] has yields from all contributing agents
+      - context["report"] and context["alerts"] are injected by @compose
+      - After this function, @chain runs validate_inputs -> score_priorities
+    """
+    # ─── Fan-in upstream yields ───
+    # For OR fan-in, the SDK includes yields from whichever agents completed.
+    # Check both research agents — prefer LLM researcher (higher confidence).
+    upstream_yields = input_data.get("upstream_yields", {})
+    processor_yields = upstream_yields.get("processor_agent", {})
+    researcher_yields = upstream_yields.get("researcher_agent", {})
+    fallback_yields = upstream_yields.get("fallback_researcher_agent", {})
+
+    # ─── Pick the best research source ───
+    # LLM researcher has confidence 0.85, fallback has 0.6
+    skipped_agents = []
+    if researcher_yields and researcher_yields.get("status") == "researched":
+        research_data = researcher_yields
+        research_source = "researcher_agent"
+        research_confidence = 0.85
+    elif fallback_yields and fallback_yields.get("status") == "researched":
+        research_data = fallback_yields
+        research_source = "fallback_researcher_agent"
+        research_confidence = 0.6
+        skipped_agents.append("researcher_agent")
+    else:
+        research_data = {}
+        research_source = "none"
+        research_confidence = 0.0
+        skipped_agents.extend(["researcher_agent", "fallback_researcher_agent"])
+
+    # ─── Build recommendations from upstream data ───
+    processed_items = processor_yields.get("processed_items", [])
+    findings = research_data.get("findings", [])
+
+    recommendations = []
+    if processed_items:
+        urgent = [i for i in processed_items if i.get("category") == "urgent"]
+        if urgent:
+            recommendations.append(f"Address {len(urgent)} urgent item(s) immediately")
+        recommendations.append(f"Review {len(processed_items)} processed items")
+
+    if findings:
+        recommendations.append(f"Incorporate {len(findings)} research finding(s)")
+
+    risk = "low"
+    if any(i.get("category") == "urgent" for i in processed_items):
+        risk = "elevated — urgent items detected"
+
+    logger.info(f"Advisory complete — {len(recommendations)} recommendations, risk={risk}, source={research_source}")
+
+    return {
+        "recommendations": recommendations,
+        "risk_assessment": risk,
+        "research_source": research_source,
+        "research_confidence": research_confidence,
+        "skipped_agents": skipped_agents,
+        "source_data": {
+            "processed_count": len(processed_items),
+            "finding_count": len(findings),
+        },
+        "status": "advised",
+    }
+
+# ─── Alternative: @chain_with_results ───
+# If you want to accumulate results from each chain step:
+#
+# from leafmesh import chain_with_results
+#
+# @chain_with_results(validate_inputs, score_priorities)
+# async def advisor_agent(llm_response, input_data, context):
+#     # After execution, context["chain_results"] has a list of
+#     # each step's return value: [validate_result, score_result]
+#     ...

create_leafmesh/templates/agency/external_agents.py

@@ -0,0 +1,278 @@
+"""External Agent Reference — ALL external integrations documented here.
+
+NOTE: This file is named external_agents.py (NOT *_agent.py) so auto_discover
+skips it. Everything here is COMMENTED OUT — uncomment what you need.
+
+Each section includes:
+  - Required environment variables
+  - YAML config to add to config.yaml
+  - Python implementation code
+
+All connectors are included with `pip install leafmesh` — no extra installs needed.
+
+For each integration, you have TWO options:
+  1. Add the YAML config to config.yaml as an external agent
+  2. Use helper factories to wire into an existing agent's pipeline
+     (works with @pre_compose, @chain, and @conditional_chain)
+"""
+
+# ===================================================================
+# 1. CREWAI — Delegate to a CrewAI crew
+# ===================================================================
+#
+# YAML config (add to agents: section in config.yaml):
+#   crewai_research:
+#     name: "crewai_research"
+#     agent_type: "external"
+#     framework: "crewai"
+#     description: "Delegates research tasks to a CrewAI crew"
+#     connector_config:
+#       endpoint: "http://localhost:9000"
+#       api_key: "${CREWAI_API_KEY:}"
+#     yields:
+#       research_result: "string"
+#       sources: "list"
+#     can_call:
+#       - agent: "advisor_agent"
+#
+# Python (create agency/crewai_research_agent.py):
+# from leafmesh import pre_compose
+#
+# async def crewai_research_agent(external_response, input_data, context):
+#     """Post-process CrewAI crew results."""
+#     return {
+#         "research_result": external_response.get("output", ""),
+#         "sources": external_response.get("sources", []),
+#     }
+
+
+# ===================================================================
+# 2. LANGGRAPH — Delegate to a LangGraph graph
+# ===================================================================
+#
+# YAML config:
+#   langgraph_workflow:
+#     name: "langgraph_workflow"
+#     agent_type: "external"
+#     framework: "langgraph"
+#     description: "Runs a LangGraph stateful workflow"
+#     connector_config:
+#       endpoint: "${LANGGRAPH_API_URL:http://localhost:8123}"
+#       api_key: "${LANGGRAPH_API_KEY:}"
+#       graph_id: "my_graph"
+#     yields:
+#       workflow_result: "object"
+#
+# Python (create agency/langgraph_workflow_agent.py):
+# async def langgraph_workflow_agent(external_response, input_data, context):
+#     return {"workflow_result": external_response}
+
+
+# ===================================================================
+# 3. AUTOGEN — Delegate to an AutoGen agent group
+# ===================================================================
+#
+# YAML config:
+#   autogen_team:
+#     name: "autogen_team"
+#     agent_type: "external"
+#     framework: "autogen"
+#     description: "Multi-agent conversation via AutoGen"
+#     connector_config:
+#       endpoint: "http://localhost:8081"
+#     yields:
+#       team_result: "string"
+#
+# Python (create agency/autogen_team_agent.py):
+# async def autogen_team_agent(external_response, input_data, context):
+#     return {"team_result": external_response.get("output", "")}
+
+
+# ===================================================================
+# 4. A2A (Agent-to-Agent Protocol) — Google's interop standard
+# ===================================================================
+#
+# YAML config:
+#   a2a_partner:
+#     name: "a2a_partner"
+#     agent_type: "external"
+#     framework: "a2a"
+#     description: "Communicates with an A2A-compatible agent"
+#     connector_config:
+#       endpoint: "http://partner-agent:8080"
+#       agent_card_url: "http://partner-agent:8080/.well-known/agent.json"
+#     yields:
+#       partner_response: "object"
+#
+# Python (create agency/a2a_partner_agent.py):
+# async def a2a_partner_agent(external_response, input_data, context):
+#     return {"partner_response": external_response}
+
+
+# ===================================================================
+# 5. MCP (Model Context Protocol) — Tool servers
+# ===================================================================
+#
+# Two transport modes: HTTP (SSE) and stdio
+#
+# YAML config (HTTP mode):
+#   mcp_tools:
+#     name: "mcp_tools"
+#     agent_type: "external"
+#     framework: "mcp"
+#     description: "Access tools from an MCP server"
+#     connector_config:
+#       transport: "http"
+#       endpoint: "http://localhost:3000/sse"
+#     yields:
+#       tool_results: "object"
+#
+# YAML config (stdio mode):
+#   mcp_local:
+#     name: "mcp_local"
+#     agent_type: "external"
+#     framework: "mcp"
+#     description: "Local MCP tool server via stdio"
+#     connector_config:
+#       transport: "stdio"
+#       command: "npx"
+#       args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+#     yields:
+#       tool_results: "object"
+#
+# Python (create agency/mcp_tools_agent.py):
+# async def mcp_tools_agent(external_response, input_data, context):
+#     return {"tool_results": external_response}
+
+
+# ===================================================================
+# 6. ZAPIER — Natural Language Actions
+# ===================================================================
+#
+# Set env: ZAPIER_NLA_API_KEY=your-key
+#
+# YAML config:
+#   zapier_actions:
+#     name: "zapier_actions"
+#     agent_type: "external"
+#     framework: "zapier"
+#     description: "Trigger Zapier NLA actions"
+#     connector_config:
+#       api_key: "${ZAPIER_NLA_API_KEY:}"
+#     yields:
+#       action_result: "object"
+#
+# Python (create agency/zapier_actions_agent.py):
+# async def zapier_actions_agent(external_response, input_data, context):
+#     return {"action_result": external_response}
+
+
+# ===================================================================
+# 7. COMPOSIO — Managed tool integrations (GitHub, Slack, etc.)
+# ===================================================================
+#
+# Set env: COMPOSIO_API_KEY=your-key
+#
+# YAML config:
+#   composio_tools:
+#     name: "composio_tools"
+#     agent_type: "external"
+#     framework: "composio"
+#     description: "Access Composio-managed integrations"
+#     connector_config:
+#       api_key: "${COMPOSIO_API_KEY:}"
+#       actions: ["github_star_repo", "slack_send_message"]
+#     yields:
+#       integration_result: "object"
+#
+# Python (create agency/composio_tools_agent.py):
+# async def composio_tools_agent(external_response, input_data, context):
+#     return {"integration_result": external_response}
+
+
+# ===================================================================
+# 8. N8N — Workflow automation
+# ===================================================================
+#
+# Set env: N8N_BASE_URL=http://localhost:5678, N8N_API_KEY=your-key
+#
+# YAML config:
+#   n8n_workflow:
+#     name: "n8n_workflow"
+#     agent_type: "external"
+#     framework: "n8n"
+#     description: "Trigger n8n workflows"
+#     connector_config:
+#       base_url: "${N8N_BASE_URL:http://localhost:5678}"
+#       api_key: "${N8N_API_KEY:}"
+#       workflow_id: "your-workflow-id"
+#     yields:
+#       workflow_result: "object"
+#
+# Python (create agency/n8n_workflow_agent.py):
+# async def n8n_workflow_agent(external_response, input_data, context):
+#     return {"workflow_result": external_response}
+
+
+# ===================================================================
+# 9. HELPER FACTORIES — Wire integrations into agent decorators
+#
+# These work with @pre_compose (before LLM), @chain (after agent),
+# and @conditional_chain (conditional post-processing).
+# ===================================================================
+#
+# from leafmesh import pre_compose, chain, conditional_chain, mcp, zapier, composio, n8n
+#
+# # ── @pre_compose: run BEFORE the LLM call ──
+# @pre_compose(context_processor=mcp("https://mcp.example.com", "get_weather", args={"city": "NYC"}))
+# def weather_agent(llm_response, input_data, context):
+#     return {"result": llm_response}
+#
+# # ── @chain: run AFTER the agent completes ──
+# @chain(zapier("send_slack_message", connection="slack"))
+# async def notify_agent(llm_response, input_data, context):
+#     return {"message": llm_response.get("summary")}
+#
+# # ── @conditional_chain: run conditionally after the agent ──
+# @conditional_chain(lambda r, ctx: r.get("needs_enrichment"), composio("GITHUB_STAR_REPO"))
+# async def enricher(llm_response, input_data, context):
+#     return {"needs_enrichment": True, "data": llm_response}
+#
+# # ── n8n webhook as a chain step ──
+# @chain(n8n("https://my-n8n.example.com/webhook/notify"))
+# async def alert_agent(llm_response, input_data, context):
+#     return {"event": "completed", "data": llm_response}
+
+
+# ===================================================================
+# 10. CUSTOM CONNECTOR — Build your own integration
+# ===================================================================
+#
+# from leafmesh.external.connectors.base_connector import ExternalConnector
+#
+# class MyCustomConnector(ExternalConnector):
+#     """Custom connector for your proprietary system."""
+#
+#     async def connect(self):
+#         """Initialize connection to the external system."""
+#         self.client = await create_my_client(self.config)
+#
+#     async def execute(self, input_data: dict) -> dict:
+#         """Send data to the external system and return results."""
+#         response = await self.client.run(input_data)
+#         return {"result": response}
+#
+#     async def disconnect(self):
+#         """Clean up resources."""
+#         await self.client.close()
+#
+# # Register in connector_registry:
+# from leafmesh.external.connectors.connector_registry import ConnectorRegistry
+# ConnectorRegistry.register("my_system", MyCustomConnector)
+#
+# # Then use in YAML:
+# #   my_agent:
+# #     agent_type: "external"
+# #     framework: "my_system"
+# #     connector_config:
+# #       endpoint: "http://my-system:8080"

create_leafmesh/templates/agency/fallback_researcher_agent.py

@@ -0,0 +1,80 @@
+"""Programmatic Agent — Fast template-based research fallback (no LLM).
+
+auto_discover matches function name 'fallback_researcher_agent' to YAML agent config.
+
+Features showcased:
+  - Programmatic agent: pure Python, no LLM call, instant response
+  - OR fan-in: advisor_agent uses wait_for: "processor_agent AND (researcher_agent OR fallback_researcher_agent)"
+  - Race pattern: this agent completes instantly while researcher_agent waits for LLM
+  - Mirrors researcher_agent's output schema so advisor_agent can consume either
+
+Execution flow:
+  1. processor_agent fans out to researcher_agent AND fallback_researcher_agent
+  2. This agent returns immediately with template-based findings
+  3. researcher_agent is still waiting for LLM response
+  4. advisor_agent's OR expression resolves — it proceeds with fallback data
+  5. researcher_agent result arrives later (already resolved, ignored by fan-in)
+"""
+from leafmesh import chain, LeafMeshLogger
+
+logger = LeafMeshLogger(__name__)
+
+
+def enrich_findings(result, context):
+    """Chain step: Add analysis metadata to template findings."""
+    findings = result.get("findings", [])
+    result["analysis"] = {
+        "total_findings": len(findings),
+        "confidence_score": 0.6,
+        "data_quality": "template",
+        "source_type": "fallback_template",
+    }
+    result["report"] = {
+        "title": "Fallback Research Findings",
+        "confidence": 0.6,
+        "quality": "template",
+        "finding_count": len(findings),
+        "formatted": True,
+    }
+    return result
+
+
+@chain(enrich_findings)
+async def fallback_researcher_agent(llm_response, input_data, context):
+    """Instant template-based research — no LLM needed.
+
+    Provides a fast fallback so the advisor_agent can proceed immediately
+    via OR fan-in without waiting for the slower LLM-based researcher_agent.
+    """
+    upstream_yields = input_data.get("upstream_yields", {})
+    processor_yields = upstream_yields.get("processor_agent", {})
+
+    calling_data = input_data.get("calling_agent_response", {})
+    processed_items = calling_data.get("processed_items", [])
+
+    # Build template-based findings from upstream data
+    findings = []
+    for item in processed_items:
+        findings.append({
+            "source": "template",
+            "content": item.get("item", ""),
+            "recommendation": f"Review and address: {item.get('item', 'unknown')}",
+        })
+
+    if not findings:
+        findings.append({
+            "source": "template",
+            "content": "No specific items to research",
+            "recommendation": "Gather more information from the user",
+        })
+
+    logger.info(f"Fallback research — {len(findings)} template findings")
+
+    return {
+        "findings": findings,
+        "query": input_data.get("message", input_data.get("research_topic", "")),
+        "upstream_item_count": processor_yields.get("item_count", 0),
+        "source_agent": "fallback_researcher_agent",
+        "source_type": "fallback_template",
+        "status": "researched",
+    }

create_leafmesh/templates/agency/greeter_agent.py

@@ -0,0 +1,79 @@
+"""LLM Agent — Auto-discovered with @pre_compose (all 3 processor types).
+
+auto_discover matches function name 'greeter_agent' to YAML agent config.
+
+Execution flow:
+  1. Processors run BEFORE the LLM call (data preparation)
+  2. context_parts (care, sentiment, guardrails) shape the LLM's tone
+  3. LLM generates response using YAML prompt + prepared data
+  4. This function post-processes the LLM response
+
+Processor results in context["prepared_data"]:
+  - context_processor → context["prepared_data"]["business_context"]
+  - input_processor   → context["prepared_data"]["clean_user_input"]
+  - others_processor  → context["prepared_data"]["others"]
+"""
+from leafmesh import pre_compose, LeafMeshLogger
+
+logger = LeafMeshLogger(__name__)
+
+
+def process_context(input_data, context):
+    """context_processor: Prepare business context for the LLM prompt.
+    Runs before LLM — enriches the prompt with relevant domain info."""
+    return {
+        "domain": "task_management",
+        "session_id": context.get("session_id", "unknown"),
+    }
+
+
+def clean_input(input_data, context):
+    """input_processor: Extract and clean the user's message.
+    Runs before LLM — normalizes input for consistent processing."""
+    raw = input_data.get("message", "")
+    return {"user_message": raw.strip()}
+
+
+def load_extras(input_data, context):
+    """others_processor: Load auxiliary data (feature flags, config, etc.).
+    Runs before LLM — provides supplementary data."""
+    return {"timestamp_requested": "message" in input_data}
+
+
+@pre_compose(
+    context_processor=process_context,
+    input_processor=clean_input,
+    others_processor=load_extras,
+)
+async def greeter_agent(llm_response, input_data, context):
+    """Post-process the LLM's response.
+
+    At this point:
+      - Processors already ran (before LLM call)
+      - context_parts (care, sentiment, guardrails) already shaped the LLM's tone
+      - llm_response has the LLM's output
+      - context["prepared_data"] has processor results
+    """
+    prepared = context.get("prepared_data", {})
+
+    # ─── Memory access (add memory: true to this agent's YAML to enable) ───
+    # memory_posts = context.get("memory_posts", [])
+    # Each post has "role" (user/assistant) and "content" (text).
+    # See researcher_agent.py for a working memory example.
+
+    # ─── Upstream yields access ───
+    # If this agent is called by another agent (e.g., client → greeter_agent),
+    # the SDK injects upstream yields as input_data["upstream_yields"].
+    # upstream_yields = input_data.get("upstream_yields", {})
+    # client_yields = upstream_yields.get("client", {})
+
+    user_input = input_data.get("message", "")
+    logger.info(f"Greeting user — input: {user_input[:80]}")
+
+    return {
+        "greeting": llm_response if llm_response else "Hello!",
+        "user_input": user_input,
+        "detected_sentiment": "neutral",
+        "domain": prepared.get("business_context", {}).get("domain", "general"),
+        "status": "greeted",
+    }

create_leafmesh/templates/agency/processor_agent.py

@@ -0,0 +1,90 @@
+"""Programmatic Agent — Pure Python, no LLM, @conditional_chain branching.
+
+auto_discover matches function name 'processor_agent' to YAML agent config.
+parallel: true is set in config.yaml — enables concurrent execution.
+
+All agent functions use the 3-param signature: (llm_response, input_data, context)
+For programmatic agents, llm_response is always None (no LLM is called).
+
+Data flow:
+  greeter_agent returns output → SDK evaluates can_call rules →
+  SDK passes output as input_data to this agent automatically.
+
+Upstream yields:
+  When greeter_agent stores yields (greeting, user_input, detected_sentiment),
+  the SDK injects them as input_data["upstream_yields"][calling_agent_name].
+  This gives downstream agents typed access to structured data from upstream.
+"""
+from leafmesh import conditional_chain, LeafMeshLogger
+
+logger = LeafMeshLogger(__name__)
+
+
+def handle_urgent(result, context):
+    """Conditional chain: runs only when urgent items exist."""
+    urgent = [i for i in result.get("processed_items", []) if i["category"] == "urgent"]
+    result["urgent_items"] = urgent
+    result["alert"] = f"{len(urgent)} urgent item(s) flagged"
+    return result
+
+
+def handle_normal(result, context):
+    """Conditional chain: runs when no urgent items."""
+    result["alert"] = "No urgent items"
+    return result
+
+
+@conditional_chain(
+    lambda result, ctx: any(i["category"] == "urgent" for i in result.get("processed_items", [])),
+    handle_urgent,
+    handle_normal,
+)
+async def processor_agent(llm_response, input_data, context):
+    """Process the greeter's output into structured action items.
+
+    Pure Python processing — no LLM cost.
+    llm_response is always None for programmatic agents.
+    With parallel: true, multiple invocations run concurrently.
+
+    After this function returns, @conditional_chain runs either
+    handle_urgent or handle_normal based on the result.
+    Then SDK evaluates can_call rules to chain to the next agent.
+    """
+    # SDK passes the calling agent's output directly as input_data.
+    # "calling_agent_response" is a virtual variable only in YAML condition evaluation.
+
+    # ─── Upstream yields access ───
+    # When greeter_agent has yields defined in YAML, the SDK auto-injects them:
+    upstream_yields = input_data.get("upstream_yields", {})
+    greeter_yields = upstream_yields.get("greeter_agent", {})
+    # greeter_yields has: greeting, user_input, detected_sentiment, status
+    detected_sentiment = greeter_yields.get("detected_sentiment", "unknown")
+
+    # In HITL flow (greeter → client → processor), input_data comes from the
+    # human agent's output — look for human_message first, then greeter yields,
+    # then direct user_input (non-HITL path: greeter → processor).
+    user_input = (
+        input_data.get("human_message", "")
+        or greeter_yields.get("user_input", "")
+        or input_data.get("user_input", "")
+    )
+
+    raw_items = [item.strip() for item in user_input.split(",") if item.strip()]
+
+    categorized = []
+    for item in raw_items:
+        categorized.append({
+            "item": item,
+            "category": "urgent" if any(w in item.lower() for w in ["asap", "urgent", "now"]) else "normal",
+        })
+
+    urgent_count = sum(1 for i in categorized if i["category"] == "urgent")
+    logger.info(f"Processed {len(categorized)} items ({urgent_count} urgent)")
+
+    return {
+        "processed_items": categorized,
+        "item_count": len(categorized),
+        "source_agent": "greeter_agent",
+        "upstream_sentiment": detected_sentiment,
+        "status": "processed",
+    }