create-leafmesh 2.1.0__py3-none-any.whl

create_leafmesh/__init__.py

@@ -0,0 +1,3 @@
+"""create-leafmesh — Project scaffolding tool for LeafMesh."""
+
+__version__ = "2.1.0"

create_leafmesh/cli.py

@@ -0,0 +1,252 @@
+"""CLI entry point for create-leafmesh."""
+
+import argparse
+import re
+import sys
+import time
+
+from create_leafmesh import __version__
+from create_leafmesh.create import create_project
+
+# ---------------------------------------------------------------------------
+# ANSI helpers (graceful fallback on terminals that don't support color)
+# ---------------------------------------------------------------------------
+_CYAN   = "\033[36m"
+_GREEN  = "\033[32m"
+_WHITE  = "\033[97m"
+_DIM    = "\033[2m"
+_BOLD   = "\033[1m"
+_RESET  = "\033[0m"
+
+def _c(code: str, text: str) -> str:
+    """Wrap text in an ANSI code, reset after."""
+    return f"{code}{text}{_RESET}"
+
+
+# ---------------------------------------------------------------------------
+# ASCII art — block letters for LEAFMESH
+# ---------------------------------------------------------------------------
+BANNER = r"""
+  ██╗     ███████╗ █████╗ ███████╗███╗   ███╗███████╗███████╗██╗  ██╗
+  ██║     ██╔════╝██╔══██╗██╔════╝████╗ ████║██╔════╝██╔════╝██║  ██║
+  ██║     █████╗  ███████║█████╗  ██╔████╔██║█████╗  ███████╗███████║
+  ██║     ██╔══╝  ██╔══██║██╔══╝  ██║╚██╔╝██║██╔══╝  ╚════██║██╔══██║
+  ███████╗███████╗██║  ██║██║     ██║ ╚═╝ ██║███████╗███████║██║  ██║
+  ╚══════╝╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝     ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝
+"""
+
+def print_banner(version: str) -> None:
+    print()
+    print(_c(_CYAN, BANNER), end="")
+    pad = " " * 2
+    print(f"{pad}  create-leafmesh {_c(_DIM, 'v' + version)}   "
+          f"{_c(_DIM, 'Agent mesh scaffolding tool')}")
+    print(f"{pad}  " + "-" * 55)
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Step progress printer
+# ---------------------------------------------------------------------------
+def step(n: int, total: int, label: str, done: bool = False) -> None:
+    status = _c(_GREEN, "[ OK ]") if done else _c(_DIM, "[    ]")
+    print(f"  {status}  [{n}/{total}]  {label}")
+
+
+def step_done(n: int, total: int, label: str) -> None:
+    print(f"\033[1A\r  {_c(_GREEN, '[ OK ]')}  [{n}/{total}]  {label}")
+
+
+# ---------------------------------------------------------------------------
+# File tree renderer
+# ---------------------------------------------------------------------------
+FILE_TREE = """\
+  {name}/
+  |-- agency/
+  |   |-- greeter_agent.py
+  |   |-- processor_agent.py
+  |   |-- researcher_agent.py
+  |   |-- advisor_agent.py
+  |   |-- fallback_researcher_agent.py
+  |   `-- scheduler_agent.py
+  |-- configs/
+  |   `-- config.yaml
+  |-- main.py
+  |-- hitl_stub_receiver.py
+  |-- requirements.txt
+  |-- .env
+  |-- Dockerfile
+  `-- docker-compose.yml"""
+
+
+# ---------------------------------------------------------------------------
+# Next-steps box
+# ---------------------------------------------------------------------------
+def print_success_box(project_name: str, missing_keys: list[str]) -> None:
+    w = 58
+
+    def row(text: str = "") -> str:
+        return f"  |  {text:<{w - 4}}|"
+
+    def div() -> str:
+        return "  +" + "-" * (w - 2) + "+"
+
+    def header(text: str) -> str:
+        return "  |  " + _c(_GREEN, _c(_BOLD, f"{text:<{w - 4}}")) + "|"
+
+    print()
+    print(div())
+    print(header(f"Project ready: {project_name}"))
+    print(div())
+    print(row())
+    print(row(f"  cd {project_name}"))
+    print(row(f"  pip install -r requirements.txt"))
+    if missing_keys:
+        print(row())
+        print(row(f"  # Add to .env before starting:"))
+        for k in missing_keys:
+            print(row(f"  #   {k}=<your-key>"))
+    print(row())
+    print(row(f"  Terminal 1:   python hitl_stub_receiver.py"))
+    print(row(f"  Terminal 2:   python main.py"))
+    print(row())
+    print(row(f"  Open:         http://127.0.0.1:18820/docs"))
+    print(row())
+    print(div())
+    print(row(f"  Docs:         https://leafcraft.ai/docs"))
+    print(div())
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Validation / prompts
+# ---------------------------------------------------------------------------
+def validate_project_name(name: str) -> str:
+    if not re.match(r"^[a-zA-Z][a-zA-Z0-9_-]*$", name):
+        raise argparse.ArgumentTypeError(
+            f"Invalid project name '{name}'. "
+            "Must start with a letter and contain only alphanumeric characters, "
+            "hyphens, or underscores."
+        )
+    return name
+
+
+def prompt_project_name() -> str:
+    while True:
+        name = input("  Project name: ").strip()
+        if not name:
+            print("  Name cannot be empty.")
+            continue
+        if not re.match(r"^[a-zA-Z][a-zA-Z0-9_-]*$", name):
+            print("  Must start with a letter, letters/numbers/hyphens/underscores only.")
+            continue
+        return name
+
+
+def prompt_env_vars() -> dict:
+    w = 55
+    print()
+    print("  " + "-" * w)
+    print(f"  {'Environment setup':^{w}}")
+    print(f"  {'(press Enter to skip any field)':^{w}}")
+    print("  " + "-" * w)
+    print()
+
+    env_vars: dict = {}
+
+    fields = [
+        ("LEAFMESH_LICENSE_KEY",  "License key    (https://leafcraft.ai): "),
+        ("LEAFMESH_ENV_TOKEN",    "Env token      (https://leafcraft.ai): "),
+        ("OPENAI_API_KEY",        "OpenAI key     (https://platform.openai.com): "),
+        ("ANTHROPIC_API_KEY",     "Anthropic key  (optional): "),
+    ]
+
+    for key, label in fields:
+        val = input(f"  {label}").strip()
+        if val:
+            env_vars[key] = val
+
+    print()
+    return env_vars
+
+
+# ---------------------------------------------------------------------------
+# Main create flow
+# ---------------------------------------------------------------------------
+def _run_create(project_name: str | None, output_dir: str, no_git: bool) -> int:
+    print_banner(__version__)
+
+    if project_name is None:
+        project_name = prompt_project_name()
+        print()
+    else:
+        try:
+            project_name = validate_project_name(project_name)
+        except argparse.ArgumentTypeError as e:
+            print(f"  Error: {e}")
+            return 1
+
+    env_vars = prompt_env_vars()
+
+    # Hand off to create_project, passing our step-printer so it can report progress
+    print(f"  Creating {_c(_BOLD, project_name + '/')}")
+    print()
+
+    result = create_project(
+        project_name,
+        output_dir,
+        init_git=not no_git,
+        env_vars=env_vars,
+        step_fn=step,
+        step_done_fn=step_done,
+    )
+
+    if result != 0:
+        return result
+
+    # File tree — print line by line with dim so pipe chars aren't swallowed
+    print()
+    for line in FILE_TREE.format(name=project_name).splitlines():
+        print(_c(_DIM, line))
+
+    # Success box
+    missing = [k for k in ("LEAFMESH_LICENSE_KEY", "OPENAI_API_KEY") if k not in env_vars]
+    print_success_box(project_name, missing)
+
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="create-leafmesh",
+        description="Project scaffolding tool for LeafMesh",
+        epilog="""
+examples:
+  create-leafmesh my-project              Create a new project
+  create-leafmesh my-project -o /tmp      Create in a specific directory
+  create-leafmesh                         Interactive mode
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version=f"create-leafmesh {__version__}")
+    parser.add_argument("project_name", nargs="?", default=None, help="Project name")
+    parser.add_argument("-o", "--output-dir", default=".", help="Output directory (default: current)")
+    parser.add_argument("--no-git", action="store_true", help="Skip git init")
+
+    args = parser.parse_args(argv)
+    try:
+        return _run_create(args.project_name, args.output_dir, args.no_git)
+    except KeyboardInterrupt:
+        print("\n\n  Cancelled.\n")
+        return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except KeyboardInterrupt:
+        print("\n\n  Cancelled.\n")
+        sys.exit(0)

create_leafmesh/create.py

@@ -0,0 +1,106 @@
+"""Project scaffolding logic."""
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Callable
+
+TEMPLATES_DIR = Path(__file__).parent / "templates"
+
+RENAME_MAP = {
+    "env": ".env",
+    "gitignore": ".gitignore",
+    "dockerignore": ".dockerignore",
+}
+
+SUBSTITUTE_EXTENSIONS = {".py", ".yaml", ".yml", ".txt", ".md", ".env", ""}
+
+ENV_PLACEHOLDERS = {
+    "LEAFMESH_LICENSE_KEY": "your-license-key-here",
+    "LEAFMESH_ENV_TOKEN":   "your-env-token-here",
+    "OPENAI_API_KEY":       "your-key-here",
+    "ANTHROPIC_API_KEY":    "your-anthropic-key",
+}
+
+# Step labels — order matches execution
+_STEPS = [
+    "Copying template files",
+    "Writing .env",
+    "Setting up git repository",
+    "Installing Claude Code skill",
+]
+_TOTAL = len(_STEPS)
+
+
+def _noop(*args, **kwargs) -> None:
+    pass
+
+
+def create_project(
+    project_name: str,
+    output_dir: str,
+    *,
+    init_git: bool = True,
+    env_vars: dict | None = None,
+    step_fn: Callable = _noop,
+    step_done_fn: Callable = _noop,
+) -> int:
+    target = Path(output_dir).resolve() / project_name
+
+    if target.exists():
+        print(f"\n  Error: '{target}' already exists.\n")
+        return 1
+
+    # Step 1 — copy template
+    step_fn(1, _TOTAL, _STEPS[0])
+    shutil.copytree(TEMPLATES_DIR, target)
+    for path in target.rglob("*"):
+        if not path.is_file():
+            continue
+        if path.suffix not in SUBSTITUTE_EXTENSIONS:
+            continue
+        text = path.read_text(encoding="utf-8")
+        if "{{project_name}}" in text:
+            path.write_text(text.replace("{{project_name}}", project_name), encoding="utf-8")
+    step_done_fn(1, _TOTAL, _STEPS[0])
+
+    # Step 2 — .env
+    step_fn(2, _TOTAL, _STEPS[1])
+    if env_vars:
+        env_file = target / "env"
+        if env_file.exists():
+            text = env_file.read_text(encoding="utf-8")
+            for key, value in env_vars.items():
+                placeholder = ENV_PLACEHOLDERS.get(key)
+                if placeholder and placeholder in text:
+                    text = text.replace(placeholder, value)
+                    text = text.replace(f"# {key}={value}", f"{key}={value}")
+                elif f"# {key}=" in text:
+                    text = re.sub(rf"# {re.escape(key)}=.*", f"{key}={value}", text)
+            env_file.write_text(text, encoding="utf-8")
+    for old_name, new_name in RENAME_MAP.items():
+        src = target / old_name
+        if src.exists():
+            src.rename(target / new_name)
+    step_done_fn(2, _TOTAL, _STEPS[1])
+
+    # Step 3 — git
+    step_fn(3, _TOTAL, _STEPS[2])
+    if init_git:
+        try:
+            subprocess.run(["git", "init", str(target)], capture_output=True, check=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass
+    step_done_fn(3, _TOTAL, _STEPS[2])
+
+    # Step 4 — Claude skill
+    step_fn(4, _TOTAL, _STEPS[3])
+    claude_skills_src = target / "claude_skills"
+    if claude_skills_src.exists():
+        claude_dir = target / ".claude" / "skills"
+        claude_dir.parent.mkdir(parents=True, exist_ok=True)
+        claude_skills_src.rename(claude_dir)
+    step_done_fn(4, _TOTAL, _STEPS[3])
+
+    return 0

create_leafmesh/templates/Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.13-slim AS base
+
+WORKDIR /app
+
+# System dependencies for compiled packages (grpcio, etc.)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends gcc libffi-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY configs/ configs/
+COPY agency/ agency/
+COPY main.py .
+
+EXPOSE 18820
+
+CMD ["python", "main.py"]

create_leafmesh/templates/README.md

@@ -0,0 +1,309 @@
+# {{project_name}}
+
+A LeafMesh multi-agent project with Human-in-the-Loop (HITL), fan-in/fan-out patterns, smart memory, scheduled agents, and more.
+
+## Quick Start
+
+```bash
+# 1. Install dependencies
+python -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt
+
+# 2. Configure environment
+#    Edit .env with your API keys (OPENAI_API_KEY, LEAFMESH_LICENSE_KEY, Redis)
+
+# 3. Start Redis (if not already running)
+docker compose up redis -d
+# Or: redis-server
+
+# 4. Start the mesh
+python main.py
+```
+
+The mesh starts an API server at **http://127.0.0.1:18820**. Visit `/docs` for interactive API docs.
+
+## Project Structure
+
+```
+{{project_name}}/
+  configs/
+    config.yaml              # Agent definitions, mesh wiring, HITL config
+  agency/
+    greeter_agent.py         # LLM agent with @pre_compose
+    processor_agent.py       # Programmatic agent with @conditional_chain
+    researcher_agent.py      # LLM agent with @chain_with_results + smart memory
+    fallback_researcher_agent.py  # Programmatic fast fallback (race pattern)
+    advisor_agent.py         # LLM fan-in agent with @chain + @compose
+    scheduler_agent.py       # Cron-scheduled agent (daily reports)
+    tools.py                 # Custom tools (@global_tool, @tool)
+    external_agents.py       # Integration reference (CrewAI, LangGraph, etc.)
+  main.py                    # Entry point
+  hitl_stub_receiver.py      # Webhook stub for testing HITL locally
+  requirements.txt
+  .env                       # API keys and config
+  Dockerfile
+  docker-compose.yml         # Redis + app (one command)
+```
+
+## Agent Flow
+
+```
+                              HITL Scenario 1 (system-initiated)
+                              ===================================
+  API request                 greeter_agent (LLM)
+  "greet_user"  ─────────>       |
+                                 v
+                              client (human agent, HITL)
+                              [outbound webhook → human reviews → inbound webhook]
+                                 |
+                                 v
+                              processor_agent (programmatic, parallel)
+                              ┌──┼──┐
+                              v  v  v
+                    researcher  fallback  advisor (waits)
+                    (LLM)      (instant)     |
+                              └──────────────┘
+                              advisor_agent (OR fan-in)
+                              [processor AND (researcher OR fallback)]
+
+
+                              HITL Scenario 2 (human-initiated)
+                              ==================================
+  Webhook                     client (human agent)
+  "human_contact"  ──────>       |  (no from_agent → route to greeter)
+                                 v
+                              greeter_agent (LLM)
+                                 |  (dual callback → client)
+                                 v
+                              client (HITL, from_agent = "greeter_agent")
+                              [outbound webhook → human reviews → inbound webhook]
+                                 |  (from_agent == "greeter_agent" → route to processor)
+                                 v
+                              processor_agent → researcher + fallback → advisor
+```
+
+## HITL Walkthrough
+
+### Prerequisites
+
+You need **3 terminals** open:
+
+| Terminal | Purpose |
+|----------|---------|
+| Terminal 1 | HITL stub receiver (captures outbound webhooks) |
+| Terminal 2 | LeafMesh server |
+| Terminal 3 | curl commands (trigger mesh + respond as human) |
+
+### Step 1: Start the Stub Receiver
+
+```bash
+# Terminal 1
+python hitl_stub_receiver.py
+```
+
+This listens on port 9999 and prints outbound webhook payloads when the human agent is invoked.
+
+### Step 2: Start the Mesh
+
+```bash
+# Terminal 2
+python main.py
+```
+
+Wait for "{{project_name}} is running" in the logs.
+
+### Step 3: Get Your Webhook Signing Secret
+
+```bash
+# Terminal 3
+curl http://127.0.0.1:18820/api/webhook/secret
+```
+
+Save the `secret` value — you'll need it to sign inbound webhook responses.
+
+### Scenario 1: System-Initiated HITL
+
+The system triggers a workflow, and the human agent is called mid-flow for review.
+
+**Trigger the mesh:**
+
+```bash
+# Terminal 3
+curl -X POST http://127.0.0.1:18820/api/mesh/request \
+  -H "Content-Type: application/json" \
+  -d '{"entry_point": "greet_user", "data": {"message": "I need help with item1, item2, item3"}}'
+```
+
+**What happens:**
+1. `greeter_agent` processes the message via LLM
+2. `greeter_agent` routes to `client` (human agent)
+3. SDK sends outbound webhook to the stub receiver (Terminal 1)
+4. The stub prints a curl command to respond
+
+**Respond as the human** (compute HMAC + timestamp + nonce — required by the SDK):
+
+```bash
+# Terminal 3 — sign and respond
+# Replace SESSION_ID with the session_id from the stub output
+# Replace SECRET with the value from /api/webhook/secret
+
+BODY='{"session_id": "SESSION_ID", "decision": "approved", "message": "Looks good, proceed with item1, item2, item3"}'
+SECRET="your-secret-here"
+TS=$(date +%s)
+NONCE=$(python3 -c 'import secrets; print(secrets.token_urlsafe(16))')
+
+# Signed material: "{timestamp}.{nonce}.{body}"
+SIG=$(printf '%s' "$TS.$NONCE.$BODY" | openssl dgst -sha256 -hmac "$SECRET" -hex | awk '{print $NF}')
+
+curl -X POST http://127.0.0.1:18820/webhook/greet_user \
+  -H "Content-Type: application/json" \
+  -H "X-LeafMesh-Signature: sha256=$SIG" \
+  -H "X-LeafMesh-Timestamp: $TS" \
+  -H "X-LeafMesh-Nonce: $NONCE" \
+  -d "$BODY"
+```
+
+**Result:** The human's response flows through `processor_agent` → `researcher_agent` + `fallback_researcher_agent` → `advisor_agent`.
+
+### Scenario 2: Human-Initiated HITL
+
+The human initiates contact, the system processes it, and the human reviews before final processing.
+
+**Trigger via webhook:**
+
+```bash
+# Terminal 3
+BODY='{"message": "I want to report an issue with item1, item2"}'
+SECRET="your-secret-here"
+TS=$(date +%s)
+NONCE=$(python3 -c 'import secrets; print(secrets.token_urlsafe(16))')
+SIG=$(printf '%s' "$TS.$NONCE.$BODY" | openssl dgst -sha256 -hmac "$SECRET" -hex | awk '{print $NF}')
+
+curl -X POST http://127.0.0.1:18820/webhook/human_contact \
+  -H "Content-Type: application/json" \
+  -H "X-LeafMesh-Signature: sha256=$SIG" \
+  -H "X-LeafMesh-Timestamp: $TS" \
+  -H "X-LeafMesh-Nonce: $NONCE" \
+  -d "$BODY"
+```
+
+**What happens:**
+1. `client` receives the message (no `from_agent` → routes to `greeter_agent`)
+2. `greeter_agent` processes via LLM and responds back to `client`
+3. SDK sends outbound webhook to the stub receiver (Terminal 1)
+4. The stub prints a curl command to respond
+
+**Respond as the human** (same pattern as Scenario 1 — use the session_id from the stub output).
+
+**Result:** `from_agent == "greeter_agent"` → routes to `processor_agent` → full chain completes.
+
+### How `from_agent` Routing Works
+
+The `client` agent's `can_call` uses conditions to determine where to route:
+
+```yaml
+can_call:
+  - agent: "greeter_agent"
+    condition: "not calling_agent_response.from_agent"    # No caller → greet first
+  - agent: "processor_agent"
+    condition: "calling_agent_response.from_agent == 'greeter_agent'"  # Greeter done → process
+```
+
+When an agent calls the human agent, the SDK stores which agent called (`called_by`) in Redis. When the human responds via webhook, the SDK includes `from_agent` in the output data so `can_call` conditions can route accordingly.
+
+## Key Concepts
+
+### Agent Types
+
+| Type | Description | Example |
+|------|-------------|---------|
+| `human` | Human-in-the-loop via webhook/channel | `client` |
+| `llm` | LLM-powered with prompt + tools | `greeter_agent`, `researcher_agent` |
+| `programmatic` | Pure Python logic, no LLM | `processor_agent`, `scheduler_agent` |
+| `external` | Delegates to CrewAI, LangGraph, etc. | See `external_agents.py` |
+
+### Decorators
+
+| Decorator | Purpose | Example Agent |
+|-----------|---------|---------------|
+| `@pre_compose(fn1, fn2, ...)` | Pre-process input before LLM call | `greeter_agent` |
+| `@chain(fn1, fn2, ...)` | Sequential post-processing pipeline | `advisor_agent` |
+| `@chain_with_results(fn1, fn2)` | Accumulate results across steps | `researcher_agent` |
+| `@conditional_chain(cond, true_fn, false_fn)` | Branch based on condition | `processor_agent` |
+| `@compose(key=fn, ...)` | Inject shaped data per downstream agent | `advisor_agent` |
+
+### Fan-In Patterns (`wait_for`)
+
+```yaml
+wait_for: "A AND B"                    # Wait for both
+wait_for: "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
+```
+
+### Smart Memory
+
+```yaml
+memory:
+  strategy: "hybrid"          # recency | relevance | hybrid
+  limit: 10                   # Max entries per invocation
+  cross_session: true         # Persist across sessions
+  relevance_weight: 0.6
+  recency_weight: 0.4
+```
+
+### Upstream Yields
+
+Agents define `yields` in YAML. The SDK auto-stores them in Redis and injects them into downstream agents as `input_data["upstream_yields"][agent_name]`.
+
+### Scheduled Agents
+
+```yaml
+scheduler_agent:
+  wake_up: "0 9 * * *"       # Cron expression (9 AM UTC daily)
+```
+
+Also triggerable on-demand via `mesh_call("scheduled_report", data)`.
+
+## API Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/mesh/request` | Trigger agent workflows via entry points |
+| POST | `/api/mesh/stream` | SSE stream of LLM response |
+| POST | `/webhook/{entry_point}` | Webhook (new task or human HITL response) |
+| GET | `/api/mesh/entry_points` | List configured entry points |
+| GET | `/api/agents/` | List all agents |
+| GET | `/api/sessions/` | List active sessions |
+| GET | `/api/sessions/{id}/history` | Conversation history |
+| GET | `/api/webhook/secret` | HMAC signing secret |
+| GET | `/health` | Health check |
+| GET | `/docs` | Interactive API docs (ReDoc) |
+
+## Docker
+
+```bash
+# Start Redis + app
+docker compose up --build
+
+# Or just Redis (run app locally)
+docker compose up redis -d
+```
+
+## Configuration
+
+All agent wiring is in `configs/config.yaml`. Key sections:
+
+- **`entry_points`** — Named portals into the mesh
+- **`agents`** — Agent definitions (type, model, can_call, yields, etc.)
+- **`manager`** — Built-in coordinator with learning-based routing and escalation
+- **`mesh`** — Timeout and cloud LLM provider configs
+
+## Observability
+
+Observability auto-enables when `LEAFMESH_LICENSE_KEY` is set in `.env`. Traces, metrics, and logs flow automatically. Set `LEAFMESH_ENV_TOKEN` to group telemetry by environment.
+
+## Links
+
+- [LeafMesh SDK](https://pypi.org/project/leafmesh/)
+- [LeafCraft Studios](https://leafcraft.ai)