volute 0.3.0 → 0.4.0

package/dist/daemon.js

@@ -1,26 +1,30 @@
 #!/usr/bin/env node
+import {
+  CHANNELS
+} from "./chunk-5OCWMTVS.js";
 import {
   clearJsonMap,
   getAgentManager,
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-IPIPLGME.js";
+} from "./chunk-I6OHXCMV.js";
 import {
+  collectPart,
   logBuffer,
   logger_default,
   readNdjson
-} from "./chunk-N4YNKR3Q.js";
+} from "./chunk-ZHCE4DPY.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-NETNFBA5.js";
 import {
   loadMergedEnv
-} from "./chunk-YEIHRP2J.js";
+} from "./chunk-DNOXHLE5.js";
 import {
   applyIsolation
-} from "./chunk-DEUAVGSA.js";
+} from "./chunk-SOZA2TLP.js";
 import {
   agentDir,
   checkHealth,
@@ -34,32 +38,106 @@ import {
   setAgentRunning,
   setVariantRunning,
   voluteHome
-} from "./chunk-RALYNMHR.js";
+} from "./chunk-3C2XR4IY.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve8 } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve9 } from "path";
 
 // src/lib/connector-manager.ts
 import { spawn } from "child_process";
 import {
   createWriteStream,
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   unlinkSync,
   writeFileSync
 } from "fs";
-import { dirname, resolve } from "path";
+import { dirname, resolve as resolve2 } from "path";
+
+// src/lib/connector-defs.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var BUILTIN_DEFS = {
+  discord: {
+    displayName: "Discord",
+    description: "Connect to Discord as a bot",
+    envVars: [
+      {
+        name: "DISCORD_TOKEN",
+        required: true,
+        description: "Discord bot token",
+        scope: "agent"
+      },
+      {
+        name: "DISCORD_GUILD_ID",
+        required: false,
+        description: "Discord server ID (optional, for slash commands)",
+        scope: "agent"
+      }
+    ]
+  },
+  slack: {
+    displayName: "Slack",
+    description: "Connect to Slack via Socket Mode",
+    envVars: [
+      {
+        name: "SLACK_BOT_TOKEN",
+        required: true,
+        description: "Slack bot token (xoxb-...)",
+        scope: "agent"
+      },
+      {
+        name: "SLACK_APP_TOKEN",
+        required: true,
+        description: "Slack app-level token (xapp-...) for Socket Mode",
+        scope: "agent"
+      }
+    ]
+  },
+  telegram: {
+    displayName: "Telegram",
+    description: "Connect to Telegram via long polling",
+    envVars: [
+      {
+        name: "TELEGRAM_BOT_TOKEN",
+        required: true,
+        description: "Telegram bot token from BotFather",
+        scope: "agent"
+      }
+    ]
+  }
+};
+function getConnectorDef(type, connectorDir) {
+  if (BUILTIN_DEFS[type]) return BUILTIN_DEFS[type];
+  if (connectorDir) {
+    const jsonPath = resolve(connectorDir, "connector.json");
+    if (existsSync(jsonPath)) {
+      try {
+        return JSON.parse(readFileSync(jsonPath, "utf-8"));
+      } catch (err) {
+        console.warn(`Failed to parse ${jsonPath}: ${err}`);
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function checkMissingEnvVars(def, env) {
+  return def.envVars.filter((v) => v.required && !env[v.name]);
+}
+
+// src/lib/connector-manager.ts
 function searchUpwards(...segments) {
   let searchDir = dirname(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve(searchDir, ...segments);
-    if (existsSync(candidate)) return candidate;
+    const candidate = resolve2(searchDir, ...segments);
+    if (existsSync2(candidate)) return candidate;
     searchDir = dirname(searchDir);
   }
   return null;
@@ -85,6 +163,20 @@ var ConnectorManager = class {
       }
     }
   }
+  checkConnectorEnv(type, agentDir2) {
+    const agentConnectorDir = resolve2(agentDir2, "connectors", type);
+    const userConnectorDir = resolve2(voluteHome(), "connectors", type);
+    const connectorDir = existsSync2(agentConnectorDir) ? agentConnectorDir : existsSync2(userConnectorDir) ? userConnectorDir : void 0;
+    const def = getConnectorDef(type, connectorDir);
+    if (!def) return null;
+    const env = loadMergedEnv(agentDir2);
+    const missing = checkMissingEnvVars(def, env);
+    if (missing.length === 0) return null;
+    return {
+      missing: missing.map((v) => ({ name: v.name, description: v.description })),
+      connectorName: def.displayName
+    };
+  }
   async startConnector(agentName, agentDir2, agentPort, type, daemonPort) {
     const existing = this.connectors.get(agentName)?.get(type);
     if (existing) {
@@ -106,15 +198,15 @@ var ConnectorManager = class {
       this.connectors.get(agentName)?.delete(type);
     }
     this.killOrphanConnector(agentDir2, type);
-    const agentConnector = resolve(agentDir2, "connectors", type, "index.ts");
-    const userConnector = resolve(voluteHome(), "connectors", type, "index.ts");
+    const agentConnector = resolve2(agentDir2, "connectors", type, "index.ts");
+    const userConnector = resolve2(voluteHome(), "connectors", type, "index.ts");
     const builtinConnector = this.resolveBuiltinConnector(type);
     let connectorScript;
     let runtime;
-    if (existsSync(agentConnector)) {
+    if (existsSync2(agentConnector)) {
       connectorScript = agentConnector;
-      runtime = resolve(agentDir2, "node_modules", ".bin", "tsx");
-    } else if (existsSync(userConnector)) {
+      runtime = resolve2(agentDir2, "node_modules", ".bin", "tsx");
+    } else if (existsSync2(userConnector)) {
       connectorScript = userConnector;
       runtime = this.resolveVoluteTsx();
     } else if (builtinConnector) {
@@ -123,9 +215,9 @@ var ConnectorManager = class {
     } else {
       throw new Error(`No connector code found for type: ${type}`);
     }
-    const logsDir = resolve(agentDir2, ".volute", "logs");
+    const logsDir = resolve2(agentDir2, ".volute", "logs");
     mkdirSync(logsDir, { recursive: true });
-    const logStream = createWriteStream(resolve(logsDir, `${type}.log`), { flags: "a" });
+    const logStream = createWriteStream(resolve2(logsDir, `${type}.log`), { flags: "a" });
     const agentEnv = loadMergedEnv(agentDir2);
     const prefix = `${type.toUpperCase()}_`;
     const connectorEnv = Object.fromEntries(
@@ -137,8 +229,9 @@ var ConnectorManager = class {
         ...process.env,
         VOLUTE_AGENT_PORT: String(agentPort),
         VOLUTE_AGENT_NAME: agentName,
+        VOLUTE_AGENT_DIR: agentDir2,
         ...daemonPort ? {
-          VOLUTE_DAEMON_URL: `http://localhost:${daemonPort}`,
+          VOLUTE_DAEMON_URL: `http://127.0.0.1:${daemonPort}`,
           VOLUTE_DAEMON_TOKEN: process.env.VOLUTE_DAEMON_TOKEN
         } : {},
         ...connectorEnv
@@ -146,8 +239,12 @@ var ConnectorManager = class {
     };
     await applyIsolation(spawnOpts, agentName);
     const child = spawn(runtime, [connectorScript], spawnOpts);
+    let lastStderr = "";
     child.stdout?.pipe(logStream);
-    child.stderr?.pipe(logStream);
+    child.stderr?.on("data", (chunk) => {
+      logStream.write(chunk);
+      lastStderr = chunk.toString().trim();
+    });
     if (child.pid) {
       this.saveConnectorPid(agentDir2, type, child.pid);
     }
@@ -165,6 +262,7 @@ var ConnectorManager = class {
       if (this.shuttingDown) return;
       if (this.stopping.has(stopKey)) return;
       console.error(`[daemon] connector ${type} for ${agentName} exited with code ${code}`);
+      if (lastStderr) console.error(`[daemon] last output: ${lastStderr}`);
       const attempts = this.restartAttempts.get(stopKey) ?? 0;
       if (attempts >= MAX_RESTART_ATTEMPTS) {
         console.error(
@@ -194,19 +292,19 @@ var ConnectorManager = class {
     const stopKey = `${agentName}:${type}`;
     this.stopping.add(stopKey);
     agentMap.delete(type);
-    await new Promise((resolve9) => {
-      tracked.child.on("exit", () => resolve9());
+    await new Promise((resolve10) => {
+      tracked.child.on("exit", () => resolve10());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve9();
+        resolve10();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve9();
+        resolve10();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -238,7 +336,7 @@ var ConnectorManager = class {
     }));
   }
   connectorPidPath(agentDir2, type) {
-    return resolve(agentDir2, ".volute", "connectors", `${type}.pid`);
+    return resolve2(agentDir2, ".volute", "connectors", `${type}.pid`);
   }
   saveConnectorPid(agentDir2, type, pid) {
     const pidPath = this.connectorPidPath(agentDir2, type);
@@ -253,9 +351,9 @@ var ConnectorManager = class {
   }
   killOrphanConnector(agentDir2, type) {
     const pidPath = this.connectorPidPath(agentDir2, type);
-    if (!existsSync(pidPath)) return;
+    if (!existsSync2(pidPath)) return;
     try {
-      const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
       if (pid > 0) {
         process.kill(pid, "SIGTERM");
         console.error(`[daemon] killed orphan connector ${type} (pid ${pid})`);
@@ -286,7 +384,7 @@ function getConnectorManager() {
 }
 
 // src/lib/scheduler.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
@@ -296,7 +394,7 @@ var Scheduler = class {
   daemonPort = null;
   daemonToken = null;
   get statePath() {
-    return resolve2(voluteHome(), "scheduler-state.json");
+    return resolve3(voluteHome(), "scheduler-state.json");
   }
   start(daemonPort, daemonToken) {
     this.daemonPort = daemonPort ?? null;
@@ -374,10 +472,12 @@ var Scheduler = class {
       channel: "system:scheduler",
       sender: schedule.id
     });
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 12e4);
     try {
       let res;
       if (this.daemonPort && this.daemonToken) {
-        const daemonUrl = `http://localhost:${this.daemonPort}`;
+        const daemonUrl = `http://127.0.0.1:${this.daemonPort}`;
         res = await fetch(`${daemonUrl}/api/agents/${encodeURIComponent(agentName)}/message`, {
           method: "POST",
           headers: {
@@ -385,13 +485,15 @@ var Scheduler = class {
             Authorization: `Bearer ${this.daemonToken}`,
             Origin: daemonUrl
           },
-          body
+          body,
+          signal: controller.signal
         });
       } else {
-        res = await fetch(`http://localhost:${entry.port}/message`, {
+        res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body
+          body,
+          signal: controller.signal
         });
       }
       if (!res.ok) {
@@ -399,8 +501,14 @@ var Scheduler = class {
       } else {
         console.error(`[scheduler] fired "${schedule.id}" for ${agentName}`);
       }
+      try {
+        await res.body?.cancel();
+      } catch {
+      }
     } catch (err) {
       console.error(`[scheduler] failed to fire "${schedule.id}" for ${agentName}:`, err);
+    } finally {
+      clearTimeout(timeout);
     }
   }
 };
@@ -421,8 +529,8 @@ import { compareSync, hashSync } from "bcryptjs";
 import { and, count, eq } from "drizzle-orm";
 
 // src/lib/db.ts
-import { chmodSync, existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, resolve as resolve3 } from "path";
+import { chmodSync, existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 import { drizzle } from "drizzle-orm/libsql";
 import { migrate } from "drizzle-orm/libsql/migrator";
@@ -498,11 +606,11 @@ var messages = sqliteTable(
 
 // src/lib/db.ts
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync2(resolve3(__dirname, "../drizzle")) ? resolve3(__dirname, "../drizzle") : resolve3(__dirname, "../../drizzle");
+var migrationsFolder = existsSync3(resolve4(__dirname, "../drizzle")) ? resolve4(__dirname, "../drizzle") : resolve4(__dirname, "../../drizzle");
 var db = null;
 async function getDb() {
   if (db) return db;
-  const dbPath = process.env.VOLUTE_DB_PATH || resolve3(voluteHome(), "volute.db");
+  const dbPath = process.env.VOLUTE_DB_PATH || resolve4(voluteHome(), "volute.db");
   db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
   await migrate(db, { migrationsFolder });
   try {
@@ -642,9 +750,9 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname3, extname, resolve as resolve7 } from "path";
+import { dirname as dirname3, extname, resolve as resolve8 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/web/app.ts
@@ -654,25 +762,14 @@ import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
 // src/web/routes/agents.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, rmSync } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync } from "fs";
+import { resolve as resolve5 } from "path";
 import { and as and2, desc, eq as eq3 } from "drizzle-orm";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
-
-// src/lib/channels.ts
-var CHANNELS = {
-  web: { name: "web", displayName: "Web UI", showToolCalls: true },
-  discord: { name: "discord", displayName: "Discord", showToolCalls: false },
-  cli: { name: "cli", displayName: "CLI", showToolCalls: true },
-  agent: { name: "agent", displayName: "Agent", showToolCalls: true },
-  system: { name: "system", displayName: "System", showToolCalls: false }
-};
-
-// src/web/routes/agents.ts
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync2(resolve4(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync3(resolve5(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
   } catch {
     return void 0;
@@ -717,7 +814,7 @@ var app = new Hono().get("/", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  if (!existsSync3(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
+  if (!existsSync4(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
   const { status, channels } = await getAgentStatus(name, entry.port);
   const variants = readVariants(name);
   const manager = getAgentManager();
@@ -743,7 +840,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   const manager = getAgentManager();
   if (manager.isRunning(name)) {
@@ -770,7 +867,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   const manager = getAgentManager();
   const connectorManager = getConnectorManager();
@@ -825,7 +922,7 @@ var app = new Hono().get("/", async (c) => {
   }
   removeAllVariants(name);
   removeAgent(name);
-  if (force && existsSync3(dir)) {
+  if (force && existsSync4(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
   return c.json({ ok: true });
@@ -847,14 +944,22 @@ var app = new Hono().get("/", async (c) => {
   let parsed = null;
   try {
     parsed = JSON.parse(body);
-  } catch {
+  } catch (err) {
+    console.error(`[daemon] failed to parse message body for ${baseName}:`, err);
   }
   const channel = parsed?.channel ?? "unknown";
   const db2 = await getDb();
   if (parsed) {
     try {
       const sender = parsed.sender ?? null;
-      const content = typeof parsed.content === "string" ? parsed.content : JSON.stringify(parsed.content);
+      let content;
+      if (typeof parsed.content === "string") {
+        content = parsed.content;
+      } else if (Array.isArray(parsed.content)) {
+        content = parsed.content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+      } else {
+        content = JSON.stringify(parsed.content);
+      }
       await db2.insert(agentMessages).values({
         agent: baseName,
         channel,
@@ -866,11 +971,17 @@ var app = new Hono().get("/", async (c) => {
       console.error(`[daemon] failed to persist inbound message for ${baseName}:`, err);
     }
   }
-  const res = await fetch(`http://localhost:${port}/message`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body
-  });
+  let res;
+  try {
+    res = await fetch(`http://127.0.0.1:${port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body
+    });
+  } catch (err) {
+    console.error(`[daemon] agent ${name} unreachable on port ${port}:`, err);
+    return c.json({ error: "Agent is not reachable" }, 502);
+  }
   if (!res.ok) {
     return c.json({ error: `Agent responded with ${res.status}` }, res.status);
   }
@@ -878,57 +989,39 @@ var app = new Hono().get("/", async (c) => {
     return c.json({ error: "No response body from agent" }, 502);
   }
   c.header("Content-Type", "application/x-ndjson");
+  const encoder = new TextEncoder();
   return stream(c, async (s) => {
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
     const textParts = [];
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        await s.write(value);
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const event = JSON.parse(line);
-            if (event.type === "text") {
-              textParts.push(event.content);
-            }
-          } catch {
-            console.warn(`[daemon] malformed NDJSON line from ${baseName}`);
-          }
-        }
-      }
-      if (buffer.trim()) {
-        try {
-          const event = JSON.parse(buffer);
-          if (event.type === "text") {
-            textParts.push(event.content);
-          }
-        } catch {
-          console.warn(`[daemon] malformed NDJSON trailing data from ${baseName}`);
-        }
+    const toolParts = [];
+    for await (const event of readNdjson(res.body)) {
+      await s.write(encoder.encode(`${JSON.stringify(event)}
+`));
+      const part = collectPart(event);
+      if (part != null) {
+        if (event.type === "tool_use") toolParts.push(part);
+        else textParts.push(part);
       }
-      if (textParts.length > 0) {
-        try {
-          await db2.insert(agentMessages).values({
-            agent: baseName,
-            channel,
-            role: "assistant",
-            content: textParts.join("")
-          });
-        } catch (err) {
-          console.error(`[daemon] failed to persist assistant response for ${baseName}:`, err);
-        }
+    }
+    const content = [textParts.join(""), ...toolParts].filter(Boolean).join("\n");
+    if (content) {
+      try {
+        await db2.insert(agentMessages).values({
+          agent: baseName,
+          channel,
+          role: "assistant",
+          sender: baseName,
+          content
+        });
+      } catch (err) {
+        console.error(`[daemon] failed to persist assistant response for ${baseName}:`, err);
       }
-    } finally {
-      reader.releaseLock();
     }
   });
+}).get("/:name/history/channels", async (c) => {
+  const name = c.req.param("name");
+  const db2 = await getDb();
+  const rows = await db2.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq3(agentMessages.agent, name));
+  return c.json(rows.map((r) => r.channel));
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
   const channel = c.req.query("channel");
@@ -1116,7 +1209,7 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
     port = variant.port;
   }
-  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-2LU6KULR.js");
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-AUCKMGPR.js");
   if (!getAgentManager2().isRunning(name)) {
     return c.json({ error: "Agent is not running" }, 409);
   }
@@ -1155,15 +1248,21 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
     sender: user.username,
     content: body.message ?? "[image]"
   });
-  const res = await fetch(`http://localhost:${port}/message`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      content: contentBlocks,
-      channel: "web",
-      sender: user.username
-    })
-  });
+  let res;
+  try {
+    res = await fetch(`http://127.0.0.1:${port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        content: contentBlocks,
+        channel: "web",
+        sender: user.username
+      })
+    });
+  } catch (err) {
+    console.error(`[chat] agent ${name} unreachable on port ${port}:`, err);
+    return c.json({ error: "Agent is not reachable" }, 502);
+  }
   if (!res.ok) {
     return c.json({ error: `Agent responded with ${res.status}` }, res.status);
   }
@@ -1200,13 +1299,23 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
       if (event.type === "done") {
         if (assistantContent.length > 0) {
           await addMessage(conversationId, "assistant", baseName, assistantContent);
-          const textParts = assistantContent.filter((b) => b.type === "text").map((b) => b.text);
-          if (textParts.length > 0) {
+          const textParts = [];
+          const toolParts = [];
+          for (const b of assistantContent) {
+            const part = collectPart(b);
+            if (part != null) {
+              if (b.type === "tool_use") toolParts.push(part);
+              else textParts.push(part);
+            }
+          }
+          const summary = [textParts.join(""), ...toolParts].filter(Boolean).join("\n");
+          if (summary) {
             await db2.insert(agentMessages).values({
               agent: baseName,
               channel: "web",
               role: "assistant",
-              content: textParts.join("")
+              sender: baseName,
+              content: summary
             });
           }
         }
@@ -1243,13 +1352,24 @@ var app4 = new Hono4().get("/:name/connectors", (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
+  const manager = getConnectorManager();
+  const envCheck = manager.checkConnectorEnv(type, dir);
+  if (envCheck) {
+    return c.json(
+      {
+        error: "missing_env",
+        missing: envCheck.missing,
+        connectorName: envCheck.connectorName
+      },
+      400
+    );
+  }
   const config = readVoluteConfig(dir) ?? {};
   const connectors = config.connectors ?? [];
   if (!connectors.includes(type)) {
     config.connectors = [...connectors, type];
     writeVoluteConfig(dir, config);
   }
-  const manager = getConnectorManager();
   try {
     await manager.startConnector(name, dir, entry.port, type);
     return c.json({ ok: true });
@@ -1301,9 +1421,9 @@ var app5 = new Hono5().get("/:name/conversations", async (c) => {
 var conversations_default = app5;
 
 // src/web/routes/files.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readdir, readFile, writeFile } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { Hono as Hono6 } from "hono";
 import { z as z3 } from "zod";
@@ -1314,8 +1434,8 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const homeDir = resolve5(dir, "home");
-  if (!existsSync4(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve6(dir, "home");
+  if (!existsSync5(homeDir)) return c.json({ error: "Home directory missing" }, 404);
   const allFiles = await readdir(homeDir);
   const files = allFiles.filter((f) => f.endsWith(".md") && ALLOWED_FILES.has(f));
   return c.json(files);
@@ -1328,8 +1448,8 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const filePath = resolve5(dir, "home", filename);
-  if (!existsSync4(filePath)) {
+  const filePath = resolve6(dir, "home", filename);
+  if (!existsSync5(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -1343,7 +1463,7 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const filePath = resolve5(dir, "home", filename);
+  const filePath = resolve6(dir, "home", filename);
   const { content } = c.req.valid("json");
   await writeFile(filePath, content);
   return c.json({ ok: true });
@@ -1352,8 +1472,8 @@ var files_default = app6;
 
 // src/web/routes/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve6 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve7 } from "path";
 import { Hono as Hono7 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 var app7 = new Hono7().get("/:name/logs", async (c) => {
@@ -1361,8 +1481,8 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const logFile = resolve6(dir, ".volute", "logs", "agent.log");
-  if (!existsSync5(logFile)) {
+  const logFile = resolve7(dir, ".volute", "logs", "agent.log");
+  if (!existsSync6(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE2(c, async (stream2) => {
@@ -1380,9 +1500,9 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
     stream2.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve9) => {
-      tail.on("exit", resolve9);
-      stream2.onAbort(resolve9);
+    await new Promise((resolve10) => {
+      tail.on("exit", resolve10);
+      stream2.onAbort(resolve10);
     });
   });
 });
@@ -1451,7 +1571,7 @@ var app8 = new Hono8().get("/:name/schedules", (c) => {
   const body = await c.req.text();
   const message = `[webhook: ${event}] ${body}`;
   try {
-    const res = await fetch(`http://localhost:${entry.port}/message`, {
+    const res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -1484,10 +1604,10 @@ var app9 = new Hono9().get("/logs", async (c) => {
       stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve9) => {
+    await new Promise((resolve10) => {
       stream2.onAbort(() => {
         unsubscribe();
-        resolve9();
+        resolve10();
       });
     });
   });
@@ -1566,8 +1686,8 @@ async function startServer({
   let assetsDir = "";
   let searchDir = dirname3(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve7(searchDir, "dist", "web-assets");
-    if (existsSync6(candidate)) {
+    const candidate = resolve8(searchDir, "dist", "web-assets");
+    if (existsSync7(candidate)) {
       assetsDir = candidate;
       break;
     }
@@ -1576,7 +1696,7 @@ async function startServer({
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
-      const filePath = resolve7(assetsDir, urlPath.slice(1));
+      const filePath = resolve8(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -1585,7 +1705,7 @@ async function startServer({
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve7(assetsDir, "index.html");
+      const indexPath = resolve8(assetsDir, "index.html");
       const indexStat = await stat(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile2(indexPath, "utf-8");
@@ -1595,10 +1715,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve10, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve9();
+      resolve10();
     });
     server.on("error", (err) => {
       reject(err);
@@ -1612,8 +1732,8 @@ async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
-  const DAEMON_PID_PATH = resolve8(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve8(home, "daemon.json");
+  const DAEMON_PID_PATH = resolve9(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve9(home, "daemon.json");
   mkdirSync2(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
@@ -1666,13 +1786,13 @@ async function startDaemon(opts) {
   console.error(`[daemon] running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync3(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync4(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync3(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync4(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }