npm - volute - Versions diffs - 0.3.0 → 0.4.0 - Mend

volute 0.3.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

package/README.md +7 -7
package/dist/{agent-manager-2LU6KULR.js → agent-manager-AUCKMGPR.js} +4 -4
package/dist/{channel-H7N4SGR2.js → channel-DQ6UY7QB.js} +17 -40
package/dist/{chunk-RALYNMHR.js → chunk-3C2XR4IY.js} +1 -1
package/dist/chunk-5OCWMTVS.js +152 -0
package/dist/{chunk-YEIHRP2J.js → chunk-DNOXHLE5.js} +1 -1
package/dist/{chunk-IPIPLGME.js → chunk-I6OHXCMV.js} +4 -4
package/dist/chunk-MXUCNIBG.js +168 -0
package/dist/{chunk-DEUAVGSA.js → chunk-SOZA2TLP.js} +1 -1
package/dist/{chunk-VVD3XO3E.js → chunk-YGFIWIOF.js} +1 -1
package/dist/{chunk-N4YNKR3Q.js → chunk-ZHCE4DPY.js} +20 -0
package/dist/cli.js +36 -24
package/dist/connector-DKDJTLYZ.js +152 -0
package/dist/connectors/discord.js +102 -158
package/dist/connectors/slack.js +170 -0
package/dist/connectors/telegram.js +156 -0
package/dist/{create-RSWWMGKT.js → create-ILVOG75A.js} +5 -5
package/dist/{daemon-client-27KMQQKX.js → daemon-client-XR24PUJF.js} +2 -2
package/dist/daemon.js +271 -151
package/dist/{delete-4ERL2QHH.js → delete-55MXCEY5.js} +5 -5
package/dist/{down-HRC4MQCT.js → down-3OB6UVAJ.js} +1 -1
package/dist/{env-DBWDTIP6.js → env-JB27UAC3.js} +2 -2
package/dist/{history-W7BD2H74.js → history-BKG74I43.js} +4 -4
package/dist/{import-6HTSSDFW.js → import-4CI2ZUTJ.js} +17 -2
package/dist/{logs-NHWGHNBF.js → logs-NXFFGUKY.js} +1 -1
package/dist/package-Z2SFO2SV.js +89 -0
package/dist/{schedule-DKZ2E2CL.js → schedule-A35SH4HT.js} +4 -4
package/dist/{send-5LEJXPYV.js → send-3U6OTKG7.js} +8 -4
package/dist/{setup-ZMNTOJAV.js → setup-2FDVN7OF.js} +4 -4
package/dist/{start-2BSXX6BS.js → start-LDPMCMYT.js} +2 -2
package/dist/{status-N23CV27T.js → status-MVSQG54T.js} +2 -2
package/dist/{stop-DSKBIJ2D.js → stop-5PZTZCLL.js} +2 -2
package/dist/{up-4UGID4DM.js → up-F7TMTLRE.js} +1 -1
package/dist/{upgrade-BGFVRCVP.js → upgrade-6ZW2RD64.js} +32 -19
package/dist/{variant-JPLJTS2P.js → variant-T64BKARF.js} +130 -18
package/dist/web-assets/assets/{index-BC5eSqbY.js → index-NS621maO.js} +23 -23
package/dist/web-assets/index.html +1 -1
package/package.json +3 -1
package/templates/_base/_skills/volute-agent/SKILL.md +5 -4
package/templates/_base/home/VOLUTE.md +18 -6
package/templates/_base/src/lib/file-handler.ts +46 -0
package/templates/_base/src/lib/router.ts +180 -0
package/templates/_base/src/lib/routing.ts +100 -0
package/templates/_base/src/lib/types.ts +13 -2
package/templates/_base/src/lib/volute-server.ts +20 -48
package/templates/agent-sdk/src/agent.ts +268 -82
package/templates/agent-sdk/src/server.ts +12 -3
package/templates/pi/src/agent.ts +277 -58
package/templates/pi/src/server.ts +15 -4
package/dist/chunk-MY74SUOL.js +0 -81
package/dist/connector-6LWB5PRU.js +0 -96
package/templates/_base/src/lib/sessions.ts +0 -71
package/templates/agent-sdk/src/lib/agent-sessions.ts +0 -204
package/templates/pi/src/lib/agent-sessions.ts +0 -210

package/dist/web-assets/index.html CHANGED Viewed

@@ -7,7 +7,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:ital,wght@0,300;0,400;0,500;0,600;1,400&family=Space+Grotesk:wght@300;400;500;600;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-BC5eSqbY.js"></script>
+    <script type="module" crossorigin src="/assets/index-NS621maO.js"></script>
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "volute",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CLI for creating and managing self-modifying AI agents powered by the Claude Agent SDK",
   "type": "module",
   "license": "MIT",
@@ -48,11 +48,13 @@
     "@hono/node-server": "^1.19.9",
     "@hono/zod-validator": "^0.7.6",
     "@libsql/client": "^0.17.0",
+    "@slack/bolt": "^4.6.0",
     "bcryptjs": "^3.0.3",
     "cron-parser": "^5.5.0",
     "discord.js": "^14.25.1",
     "drizzle-orm": "^0.45.1",
     "hono": "^4.11.7",
+    "telegraf": "^4.16.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/templates/_base/_skills/volute-agent/SKILL.md CHANGED Viewed

@@ -18,11 +18,12 @@ You manage yourself through the `volute` CLI. Commands that operate on "your" ag
 | `volute variant create <name> [--soul "..."] [--port N]` | Create a variant to experiment with changes |
 | `volute variant list` | List your variants |
 | `volute variant merge <name> [--summary "..." --memory "..."]` | Merge a variant back |
+| `volute variant delete <name>` | Delete a variant without merging |
 | `volute upgrade [--template <name>] [--continue]` | Upgrade your server code |
-| `volute connector connect <type>` | Enable a connector (e.g. discord) |
+| `volute connector connect <type>` | Enable a connector (discord, slack, etc.) |
 | `volute connector disconnect <type>` | Disable a connector |
-| `volute channel read discord:<id> [--limit N]` | Read channel history |
-| `volute channel send discord:<id> "msg"` | Send a message proactively |
+| `volute channel read <platform>:<id> [--limit N]` | Read channel history |
+| `volute channel send <platform>:<id> "msg"` | Send a message proactively |
 | `volute schedule add --cron "..." --message "..."` | Schedule a recurring message to yourself |
 | `volute schedule list` | List your schedules |
 | `volute schedule remove --id <id>` | Remove a schedule |
@@ -57,7 +58,7 @@ Edit `.config/hooks/startup-context.sh` to customize what you see when a new ses
 Variants let you experiment safely — fork yourself, try changes, and merge back what works. Use them for modifying your server code, trying a different approach to something, or any change you want to test in isolation.
 1. `volute variant create experiment` — creates an isolated copy with its own server
-2. Make changes in the variant's worktree (at `../.worktrees/experiment/`)
+2. Make changes in the variant's worktree (at `../.variants/experiment/`)
 3. Test: `volute send $VOLUTE_AGENT@experiment "hello"`
 4. `volute variant merge experiment --summary "..." --memory "..."` — merges back after verification

package/templates/_base/home/VOLUTE.md CHANGED Viewed

@@ -7,9 +7,11 @@ You are a volute agent — a persistent being that communicates across multiple
 | Channel | Shows tool calls | Notes |
 |---------|------------------|-------|
 | Web UI  | Yes | Full detail including tool calls |
-| Discord | No  | Text responses only |
 | CLI     | Yes | Direct terminal via `volute send` |
-| System  | No  | Automated messages (upgrades, health checks) |
+| Agent   | Yes | Messages from other agents |
+| System  | No  | Automated messages (schedules, upgrades) |
+Connector channels (Discord, Slack, etc.) show text responses only — no tool calls.
 When responding to an incoming message, just respond normally — your response routes back to the source automatically. Do not use `volute channel send` to reply to a message; that would send a duplicate.
@@ -17,13 +19,14 @@ To reach out on your own initiative, use `volute channel send <uri> "message"`.
 ## Session Routing
-By default, all messages share a single conversation session. You can route messages to different sessions by editing `.config/sessions.json`.
+By default, all messages share a single conversation session. You can route messages to different sessions — or to files — by editing `.config/sessions.json`.
 ```json
 {
   "rules": [
     { "sender": "alice", "session": "alice" },
     { "channel": "discord:*", "session": "discord-${sender}" },
+    { "channel": "discord:logs", "destination": "file", "path": "memory/discord-logs.md" },
     { "channel": "system:scheduler", "sender": "daily-report", "session": "daily-report" },
     { "channel": "system:scheduler", "sender": "cleanup", "session": "$new" }
   ],
@@ -32,12 +35,21 @@ By default, all messages share a single conversation session. You can route mess
 ```
 - Rules are evaluated top-to-bottom, first match wins
-- All non-`session` keys are match criteria (AND'd together)
-- `*` glob patterns work in match values
-- `${sender}` and `${channel}` expand in session names
+- `channel` and `sender` are match criteria (AND'd together); `*` glob patterns work
+- `${sender}` and `${channel}` expand in session/path names
 - `$new` creates a fresh session every time
 - Scheduler messages use the schedule id as `sender`
+### Destinations
+- **agent** (default) — routes to a conversation session
+- **file** — appends the message to a file (requires `path`); useful for logging channels to disk
+### Options
+- `interrupt` — whether to interrupt an in-progress agent turn (default: `true`). Set to `false` for low-priority channels.
+- `batch` — buffer messages for N minutes, then deliver as a single batch. Useful for high-volume channels.
 Each named session maintains its own conversation history across restarts. Your current session name appears in the message prefix (e.g., `— session: alice —`) unless it's the default "main".
 ## Skills

package/templates/_base/src/lib/file-handler.ts ADDED Viewed

@@ -0,0 +1,46 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { log } from "./logger.js";
+import type {
+  HandlerMeta,
+  HandlerResolver,
+  Listener,
+  MessageHandler,
+  VoluteContentPart,
+} from "./types.js";
+function extractText(content: VoluteContentPart[]): string {
+  return content
+    .filter((p): p is { type: "text"; text: string } => p.type === "text")
+    .map((p) => p.text)
+    .join("\n");
+}
+export function createFileHandlerResolver(cwd: string): HandlerResolver {
+  const resolvedCwd = resolve(cwd);
+  return (filePath: string): MessageHandler => ({
+    handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void {
+      const resolved = resolve(resolvedCwd, filePath);
+      if (!resolved.startsWith(`${resolvedCwd}/`) && resolved !== resolvedCwd) {
+        log("file", `rejected path traversal: ${filePath}`);
+        queueMicrotask(() => listener({ type: "done", messageId: meta.messageId }));
+        return () => {};
+      }
+      const text = extractText(content);
+      if (text) {
+        try {
+          mkdirSync(dirname(resolved), { recursive: true });
+          appendFileSync(resolved, `${text}\n\n`);
+          log("file", `appended to ${resolved}`);
+        } catch (err) {
+          log("file", `failed to write ${resolved}:`, err);
+        }
+      }
+      // Emit done asynchronously so unsubscribe is assigned before listener fires
+      queueMicrotask(() => listener({ type: "done", messageId: meta.messageId }));
+      return () => {};
+    },
+  });
+}

package/templates/_base/src/lib/router.ts ADDED Viewed

@@ -0,0 +1,180 @@
+import { formatPrefix } from "./format-prefix.js";
+import { log, logMessage } from "./logger.js";
+import { loadRoutingConfig, resolveRoute } from "./routing.js";
+import type { ChannelMeta, HandlerResolver, Listener, VoluteContentPart } from "./types.js";
+export type Router = {
+  route(
+    content: VoluteContentPart[],
+    meta: ChannelMeta,
+    listener?: Listener,
+  ): { messageId: string; unsubscribe: () => void };
+  close(): void;
+};
+type BufferedMessage = {
+  text: string;
+  sender?: string;
+  channel?: string;
+  channelName?: string;
+  guildName?: string;
+  timestamp: string;
+};
+type BatchBuffer = {
+  messages: BufferedMessage[];
+  timer: ReturnType<typeof setInterval>;
+  sessionName: string;
+};
+function generateMessageId(): string {
+  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function applyPrefix(content: VoluteContentPart[], meta: ChannelMeta): VoluteContentPart[] {
+  const time = new Date().toLocaleString();
+  const prefix = formatPrefix(meta, time);
+  if (!prefix) return content;
+  const firstTextIdx = content.findIndex((p) => p.type === "text");
+  if (firstTextIdx === -1) {
+    return [{ type: "text", text: prefix.trimEnd() }, ...content];
+  }
+  return content.map((part, i) => {
+    if (i === firstTextIdx) {
+      return { type: "text" as const, text: prefix + (part as { text: string }).text };
+    }
+    return part;
+  });
+}
+export function createRouter(options: {
+  configPath?: string;
+  agentHandler: HandlerResolver;
+  fileHandler?: HandlerResolver;
+}): Router {
+  const batchBuffers = new Map<string, BatchBuffer>();
+  function flushBatch(key: string) {
+    const buffer = batchBuffers.get(key);
+    if (!buffer || buffer.messages.length === 0) return;
+    const messages = buffer.messages.splice(0);
+    // Group by channel for header summary
+    const channelCounts = new Map<string, number>();
+    for (const msg of messages) {
+      const label = msg.channelName
+        ? `#${msg.channelName}${msg.guildName ? ` in ${msg.guildName}` : ""}`
+        : (msg.channel ?? "unknown");
+      channelCounts.set(label, (channelCounts.get(label) ?? 0) + 1);
+    }
+    const summary = [...channelCounts.entries()].map(([ch, n]) => `${n} from ${ch}`).join(", ");
+    const header = `[Batch: ${messages.length} message${messages.length === 1 ? "" : "s"} — ${summary}]`;
+    const body = messages
+      .map((m) => `[${m.sender ?? "unknown"} — ${m.timestamp}]\n${m.text}`)
+      .join("\n\n");
+    const content: VoluteContentPart[] = [{ type: "text", text: `${header}\n\n${body}` }];
+    const messageId = generateMessageId();
+    const handler = options.agentHandler(buffer.sessionName);
+    // Batch flushes are fire-and-forget — no HTTP response is waiting, so listener is a noop
+    try {
+      handler.handle(content, { sessionName: buffer.sessionName, messageId }, () => {});
+    } catch (err) {
+      log("router", `error flushing batch for session ${buffer.sessionName}:`, err);
+      return;
+    }
+    log("router", `flushed batch for session ${buffer.sessionName}: ${messages.length} messages`);
+  }
+  function route(
+    content: VoluteContentPart[],
+    meta: ChannelMeta,
+    listener?: Listener,
+  ): { messageId: string; unsubscribe: () => void } {
+    // Log incoming message
+    const text = content
+      .filter((p): p is { type: "text"; text: string } => p.type === "text")
+      .map((p) => p.text)
+      .join(" ");
+    logMessage("in", text, meta.channel);
+    // Resolve route from config (re-read on each request for hot-reload)
+    const config = options.configPath ? loadRoutingConfig(options.configPath) : {};
+    const resolved = resolveRoute(config, { channel: meta.channel, sender: meta.sender });
+    const messageId = generateMessageId();
+    const noop = () => {};
+    const safeListener = listener ?? noop;
+    // File destination
+    if (resolved.destination === "file") {
+      if (options.fileHandler) {
+        const formatted = applyPrefix(content, meta);
+        const handler = options.fileHandler(resolved.path);
+        const unsubscribe = handler.handle(formatted, { ...meta, messageId }, safeListener);
+        return { messageId, unsubscribe };
+      }
+      // No file handler configured — emit done and discard
+      log("router", `no file handler configured — discarding file-destined message`);
+      queueMicrotask(() => safeListener({ type: "done", messageId }));
+      return { messageId, unsubscribe: noop };
+    }
+    // Agent destination
+    let sessionName = resolved.session;
+    if (sessionName === "$new") {
+      sessionName = `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    // Batch mode: buffer the message and return immediate done
+    if (resolved.batch != null) {
+      const batchKey = `batch:${sessionName}`;
+      if (!batchBuffers.has(batchKey)) {
+        const timer = setInterval(() => flushBatch(batchKey), resolved.batch * 60 * 1000);
+        timer.unref();
+        batchBuffers.set(batchKey, { messages: [], timer, sessionName });
+      }
+      batchBuffers.get(batchKey)!.messages.push({
+        text,
+        sender: meta.sender,
+        channel: meta.channel,
+        channelName: meta.channelName,
+        guildName: meta.guildName,
+        timestamp: new Date().toLocaleTimeString("en-US", {
+          hour: "numeric",
+          minute: "2-digit",
+        }),
+      });
+      queueMicrotask(() => safeListener({ type: "done", messageId }));
+      return { messageId, unsubscribe: noop };
+    }
+    // Direct dispatch to agent
+    const formatted = applyPrefix(content, { ...meta, sessionName });
+    const handler = options.agentHandler(sessionName);
+    const unsubscribe = handler.handle(
+      formatted,
+      { ...meta, sessionName, messageId, interrupt: resolved.interrupt },
+      safeListener,
+    );
+    return { messageId, unsubscribe };
+  }
+  function close() {
+    for (const [key, buffer] of batchBuffers) {
+      clearInterval(buffer.timer);
+      flushBatch(key);
+    }
+    batchBuffers.clear();
+  }
+  return { route, close };
+}

package/templates/_base/src/lib/routing.ts ADDED Viewed

@@ -0,0 +1,100 @@
+import { readFileSync } from "node:fs";
+import { log } from "./logger.js";
+export type RoutingRule = {
+  session?: string;
+  destination?: "agent" | "file";
+  path?: string; // file path for file destination
+  interrupt?: boolean; // interrupt in-progress agent turn (default: true for agent)
+  batch?: number; // minutes — buffer messages, flush on timer
+  channel?: string;
+  sender?: string;
+};
+export type RoutingConfig = {
+  rules?: RoutingRule[];
+  default?: string;
+};
+export type ResolvedRoute =
+  | { destination: "agent"; session: string; interrupt: boolean; batch?: number }
+  | { destination: "file"; path: string };
+export function loadRoutingConfig(configPath: string): RoutingConfig {
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (err: any) {
+    if (err?.code !== "ENOENT") {
+      log("sessions", `failed to load ${configPath}:`, err);
+    }
+    return {};
+  }
+}
+/**
+ * Match a glob-like pattern against a string.
+ * Supports only `*` as wildcard (matches any sequence of characters).
+ */
+function globMatch(pattern: string, value: string): boolean {
+  // Escape regex special chars except *, then replace * with .*
+  const regex = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${regex}$`).test(value);
+}
+const MATCH_KEYS = new Set(["channel", "sender"]);
+const NON_MATCH_KEYS = new Set(["session", "batch", "destination", "path", "interrupt"]);
+function ruleMatches(rule: RoutingRule, meta: { channel?: string; sender?: string }): boolean {
+  for (const [key, pattern] of Object.entries(rule)) {
+    if (NON_MATCH_KEYS.has(key)) continue;
+    if (typeof pattern !== "string") return false;
+    if (!MATCH_KEYS.has(key)) return false;
+    const value = meta[key as keyof typeof meta] ?? "";
+    if (!globMatch(pattern, value)) return false;
+  }
+  return true;
+}
+function expandTemplate(template: string, meta: { channel?: string; sender?: string }): string {
+  return template
+    .replace(/\$\{sender\}/g, meta.sender ?? "unknown")
+    .replace(/\$\{channel\}/g, meta.channel ?? "unknown");
+}
+/**
+ * Resolve the full route for a message: destination type, session/path, interrupt, batch.
+ */
+export function resolveRoute(
+  config: RoutingConfig,
+  meta: { channel?: string; sender?: string },
+): ResolvedRoute {
+  const fallback = config.default ?? "main";
+  if (!config.rules) {
+    return { destination: "agent", session: fallback, interrupt: true };
+  }
+  for (const rule of config.rules) {
+    if (ruleMatches(rule, meta)) {
+      if (rule.destination === "file") {
+        if (!rule.path) {
+          log("sessions", `file destination rule missing path — falling through`);
+          continue;
+        }
+        return { destination: "file", path: rule.path };
+      }
+      return {
+        destination: "agent",
+        session: sanitizeSessionName(expandTemplate(rule.session ?? fallback, meta)),
+        interrupt: rule.interrupt ?? true,
+        batch: rule.batch,
+      };
+    }
+  }
+  return { destination: "agent", session: fallback, interrupt: true };
+}
+function sanitizeSessionName(name: string): string {
+  return name.replace(/\0/g, "").replace(/[/\\]/g, "-").replace(/\.\./g, "-").slice(0, 100);
+}

package/templates/_base/src/lib/types.ts CHANGED Viewed

@@ -10,7 +10,12 @@ export type ChannelMeta = {
   channelName?: string;
   guildName?: string;
   sessionName?: string;
-  messageId?: string;
+};
+/** ChannelMeta enriched by the router with dispatch info. */
+export type HandlerMeta = ChannelMeta & {
+  messageId: string;
+  interrupt?: boolean;
 };
 export type VoluteRequest = {
@@ -28,4 +33,10 @@ export type VoluteEvent = { messageId?: string } & (
 export type Listener = (event: VoluteEvent) => void;
-export const INTERACTIVE_CHANNELS = new Set(["web", "cli", "discord"]);
+/** A handler that processes a single routed message and streams events to a listener. */
+export type MessageHandler = {
+  handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void; // returns unsubscribe
+};
+/** Resolves a key (session name, file path, etc.) to a MessageHandler. */
+export type HandlerResolver = (key: string) => MessageHandler;

package/templates/_base/src/lib/volute-server.ts CHANGED Viewed

@@ -1,12 +1,7 @@
 import { createServer, type IncomingMessage, type Server } from "node:http";
 import { log } from "./logger.js";
-import { loadSessionConfig, resolveSession } from "./sessions.js";
-import type { ChannelMeta, VoluteContentPart, VoluteEvent, VoluteRequest } from "./types.js";
-export type VoluteAgent = {
-  sendMessage: (content: string | VoluteContentPart[], meta?: ChannelMeta) => void;
-  onMessage: (listener: (event: VoluteEvent) => void, sessionName?: string) => () => void;
-};
+import type { Router } from "./router.js";
+import type { VoluteRequest } from "./types.js";
 function readBody(req: IncomingMessage): Promise<string> {
   return new Promise((resolve, reject) => {
@@ -18,13 +13,12 @@ function readBody(req: IncomingMessage): Promise<string> {
 }
 export function createVoluteServer(options: {
-  agent: VoluteAgent;
+  router: Router;
   port: number;
   name: string;
   version: string;
-  sessionsConfigPath?: string;
 }): Server {
-  const { agent, port, name, version } = options;
+  const { router, port, name, version } = options;
   const server = createServer(async (req, res) => {
     const url = new URL(req.url!, "http://localhost");
@@ -39,58 +33,34 @@ export function createVoluteServer(options: {
       try {
         const body = JSON.parse(await readBody(req)) as VoluteRequest;
-        // Resolve session from routing config (re-read on each request for hot-reload)
-        let sessionName = "main";
-        if (options.sessionsConfigPath) {
-          const sessionConfig = loadSessionConfig(options.sessionsConfigPath);
-          sessionName = resolveSession(sessionConfig, {
-            channel: body.channel,
-            sender: body.sender,
-          });
-        }
-        if (sessionName === "$new") {
-          sessionName = `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        }
-        const messageId = `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         res.writeHead(200, {
           "Content-Type": "application/x-ndjson",
           "Cache-Control": "no-cache",
           Connection: "keep-alive",
         });
-        const removeListener = agent.onMessage((event) => {
+        const { unsubscribe } = router.route(body.content, body, (event) => {
           try {
-            // Only forward events from our message (skip startup/other messages)
-            if (event.messageId !== messageId) return;
             res.write(`${JSON.stringify(event)}\n`);
             if (event.type === "done") {
-              removeListener();
               res.end();
             }
-          } catch {
-            removeListener();
+          } catch (err) {
+            log("server", "write error, disconnecting:", err);
+            unsubscribe();
           }
-        }, sessionName);
-        res.on("close", () => {
-          removeListener();
         });
-        agent.sendMessage(body.content, {
-          channel: body.channel,
-          sender: body.sender,
-          platform: body.platform,
-          isDM: body.isDM,
-          channelName: body.channelName,
-          guildName: body.guildName,
-          sessionName,
-          messageId,
-        });
-      } catch {
-        res.writeHead(400);
-        res.end("Bad Request");
+        res.on("close", () => unsubscribe());
+      } catch (err) {
+        if (err instanceof SyntaxError) {
+          res.writeHead(400);
+          res.end("Bad Request");
+        } else {
+          log("server", "error handling /message:", err);
+          res.writeHead(500);
+          res.end("Internal Server Error");
+        }
       }
       return;
     }
@@ -99,6 +69,8 @@ export function createVoluteServer(options: {
     res.end("Not Found");
   });
+  server.on("close", () => router.close());
   let retries = 0;
   const maxRetries = 5;
   server.on("error", (err: NodeJS.ErrnoException) => {