@luckydraw/cumulus 0.30.29 → 0.30.30

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## v0.30.29
+- Attach files of any type to messages, with upload progress shown
+- Stricter MCP config validation catches setup errors earlier
+- Cleaner responses with literal `<thinking>` tags suppressed
+- Updated documentation reflecting current features
+
+
 ## v0.30.29
 
 - Attach files of any type to messages, with live upload progress

package/README.md

@@ -2,15 +2,14 @@
 
 A self-hosted multi-channel AI gateway built around Claude and other LLMs. Runs as a long-lived daemon, speaks to you through a web chat widget, Slack, Discord, iOS push, email webhooks, and more — with unlimited conversation context via the **Recursive Language Model (RLM)** pattern.
 
-Originally a CLI wrapper for Claude, Cumulus has grown into a full gateway platform that coordinates agents, channels, models, and federated deployments.
+Originally a CLI wrapper for Claude, Cumulus has grown into a full gateway platform that coordinates agents, channels, and models behind one persistent process.
 
 ## What you get
 
 - **Gateway daemon** (`cumulus-gateway`) — HTTP + WebSocket server with per-thread conversations, streaming responses, and an admin API.
-- **Web chat widget** — embeddable `/chat` interface with voice mode, push notifications, media uploads, and rich [blex block](https://www.npmjs.com/package/@luckydraw/blex) rendering (tables, forms, charts, kanban, diagrams).
+- **Web chat widget** — embeddable `/chat` interface with voice mode, push notifications, file uploads with progress, and rich [blex block](https://www.npmjs.com/package/@luckydraw/blex) rendering (tables, forms, charts, kanban, diagrams).
 - **Channel adapters** — Slack and Discord bots, inbound email webhooks (Resend), and generic HTTP webhooks — all injecting into the same thread model.
 - **Inter-agent messaging** — threads can talk to each other via `send_to_agent`, with support for CC/BCC visibility.
-- **Federation** — hub-and-spoke mesh so agents on different machines can message each other across NATs.
 - **Per-thread model selection** — Claude (via CLI) or any HuggingFace model (GLM-5, Kimi-K2.5, Qwen3, etc.) with tool calling.
 - **Scheduled triggers, email, push, media serving** — built-in MCP tools so agents can send emails, schedule themselves, notify you, and upload files.
 - **Unlimited history** — JSONL per thread + vector store + adaptive context budget. Conversations never truncate.
@@ -32,19 +31,19 @@ Originally a CLI wrapper for Claude, Cumulus has grown into a full gateway platf
 │              │  (HTTP / WS daemon)  │                        │
 │              └──────────┬───────────┘                        │
 │                         │                                    │
-│     ┌───────────────────┼──────────────────────┐             │
-│     ▼                   ▼                      ▼             │
-│ ┌─────────┐      ┌──────────────┐      ┌───────────────┐     │
-│ │ Thread  │      │ Model router │      │  Federation   │     │
-│ │ store   │      │ Claude / HF  │      │  hub/spoke    │     │
-│ │ (JSONL) │      │ MCP tools    │      │  (WSS mesh)   │     │
-│ └────┬────┘      └──────┬───────┘      └───────────────┘     │
-│      │                  │                                    │
-│      ▼                  ▼                                    │
-│  ~/.cumulus/       Claude CLI                                │
-│  threads/          HuggingFace API                           │
-│  content/          MCP stdio + in-process                    │
-│  media/                                                      │
+│           ┌─────────────┴─────────────┐                      │
+│           ▼                           ▼                      │
+│      ┌─────────┐              ┌──────────────┐               │
+│      │ Thread  │              │ Model router │               │
+│      │ store   │              │ Claude / HF  │               │
+│      │ (JSONL) │              │ MCP tools    │               │
+│      └────┬────┘              └──────┬───────┘               │
+│           │                          │                       │
+│           ▼                          ▼                       │
+│       ~/.cumulus/                Claude CLI                  │
+│       threads/                   HuggingFace API             │
+│       content/                   MCP stdio + in-process      │
+│       media/                                                 │
 └──────────────────────────────────────────────────────────────┘
 ```
 
@@ -108,12 +107,6 @@ Open `http://localhost:8080/chat`, paste the API key, and start talking. Message
   },
   "resend": { "apiKey": "re_…", "defaultFrom": "you@example.com" },
   "vapid": { "publicKey": "…", "privateKey": "…", "subject": "mailto:you@example.com" },
-  "federation": {
-    "enabled": true,
-    "role": "hub", // "hub" or "spoke"
-    "allowedSpokes": ["mac-karl"], // hub only
-    // spoke config: { role:"spoke", hub:"wss://host/federation", apiKey:"…", name:"mac-…" }
-  },
 }
 ```
 
@@ -131,7 +124,7 @@ curl -X PUT http://localhost:8080/api/thread/my-thread/config \
   -d '{"model": "zai-org/GLM-5"}'
 ```
 
-- `claude` — spawns `claude --print` per turn. Gets the full Claude Code tool surface.
+- `claude` — spawns `claude --print` per turn. Gets the full Claude Code tool surface. Per-thread `effort` selector (`low` → `max`) maps to the CLI's `--effort` flag.
 - HuggingFace models — routed through an OpenAI-compatible endpoint with a built-in agentic loop that handles tool use, truncation recovery, and error retry.
 
 ### Web chat widget
@@ -139,12 +132,17 @@ curl -X PUT http://localhost:8080/api/thread/my-thread/config \
 At `/chat`. Features:
 
 - **Streaming** responses over WebSocket, with interjection support (type while streaming to interrupt and redirect).
-- **[Blex blocks](https://www.npmjs.com/package/@luckydraw/blex)** — `~~~blex:table`, `~~~blex:poll`, `~~~blex:kanban`, `~~~blex:mermaid`, and 18 other block types for rich interactive content.
-- **Voice mode** — hands-free conversation using browser STT + TTS (optionally server-side Piper).
+- **Multiple threads, side by side** — Cmd/Ctrl+Click any thread in the sidebar to open it in a second panel alongside the current one. Useful for cross-referencing or driving two agents in parallel. Mobile auto-collapses to a single panel.
+- **Inline annotations** — highlight any chat text, leave a comment via the popover, and send it back as a quoted chip. Chips can be edited or removed before sending. Works like leaving a margin note on what the agent just said.
+- **[Blex blocks](https://www.npmjs.com/package/@luckydraw/blex)** — `~~~blex:TYPE` fenced JSON renders as a rich, interactive component. 22 block types including:
+  - **Interactive input** — `poll` (multi-question carousels, multi-select, write-in answers), `confirm` (Yes/No/Cancel), `form` (typed fields with validation). User responses serialize back into the chat input.
+  - **Embedded content** — `embed` (sandboxed iframe for hosted apps and webpages, inline in the chat), `image`/`gallery` (with `upload_media`-served URLs), `mermaid` and `svg` diagrams.
+  - **Live data** — `table` (sortable/selectable), `chart`, `kanban`, `calendar`, `timeline`, `status`, `metric`, `progress`, `file-tree`, `terminal`, `code`, `diff` (with Apply/Reject buttons), `layout` (composes other blocks), `branch` (step-through flowcharts).
+- **Voice mode** — hands-free conversation using browser STT + server-side Piper TTS, with sentence-by-sentence playback and barge-in.
 - **Push notifications** — PWA install + VAPID subscriptions. Agents call `notify_user` to alert you while you're away.
-- **Media uploads** — drag files in; `upload_media` tool returns a public URL backed by `~/.cumulus/media/`.
-- **Annotations** — highlight text, attach comments, send back as chips.
+- **File attachments** — drag or pick any file type. Non-image files upload via XHR with a per-chip progress bar and cancel; agents receive the absolute disk path and can `read_file` it directly. Images stay on the inline-base64 path for vision-capable models.
 - **Texitool integration** — edit Unicode-art diagrams in-place via an embedded canvas.
+- **Update banner** — auto-detects when a newer version is on npm and offers a one-click update.
 
 ### Channel adapters
 
@@ -154,7 +152,7 @@ At `/chat`. Features:
 
 ### Inter-agent messaging
 
-Any thread can message another thread using the `send_to_agent` MCP tool:
+Any thread can message another thread on the same gateway using the `send_to_agent` MCP tool:
 
 ```
 send_to_agent(target="devops", message="Deploy the new build", visibility="cc")
@@ -166,17 +164,6 @@ send_to_agent(target="devops", message="Deploy the new build", visibility="cc")
 
 If the target is busy, the message is queued and delivered as a batch when that thread is idle ("while you were busy, 3 messages arrived…").
 
-### Federation
-
-Two gateways can be linked in a hub-and-spoke topology. The hub runs at a stable URL; spokes connect outbound via WSS, so NAT doesn't matter.
-
-```
-send_to_agent("thundercat:cumulus", "…")   # cross-gateway addressing
-list_agents()                              # aggregates threads across all spokes
-```
-
-Heartbeats every 25s with bidirectional WebSocket pings; dead connections are torn down within 75s.
-
 ### Scheduled triggers
 
 Agents can schedule themselves:
@@ -200,6 +187,16 @@ list_emails(limit=10)
 
 Rate-limited per thread (default 10/hour). All sends are logged to thread history. First email from a new thread triggers a `notify_user` ping.
 
+### Reliability
+
+- **Graceful restart** — `cumulus-gateway reload` (SIGHUP) drains active Claude/HF streams up to 120s before restarting; no truncated responses on deploy.
+- **Auto-resume after restart** — interrupted threads get a resume nudge on startup so the agent picks back up with full RAG context.
+- **Persistent streaming buffer** — partial responses are flushed to disk every 5s during streaming and recovered on restart.
+- **Truncation continuation** — `finish_reason: "length"` triggers max-token escalation (8k → 16k → 32k) and seamless continuation stitching.
+- **WebSocket keepalive** — server-side ping/pong every 30s; clients reload history if a stream goes silent for >120s.
+- **Policy-error retry** — Claude CLI transient "Usage Policy" refusals auto-retry up to 3 times with a visible "Retrying…" indicator.
+- **HF transient-error retry** — `[Error: terminated]`, connection resets, and similar stream/network errors retry with exponential backoff.
+
 ### Self-update
 
 ```bash
@@ -208,7 +205,7 @@ cumulus-gateway update             # bumps to latest, saves previous for rollbac
 cumulus-gateway rollback           # restores the previous version
 ```
 
-The widget's top bar also shows an "Update available" indicator when a new version lands on npm.
+The widget's top bar also shows an "Update available" indicator (with a manual ↻ check button) when a new version lands on npm.
 
 ## Classic CLI mode
 
@@ -258,7 +255,7 @@ The `cumulus-mcp` server exposes history and content tools. Usable from any MCP-
 
 **Gateway-only tools** (available to agents running inside the daemon):
 
-`send_to_agent`, `list_agents`, `notify_user`, `schedule_trigger`, `cancel_schedule`, `list_schedules`, `send_email`, `list_emails`, `upload_media`, `create_plastic_app`, `update_pipeline`.
+`send_to_agent`, `list_agents`, `notify_user`, `schedule_trigger`, `cancel_schedule`, `list_schedules`, `send_email`, `list_emails`, `upload_media`.
 
 ## RAG & context management
 
@@ -292,7 +289,7 @@ The `cumulus-mcp` server exposes history and content tools. Usable from any MCP-
 
 All `/api/*` routes require `X-API-Key: <key>` (from `apiKeys[]`).
 
-WebSocket (`/chat/ws`) carries the same semantics with streaming, interjection, `inject`, `worker_cancel`, and voice-mode audio frames.
+WebSocket (`/chat/ws`) carries the same semantics with streaming, interjection, `inject`, and voice-mode audio frames.
 
 ## Development
 
@@ -307,7 +304,7 @@ npm run type-check
 ```
 
 - **Build:** `dist/` compiled TypeScript plus static assets (widget HTML/CSS/JS, blex bundles).
-- **Tests:** vitest, 700+ tests covering agentic loop, retriever, adapters, federation, scheduler, push.
+- **Tests:** vitest, 700+ tests covering agentic loop, retriever, adapters, scheduler, push.
 - **Deploy workflow:** bump version, `npm publish`, then `cumulus-gateway reload` on the host (SIGHUP drains active streams — see `docs/tasks/050-graceful-restart.md`).
 
 ## Background

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luckydraw/cumulus",
-  "version": "0.30.29",
+  "version": "0.30.30",
   "description": "RLM-based CLI chat wrapper for Claude with external history context management",
   "type": "module",
   "main": "dist/index.js",