agentlings 0.2.0__tar.gz

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/.env.example

@@ -0,0 +1,14 @@
+ANTHROPIC_API_KEY=sk-ant-...
+AGENT_API_KEY=your-agent-api-key
+
+# Path to agent definition YAML (name, description, tools, skills, system prompt)
+# AGENT_CONFIG=./agent.yaml
+
+# AGENT_MODEL=claude-sonnet-4-6
+# AGENT_MAX_TOKENS=4096
+# AGENT_HOST=0.0.0.0
+# AGENT_PORT=8420
+# AGENT_DATA_DIR=./data
+# AGENT_LOG_LEVEL=INFO
+# AGENT_LLM_BACKEND=anthropic
+# AGENT_EXTERNAL_URL=

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/.git

@@ -0,0 +1 @@
+gitdir: /Users/andrewmorgan/Personal/source/DonkeyWork-Agentlings/.git/worktrees/agent-ac15d433

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Unit tests
+        run: pytest tests/unit/ -v
+
+      - name: Integration tests (in-process)
+        run: pytest tests/integration/ -v
+
+  docker-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build and run agentling container
+        run: docker compose -f docker-compose.test.yml up --build --abort-on-container-exit --exit-code-from test-runner

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/.gitignore

@@ -0,0 +1,12 @@
+data/
+.env
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.pytest_cache/
+.venv/
+venv/

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/CLAUDE.md

@@ -0,0 +1,128 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project
+
+Agentlings — a lightweight single-process Python framework for running AI agents that expose both A2A (Agent-to-Agent Protocol v1.0) and MCP (Model Context Protocol) on a single HTTP port. Each agentling is a small, focused agent whose identity is defined by configuration (name, description, system prompt, tools), not code.
+
+## Architecture
+
+Two protocol interfaces (A2A JSON-RPC at `/a2a`, MCP Streamable HTTP at `/mcp`) feed into a shared **task engine**. Every request becomes a task with its own sub-journal; the HTTP handler awaits up to `AGENT_TASK_AWAIT_SECONDS` (default 60) and either returns the final result inline (fast path) or yields a task handle the caller polls (slow path). FIFO ordering is preserved per context — only one task can run per context at a time, so concurrent requests are rejected with `context_busy` for the LLM to retry.
+
+Data layout:
+
+- Parent journal: `{data_dir}/{contextId}/journal.jsonl` (conversation history)
+- Sub-journal:    `{data_dir}/{contextId}/tasks/{taskId}.jsonl` (task execution trace)
+- Legacy `{data_dir}/{contextId}.jsonl` files are auto-migrated on first access.
+
+Package structure under `src/agentlings/`:
+- `config.py` — Pydantic BaseSettings, all config via env vars + `.env`
+- `log.py` — console-first logging setup
+- `server.py` — Starlette app wiring A2A + MCP routes, API key middleware, startup crash-recovery
+- `core/` — task engine
+  - `task.py` — `TaskEngine`, `TaskRegistry`, `TaskWorker`, merge-back, crash recovery
+  - `loop.py` — synchronous facade over `TaskEngine` for legacy callers
+  - `llm.py` — LLM client abstraction (Anthropic + mock backends)
+  - `store.py` — JSONL append/replay with compaction cursor + `TaskJournal` (sub-journal)
+  - `models.py` — journal entry types (messages, compaction, task markers, merge wrappers)
+  - `prompt.py` — system prompt builder
+  - `completion.py` — shared LLM completion cycle with per-turn callback + cancellation
+- `protocol/` — protocol adapters
+  - `a2a.py` — `AgentlingExecutor` bridging A2A SDK to the task engine
+  - `mcp.py` — MCP server exposing a single task-aware tool
+  - `agent_card.py` — Agent Card generation from config
+- `tools/` — pluggable tool system
+  - `registry.py` — `ToolRegistry` with group-based registration
+  - `builtins.py` — bash and filesystem tool implementations
+
+The Agent Card at `/.well-known/agent.json` is the single source of truth — the MCP tool schema is derived from it.
+
+### Task engine lifecycle
+
+1. **Ingress**: `engine.spawn(message, contextId?)` atomically admits one task per context, writes a `TaskDispatched` audit marker to the parent journal, creates a sub-journal with `TaskStarted`, and spawns a worker.
+2. **Execution**: the worker snapshots the parent journal (replay from latest compaction cursor), runs the LLM loop via `compact_20260112`, writes each turn to the sub-journal.
+3. **Merge-back (success)**: under the per-context lock, the engine atomically writes `MergeStarted` → user message → latest sub-journal compaction (if any) → assistant final response → `MergeCommitted` to the parent journal.
+4. **Cancel/fail**: only a `TaskCancelled` or `TaskFailed` audit marker lands on the parent. No conversational content leaks.
+5. **Replay**: audit markers (`task_dispatch`, `task_cancel`, `task_fail`, `merge_start`, `merge_commit`) are stripped by the store's `replay()` — they never reach the LLM.
+6. **Crash recovery**: on startup, orphaned sub-journals get `TaskFailed { reason: "process_crash_recovery" }` and partial merge-backs are completed idempotently.
+
+## Commands
+
+```bash
+# Install in dev mode
+pip install -e ".[dev]"
+
+# Run the agent
+agentling
+
+# Run with overrides
+AGENT_NAME="my-agent" AGENT_PORT=9000 agentling
+
+# Build container
+docker build -t agentling:latest .
+
+# Run container
+docker run -e ANTHROPIC_API_KEY=... -e AGENT_API_KEY=... -v ./data:/data -p 8420:8420 agentling:latest
+```
+
+## Configuration
+
+All via environment variables (loaded from `.env` via python-dotenv):
+- `ANTHROPIC_API_KEY` (required)
+- `AGENT_API_KEY` (required) — checked via `X-API-Key` header
+- `AGENT_MODEL` (default `claude-sonnet-4-6`)
+- `AGENT_MAX_TOKENS` (default `4096`)
+- `AGENT_HOST` / `AGENT_PORT` (default `0.0.0.0:8420`)
+- `AGENT_DATA_DIR` (default `./data`) — JSONL journal storage
+- `AGENT_NAME` / `AGENT_DESCRIPTION` — identity for Agent Card + MCP tool
+- `AGENT_SYSTEM_PROMPT_FILE` — optional path to override default system prompt
+- `AGENT_LOG_LEVEL` (default `INFO`)
+- `AGENT_TASK_AWAIT_SECONDS` (default `60`) — HTTP handler await timeout before yielding a task handle to the caller
+
+## Logging
+
+Console-only, format: `datetime - level - path - message`. All modules use `logging.getLogger(__name__)`. No third-party logging libraries.
+
+## Design Constraints
+
+- **Task-enabled, message-shape.** Every request becomes a task with its own sub-journal. Protocol surfaces expose task handles for long-running work, but A2A/MCP interactions are still carried as messages — no artifacts, no push notifications, no streaming.
+- **One task per context.** FIFO is architectural, not configurable. Concurrent requests to a busy context are rejected with `context_busy`; the LLM retries.
+- **Parent journal records only successful completions.** Cancel/fail leave only audit markers, never conversational content. Replay strips audit markers unconditionally.
+- **contextId is the conversation handle; taskId is the execution handle.** ContextId maps to a directory; taskId is UUID4 and path-bound via `{contextId}/tasks/{taskId}.jsonl` — the filesystem enforces `(contextId, taskId)` pairing.
+- **Confirmation is conversation** — no `input-required` state, just natural language turns.
+- **The LLM is the agent** — the framework records and replays, it does not orchestrate.
+- **Tools are pluggable** — register at startup, errors returned to LLM as tool results (not exceptions).
+- **JSONL is append-only**, never modified or deleted; compaction markers are replay cursors, task compactions are ported to parent on merge-back.
+- **Merge-back is atomic** via `MergeStarted`/`MergeCommitted` wrappers so startup recovery can repair partial writes idempotently.
+- **MCP Session ID and contextId are independent concepts**, never cross-referenced.
+
+## Development Methodology
+
+**Write → Test → Continue.** Every piece of code gets tested before moving on.
+
+- Bug workflow: write a failing test that reproduces the bug → verify it fails → fix the code → verify the test passes. No exceptions.
+- Each task ends with tests that prove the task works.
+- Each milestone ends with rigorous integration testing.
+- Tests run in Docker via `docker compose` — the test harness spins up the agentling container and runs an MCP client and A2A client against it.
+- Unit tests (pytest) for internal modules; integration tests for protocol-level behaviour.
+- All LLM responses are mocked — tests never call the real Anthropic API or require a real key. The agentling container in integration tests runs with a mock LLM backend.
+
+```bash
+# Run unit tests
+pytest tests/unit/
+
+# Run integration tests (builds + runs container)
+docker compose -f docker-compose.test.yml up --build --abort-on-container-exit
+
+# Run all tests
+pytest tests/unit/ && docker compose -f docker-compose.test.yml up --build --abort-on-container-exit
+```
+
+## Dependencies
+
+- `anthropic` — LLM backend with `compact_20260112`
+- `starlette` + `uvicorn` — HTTP server
+- `pydantic` — config and models
+- `mcp` — MCP SDK (Streamable HTTP)
+- `python-dotenv` — env file loading

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.12-slim
+
+COPY . /app
+WORKDIR /app
+RUN pip install --no-cache-dir .
+
+VOLUME /data
+ENV AGENT_DATA_DIR=/data
+EXPOSE 8420
+
+ENTRYPOINT ["agentling"]

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/README.md

@@ -0,0 +1,367 @@
+<p align="center">
+  <img src="logo.png" alt="Agentlings" width="256">
+</p>
+
+<h1 align="center">Agentlings</h1>
+
+<p align="center">
+  Lightweight single-process agent framework exposing both
+  <a href="https://a2a-protocol.org">A2A</a> and
+  <a href="https://modelcontextprotocol.io">MCP</a> on a single HTTP port.
+</p>
+
+---
+
+Each agentling is a small, focused AI agent whose identity is defined by a YAML config file — name, description, system prompt, tools, and skills. The framework handles protocol compliance, conversation journaling, and context management. The LLM is the agent; the framework records and replays.
+
+## Quick start
+
+```bash
+pip install -e ".[dev]"
+
+# Create your agent definition
+cp agent.example.yaml agent.yaml
+
+# Run with mock LLM (no API key needed)
+AGENT_CONFIG=./agent.yaml AGENT_LLM_BACKEND=mock AGENT_API_KEY=dev agentling
+
+# Run with Anthropic
+AGENT_CONFIG=./agent.yaml ANTHROPIC_API_KEY=sk-ant-... AGENT_API_KEY=your-key agentling
+
+# See available tools
+agentling --list-tools
+```
+
+The agent serves:
+- `GET /.well-known/agent-card.json` — A2A Agent Card (public, no auth)
+- `POST /a2a` — A2A JSON-RPC endpoint
+- `POST /mcp` — MCP Streamable HTTP endpoint
+
+## Running as a daemon
+
+### systemd (Linux)
+
+Create `/etc/systemd/system/agentling.service`:
+
+```ini
+[Unit]
+Description=Agentling
+After=network.target
+
+[Service]
+Type=simple
+User=agentling
+WorkingDirectory=/opt/agentling
+EnvironmentFile=/opt/agentling/.env
+ExecStart=/opt/agentling/venv/bin/agentling
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+```
+
+```bash
+# Set up
+sudo useradd -r -s /bin/false agentling
+sudo mkdir -p /opt/agentling
+sudo python3 -m venv /opt/agentling/venv
+sudo /opt/agentling/venv/bin/pip install agentlings
+
+# Copy your config
+sudo cp agent.yaml /opt/agentling/agent.yaml
+sudo cp .env /opt/agentling/.env    # ANTHROPIC_API_KEY, AGENT_API_KEY, AGENT_CONFIG=./agent.yaml
+
+# Start
+sudo systemctl daemon-reload
+sudo systemctl enable --now agentling
+sudo journalctl -u agentling -f
+```
+
+### launchd (macOS)
+
+Create `~/Library/LaunchAgents/com.donkeywork.agentling.plist`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.donkeywork.agentling</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/path/to/venv/bin/agentling</string>
+    </array>
+    <key>WorkingDirectory</key>
+    <string>/path/to/agentling</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>AGENT_CONFIG</key>
+        <string>./agent.yaml</string>
+        <key>ANTHROPIC_API_KEY</key>
+        <string>sk-ant-...</string>
+        <key>AGENT_API_KEY</key>
+        <string>your-key</string>
+    </dict>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardErrorPath</key>
+    <string>/tmp/agentling.err</string>
+</dict>
+</plist>
+```
+
+```bash
+launchctl load ~/Library/LaunchAgents/com.donkeywork.agentling.plist
+tail -f /tmp/agentling.err
+```
+
+## Agent definition
+
+Agent identity lives in a YAML file (`agent.yaml`):
+
+```yaml
+name: k3s-agentling
+description: A k3s cluster management agent
+
+tools:
+  - bash
+  - filesystem
+
+skills:
+  - id: k8s-ops
+    name: Kubernetes Operations
+    description: Manage cluster resources, diagnose issues, apply manifests
+    tags: [kubernetes, k3s, devops]
+  - id: file-management
+    name: File Management
+    description: Read, write, and search configuration files
+    tags: [files, yaml]
+
+system_prompt: |
+  You are a DevOps engineer managing a k3s Kubernetes cluster.
+
+  All configuration changes go through /mnt/lab/k3s as the source of truth.
+  Never use kubectl patch/edit/set directly — write manifests and apply them.
+
+  Before any destructive operation, describe the impact and ask for confirmation.
+```
+
+Point to it with `AGENT_CONFIG=./agent.yaml`.
+
+### Available tools
+
+| Group | Tools | Description |
+|-------|-------|-------------|
+| `bash` | `bash` | Shell command execution with timeout |
+| `filesystem` | `read_file`, `write_file`, `edit_file`, `list_directory`, `search_files` | File operations with offset/limit, find-and-replace, glob search |
+| `memory` | `memory_edit` | Read and write the agent's persistent long-term memory |
+
+Tools are off by default. Run `agentling --list-tools` for details.
+
+## Docker
+
+```bash
+docker build -t agentling:latest .
+docker run -e AGENT_API_KEY=your-key -e AGENT_LLM_BACKEND=mock -p 8420:8420 agentling
+```
+
+## Environment variables
+
+Secrets and runtime settings stay in env vars (or `.env` file):
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `AGENT_CONFIG` | — | Path to agent YAML definition |
+| `ANTHROPIC_API_KEY` | — | Anthropic API key (required for real LLM) |
+| `AGENT_API_KEY` | — | API key for authenticating clients |
+| `AGENT_MODEL` | `claude-sonnet-4-6` | Anthropic model ID |
+| `AGENT_MAX_TOKENS` | `4096` | Max tokens per LLM response |
+| `AGENT_HOST` | `0.0.0.0` | Bind address |
+| `AGENT_PORT` | `8420` | Bind port |
+| `AGENT_DATA_DIR` | `./data` | JSONL journal storage directory |
+| `AGENT_LOG_LEVEL` | `INFO` | Log level |
+| `AGENT_LLM_BACKEND` | `anthropic` | `anthropic` or `mock` |
+| `AGENT_EXTERNAL_URL` | — | Public URL for Agent Card (needed in Docker/k8s) |
+| `AGENT_OTEL_ENDPOINT` | — | OpenTelemetry collector endpoint |
+| `AGENT_OTEL_PROTOCOL` | `http` | Collector protocol (`http` or `grpc`) |
+| `AGENT_OTEL_INSECURE` | `true` | Disable TLS for collector connection |
+| `AGENT_OTEL_HEADERS` | — | Comma-separated `key=value` pairs for collector auth |
+
+## Memory
+
+Agentlings can maintain persistent long-term memory — a curated set of key-value facts that survive across conversations. Memory transforms an agent from a tool that forgets into one that learns.
+
+### How it works
+
+Memory is a JSON file (`data/memory/memory.json`) containing entries like:
+
+```json
+{
+  "entries": [
+    {
+      "key": "cluster-node-count",
+      "value": "4 nodes: node1 (control), node2-4 (workers)",
+      "recorded": "2026-04-01T10:00:00Z"
+    }
+  ]
+}
+```
+
+The memory block is injected into the system prompt on every LLM call, between the agent's identity and the conversation history. The agent sees its accumulated knowledge as working context, not as a separate tool call.
+
+### The memory tool
+
+When the `memory` tool group is enabled, the agent gets a `memory_edit` tool with three operations:
+
+| Operation | Description |
+|-----------|-------------|
+| `set` | Upsert an entry by key. Updates the timestamp. |
+| `remove` | Delete an entry by key. |
+| `list` | Return all current entries. |
+
+The agent decides what to remember based on its system prompt. A DevOps agent might store cluster topology and known issues. A support agent might store escalation paths and recurring problems.
+
+### CLI
+
+```bash
+# Show current memory
+agentling memory show
+```
+
+### Configuration
+
+```yaml
+memory:
+  token_budget: 2000        # max tokens for the memory block in the system prompt
+  # injection_prompt: null   # override the memory/data-dir-awareness template
+```
+
+## Sleep cycle
+
+<p align="center">
+  <img src="sleep.png" alt="Sleep Cycle" width="256">
+</p>
+
+The sleep cycle is a nightly process that journals the day's activity, consolidates new knowledge into memory, prunes stale entries, and cleans up old files. It maps to biological sleep phases.
+
+```mermaid
+graph LR
+    L[Light Sleep<br/>Gate check] --> D[Deep Sleep<br/>Replay & journal]
+    D --> R[REM<br/>Integrate & prune]
+    R --> H[Housekeeping<br/>Retention cleanup]
+```
+
+### Phase 1: Light sleep — gate check
+
+Quick check: were there any conversations today? If not, skip everything. No LLM calls, no cost.
+
+### Phase 2: Deep sleep — replay and file
+
+For each conversation from today, the sleep cycle reads the JSONL journal from the last compaction marker and submits all summaries as a single **batch request** to the Anthropic Message Batches API. Batch processing runs at 50% cost and processes in parallel.
+
+Each summary call receives the agent's system prompt (so the agent's persona shapes what it considers important), current memory, and the conversation content. The LLM returns a structured `ConversationSummary` with a narrative and memory candidates.
+
+Results are written to `data/journals/YYYY-MM-DD.md`.
+
+### Phase 3: REM — integrate and prune
+
+A single LLM call receives current memory, today's journal, and all extracted memory candidates. It integrates new facts, deduplicates, reviews existing entries for staleness, and returns a `ConsolidatedMemory` — the complete updated memory store. Written atomically to `memory.json`.
+
+### Phase 4: Housekeeping — retention cleanup
+
+Deletes conversation JSONL files older than `conversation_retention_days` and journal files older than `journal_retention_days`.
+
+### Configuration
+
+```yaml
+sleep:
+  schedule: "0 2 * * *"           # cron expression (default: 2am daily)
+  journal_retention_days: 30       # keep journals for 30 days
+  conversation_retention_days: 14  # keep JSONL conversations for 14 days
+  memory_max_entries: 50           # hard cap after consolidation
+  # model: null                    # override model for sleep calls
+  # summary_prompt: null           # override per-conversation summary prompt
+  # consolidation_prompt: null     # override REM consolidation prompt
+```
+
+### CLI
+
+```bash
+# Trigger sleep cycle manually
+agentling sleep --date 2026-04-01
+```
+
+### Data directory layout
+
+```
+data/
+  abc123.jsonl           # conversation journals (flat, as before)
+  def456.jsonl
+  memory/
+    memory.json          # persistent memory store
+  journals/
+    2026-04-01.md        # daily sleep journal
+    2026-04-02.md
+```
+
+The agent is told about this directory structure and can use its filesystem tools to search past journals and conversation logs for context beyond what fits in memory.
+
+## OpenTelemetry
+
+The sleep cycle and memory tool emit spans and metrics to an OpenTelemetry collector when telemetry is enabled.
+
+```yaml
+telemetry:
+  enabled: true
+  endpoint: "http://otel-collector:4318"
+  protocol: "http"                        # "http" or "grpc"
+  service_name: "agentling"
+  insecure: true
+  headers:                                # optional auth headers
+    Authorization: "Bearer your-token"
+```
+
+Or via env vars: `AGENT_OTEL_ENDPOINT=http://collector:4318 AGENT_OTEL_HEADERS="Authorization=Bearer tok"`.
+
+
+When telemetry is disabled (the default) or the OpenTelemetry packages are not installed, all instrumentation is a no-op.
+
+## Architecture
+
+```mermaid
+graph TB
+    A2A[A2A Client] -->|POST /a2a| A2ASDK[a2a-sdk Server]
+    MCP[MCP Client] -->|POST /mcp| MCPSDK[mcp SDK Server]
+    A2ASDK --> Executor[AgentlingExecutor]
+    Executor --> Loop[MessageLoop]
+    MCPSDK --> Loop
+    Loop --> Store[JSONL Store]
+    Loop --> LLM[LLM Client]
+    Loop --> Tools[Tool Registry]
+```
+
+Both protocols feed into a single `MessageLoop.process_message()` entrance. Conversations are persisted as append-only JSONL journals with compaction markers as replay cursors.
+
+## Testing
+
+```bash
+# Unit tests (no network, no LLM)
+pytest tests/unit/ -v
+
+# Integration tests (starts real server with mock LLM)
+pytest tests/integration/ -v
+
+# All tests
+pytest tests/ -v
+```
+
+Integration tests use native SDK clients — `a2a-sdk` `ClientFactory` for A2A and `mcp` `ClientSession` for MCP — talking to a real server over HTTP. All LLM responses are mocked.
+
+## Built with
+
+- [a2a-sdk](https://github.com/a2aproject/a2a-python) — A2A protocol server + client
+- [mcp](https://github.com/modelcontextprotocol/python-sdk) — MCP protocol server + client
+- [anthropic](https://github.com/anthropics/anthropic-sdk-python) — LLM backend
+- [starlette](https://www.starlette.io) + [uvicorn](https://www.uvicorn.org) — HTTP server

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/agent.example.yaml

@@ -0,0 +1,41 @@
+name: my-agentling
+description: A helpful AI assistant
+
+tools:
+  - bash
+  - filesystem
+  - memory
+
+skills:
+  - id: general
+    name: General Assistant
+    description: Answer questions and help with tasks
+    tags: [general, assistant]
+
+system_prompt: |
+  You are a helpful AI assistant.
+
+  Use the tools available to you to accomplish tasks. When a tool returns output,
+  incorporate it into your response.
+
+  Be concise. Use code blocks for command output.
+
+memory:
+  token_budget: 2000
+  # injection_prompt: null  # override the memory injection template
+
+sleep:
+  schedule: "0 2 * * *"
+  journal_retention_days: 30
+  conversation_retention_days: 14
+  memory_max_entries: 50
+  # model: null             # override model for sleep LLM calls
+  # summary_prompt: null    # override per-conversation summary prompt
+  # consolidation_prompt: null  # override REM consolidation prompt
+
+telemetry:
+  enabled: false
+  endpoint: "http://localhost:4318"
+  protocol: "http"
+  service_name: "agentling"
+  insecure: true

agentlings-0.2.0/.claude/worktrees/agent-ac15d433/docker-compose.test.yml

@@ -0,0 +1,27 @@
+services:
+  agentling:
+    build: .
+    environment:
+      - AGENT_API_KEY=test-key
+      - AGENT_LLM_BACKEND=mock
+      - AGENT_EXTERNAL_URL=http://agentling:8420
+      - AGENT_CONFIG=/app/tests/agent.test.yaml
+      - AGENT_LOG_LEVEL=WARNING
+    ports:
+      - "8420:8420"
+    healthcheck:
+      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8420/.well-known/agent-card.json')"]
+      interval: 2s
+      timeout: 5s
+      retries: 15
+
+  test-runner:
+    build:
+      context: .
+      dockerfile: tests/Dockerfile
+    depends_on:
+      agentling:
+        condition: service_healthy
+    environment:
+      - AGENT_URL=http://agentling:8420
+      - AGENT_API_KEY=test-key