volute 0.7.0 → 0.8.1

package/dist/{chunk-ZZOOTYXK.js → chunk-LIPPXNIE.js}

@@ -2,11 +2,12 @@
 import {
   resolveChannelId,
   slugify,
+  splitMessage,
   writeChannelEntry
-} from "./chunk-BX7KI4S3.js";
+} from "./chunk-N6MLQ26B.js";
 import {
   voluteHome
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";
@@ -20,6 +21,7 @@ __export(discord_exports, {
   read: () => read,
   send: () => send
 });
+var DISCORD_MAX_LENGTH = 2e3;
 var API_BASE = "https://discord.com/api/v10";
 function requireToken(env) {
   const token = env.DISCORD_TOKEN;
@@ -50,16 +52,20 @@ async function read(env, channelSlug, limit) {
 async function send(env, channelSlug, message) {
   const token = requireToken(env);
   const channelId = resolveChannelId2(env, channelSlug);
-  const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bot ${token}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ content: message })
-  });
-  if (!res.ok) {
-    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  const chunks = splitMessage(message, DISCORD_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bot ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ content: chunks[i] })
+    });
+    if (!res.ok) {
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`Discord API error: ${res.status} ${res.statusText}${partial}`);
+    }
   }
 }
 async function listConversations(env) {
@@ -134,9 +140,9 @@ async function createConversation(env, participants, _name) {
   }
   const dm = await res.json();
   const slug = `discord:@${slugify(participants[0])}`;
-  const agentDir = env.VOLUTE_AGENT_DIR;
-  if (agentDir) {
-    writeChannelEntry(agentDir, slug, {
+  const agentName = env.VOLUTE_AGENT;
+  if (agentName) {
+    writeChannelEntry(agentName, slug, {
       platformId: dm.id,
       platform: "discord",
       name: participants[0],
@@ -155,6 +161,7 @@ __export(slack_exports, {
   read: () => read2,
   send: () => send2
 });
+var SLACK_MAX_LENGTH = 4e3;
 var API_BASE2 = "https://slack.com/api";
 function requireToken2(env) {
   const token = env.SLACK_BOT_TOKEN;
@@ -191,10 +198,18 @@ async function read2(env, channelSlug, limit) {
 async function send2(env, channelSlug, message) {
   const token = requireToken2(env);
   const channelId = resolveChannelId2(env, channelSlug);
-  await slackApi(token, "chat.postMessage", {
-    channel: channelId,
-    text: message
-  });
+  const chunks = splitMessage(message, SLACK_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    try {
+      await slackApi(token, "chat.postMessage", {
+        channel: channelId,
+        text: chunks[i]
+      });
+    } catch (err) {
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`${err instanceof Error ? err.message : err}${partial}`);
+    }
+  }
 }
 async function listConversations2(env) {
   const token = requireToken2(env);
@@ -256,7 +271,7 @@ async function createConversation2(env, participants, name) {
     if (!user) throw new Error(`User not found: ${p}`);
     ids.push(user.id);
   }
-  const agentDir = env.VOLUTE_AGENT_DIR;
+  const agentName = env.VOLUTE_AGENT;
   if (name) {
     const createData = await slackApi(token, "conversations.create", {
       name,
@@ -272,8 +287,8 @@ async function createConversation2(env, participants, name) {
     const authData = await slackApi(token, "auth.test", {});
     const teamName = authData.team ?? "workspace";
     const slug2 = `slack:${slugify(teamName)}/${slugify(name)}`;
-    if (agentDir) {
-      writeChannelEntry(agentDir, slug2, {
+    if (agentName) {
+      writeChannelEntry(agentName, slug2, {
         platformId: channelId,
         platform: "slack",
         name,
@@ -287,8 +302,8 @@ async function createConversation2(env, participants, name) {
   });
   const platformId = openData.channel.id;
   const slug = participants.length === 1 ? `slack:@${slugify(participants[0])}` : `slack:@${participants.map(slugify).sort().join(",")}`;
-  if (agentDir) {
-    writeChannelEntry(agentDir, slug, {
+  if (agentName) {
+    writeChannelEntry(agentName, slug, {
       platformId,
       platform: "slack",
       name: participants.join(", "),
@@ -307,6 +322,7 @@ __export(telegram_exports, {
   read: () => read3,
   send: () => send3
 });
+var TELEGRAM_MAX_LENGTH = 4096;
 var API_BASE3 = "https://api.telegram.org";
 function requireToken3(env) {
   const token = env.TELEGRAM_BOT_TOKEN;
@@ -315,20 +331,24 @@ function requireToken3(env) {
 }
 async function read3(_env, _channelSlug, _limit) {
   throw new Error(
-    "Telegram Bot API does not support reading chat history. Use volute channel send instead."
+    "Telegram Bot API does not support reading chat history. Use volute send instead."
   );
 }
 async function send3(env, channelSlug, message) {
   const token = requireToken3(env);
   const chatId = resolveChannelId2(env, channelSlug);
-  const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ chat_id: chatId, text: message })
-  });
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new Error(`Telegram API error: ${res.status} ${body}`);
+  const chunks = splitMessage(message, TELEGRAM_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text: chunks[i] })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`Telegram API error: ${res.status} ${body}${partial}`);
+    }
   }
 }
 async function listConversations3() {
@@ -354,8 +374,7 @@ __export(volute_exports, {
   listConversations: () => listConversations4,
   listUsers: () => listUsers4,
   read: () => read4,
-  send: () => send4,
-  sendAndStream: () => sendAndStream
+  send: () => send4
 });
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
@@ -398,7 +417,7 @@ async function read4(env, channelSlug, limit) {
     return `${m.sender_name ?? m.role}: ${text}`;
   }).join("\n");
 }
-async function* sendAndStream(env, channelSlug, message) {
+async function send4(env, channelSlug, message) {
   const agentName = env.VOLUTE_AGENT;
   if (!agentName) throw new Error("VOLUTE_AGENT not set");
   const conversationId = resolveChannelId2(env, channelSlug);
@@ -417,38 +436,6 @@ async function* sendAndStream(env, channelSlug, message) {
     const data = await res.json().catch(() => ({}));
     throw new Error(data.error ?? `Failed to send: ${res.status}`);
   }
-  if (!res.body) return;
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        if (!line.startsWith("data:")) continue;
-        const data = line.slice(5).trim();
-        if (!data) continue;
-        try {
-          const event = JSON.parse(data);
-          yield event;
-          if (event.type === "done") return;
-        } catch (err) {
-          console.error(`[volute] failed to parse SSE data: ${data}`, err);
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function send4(env, channelSlug, message) {
-  for await (const event of sendAndStream(env, channelSlug, message)) {
-    if (event.type === "done") break;
-  }
 }
 async function listConversations4(env) {
   const agentName = env.VOLUTE_AGENT;
@@ -524,9 +511,8 @@ async function createConversation4(env, participants, name) {
   }
   const conv = await res.json();
   const slug = name ? `volute:${slugify(name)}` : `volute:${conv.id}`;
-  const agentDir = env.VOLUTE_AGENT_DIR;
-  if (agentDir) {
-    writeChannelEntry(agentDir, slug, {
+  if (agentName) {
+    writeChannelEntry(agentName, slug, {
       platformId: conv.id,
       platform: "volute",
       name: name ?? participants.join(", "),
@@ -569,12 +555,12 @@ function getChannelDriver(platform) {
   return CHANNELS[platform]?.driver ?? null;
 }
 function resolveChannelId2(env, slug) {
-  const agentDir = env.VOLUTE_AGENT_DIR;
-  if (!agentDir) {
+  const agentName = env.VOLUTE_AGENT;
+  if (!agentName) {
     const colonIdx = slug.indexOf(":");
     return colonIdx !== -1 ? slug.slice(colonIdx + 1) : slug;
   }
-  return resolveChannelId(agentDir, slug);
+  return resolveChannelId(agentName, slug);
 }
 
 export {

package/dist/{chunk-BX7KI4S3.js → chunk-N6MLQ26B.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  stateDir
+} from "./chunk-DP2DX4WV.js";
 
 // src/lib/slugify.ts
 function slugify(text) {
@@ -45,37 +48,6 @@ function splitMessage(text, maxLength) {
   if (text) chunks.push(text);
   return chunks;
 }
-async function* readNdjson(body) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          yield JSON.parse(line);
-        } catch {
-          console.warn(`ndjson: skipping invalid line: ${line.slice(0, 100)}`);
-        }
-      }
-    }
-    if (buffer.trim()) {
-      try {
-        yield JSON.parse(buffer);
-      } catch {
-        console.warn(`ndjson: skipping invalid line: ${buffer.slice(0, 100)}`);
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
 function getHeaders(env) {
   const headers = { "Content-Type": "application/json" };
   if (env.daemonUrl && env.daemonToken) {
@@ -106,28 +78,10 @@ function reportTyping(env, channel, sender, active) {
     console.warn(`[typing] failed to report for ${sender} on ${channel}: ${err}`);
   });
 }
-async function fireAndForget(env, payload) {
-  try {
-    const res = await fetch(`${env.baseUrl}/message`, {
-      method: "POST",
-      headers: getHeaders(env),
-      body: JSON.stringify(payload)
-    });
-    if (!res.ok) {
-      console.error(`fireAndForget: agent returned ${res.status}`);
-    }
-    if (res.body) {
-      const reader = res.body.getReader();
-      while (!(await reader.read()).done) {
-      }
-    }
-  } catch (err) {
-    console.error(`Failed to forward message: ${err}`);
-  }
-}
-async function handleAgentMessage(env, payload, handlers) {
+async function sendToAgent(env, payload) {
+  const url = `${env.baseUrl}/message`;
   try {
-    const res = await fetch(`${env.baseUrl}/message`, {
+    const res = await fetch(url, {
       method: "POST",
       headers: getHeaders(env),
       body: JSON.stringify(payload)
@@ -135,40 +89,13 @@ async function handleAgentMessage(env, payload, handlers) {
     if (!res.ok) {
       const body = await res.text().catch(() => "");
       console.error(`Agent returned ${res.status}: ${body}`);
-      await handlers.onError(`Error: agent returned ${res.status}`);
-      return;
-    }
-    if (!res.body) {
-      await handlers.onError("Error: no response from agent");
-      return;
-    }
-    let accumulated = "";
-    const pendingImages = [];
-    for await (const event of readNdjson(res.body)) {
-      if (event.type === "text") {
-        accumulated += event.content;
-      } else if (event.type === "image") {
-        pendingImages.push({ data: event.data, media_type: event.media_type });
-      } else if (event.type === "tool_use") {
-        const text2 = accumulated.trim();
-        accumulated = "";
-        const images2 = pendingImages.splice(0);
-        if (text2 || images2.length > 0) {
-          await handlers.onFlush(text2, images2);
-        }
-      } else if (event.type === "done") {
-        break;
-      }
-    }
-    const text = accumulated.trim();
-    const images = pendingImages.splice(0);
-    if (text || images.length > 0) {
-      await handlers.onFlush(text, images);
+      return { ok: false, error: `Agent returned ${res.status}` };
     }
+    return { ok: true };
   } catch (err) {
-    console.error(`Failed to reach agent at ${env.baseUrl}/message:`, err);
-    const errMsg = err instanceof TypeError && err.cause?.code === "ECONNREFUSED" ? "Agent is not running" : `Error: ${err}`;
-    await handlers.onError(errMsg);
+    console.error(`Failed to forward message: ${err}`);
+    const isConnRefused = err instanceof TypeError && err.cause?.code === "ECONNREFUSED";
+    return { ok: false, error: isConnRefused ? "Agent is not running" : "Failed to reach agent" };
   }
 }
 function buildChannelSlug(platform, meta) {
@@ -192,25 +119,26 @@ function buildChannelSlug(platform, meta) {
   }
   return `${platform}:unknown`;
 }
-function readChannelMap(agentDir) {
-  const filePath = join(agentDir, ".volute", "channels.json");
+function readChannelMap(agentName) {
+  const filePath = join(stateDir(agentName), "channels.json");
   if (!existsSync(filePath)) return {};
   try {
     return JSON.parse(readFileSync(filePath, "utf-8"));
-  } catch {
+  } catch (err) {
+    console.error(`[sdk] failed to parse ${filePath}:`, err);
     return {};
   }
 }
-function writeChannelEntry(agentDir, slug, entry) {
-  const voluteDir = join(agentDir, ".volute");
-  mkdirSync(voluteDir, { recursive: true });
-  const filePath = join(voluteDir, "channels.json");
-  const map = readChannelMap(agentDir);
+function writeChannelEntry(agentName, slug, entry) {
+  const dir = stateDir(agentName);
+  mkdirSync(dir, { recursive: true });
+  const filePath = join(dir, "channels.json");
+  const map = readChannelMap(agentName);
   map[slug] = entry;
   writeFileSync(filePath, JSON.stringify(map, null, 2) + "\n");
 }
-function resolveChannelId(agentDir, slug) {
-  const map = readChannelMap(agentDir);
+function resolveChannelId(agentName, slug) {
+  const map = readChannelMap(agentName);
   if (map[slug]) {
     return map[slug].platformId;
   }
@@ -225,8 +153,7 @@ export {
   splitMessage,
   onShutdown,
   reportTyping,
-  fireAndForget,
-  handleAgentMessage,
+  sendToAgent,
   buildChannelSlug,
   writeChannelEntry,
   resolveChannelId

package/dist/{chunk-H7AMDUIA.js → chunk-QF22MYDJ.js}

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import {
+  stateDir,
   voluteHome
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 
 // src/lib/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -9,8 +10,8 @@ import { dirname, resolve } from "path";
 function sharedEnvPath() {
   return resolve(voluteHome(), "env.json");
 }
-function agentEnvPath(agentDir) {
-  return resolve(agentDir, ".volute", "env.json");
+function agentEnvPath(agentName) {
+  return resolve(stateDir(agentName), "env.json");
 }
 function readEnv(path) {
   if (!existsSync(path)) return {};
@@ -25,9 +26,9 @@ function writeEnv(path, env) {
   writeFileSync(path, `${JSON.stringify(env, null, 2)}
 `, { mode: 384 });
 }
-function loadMergedEnv(agentDir) {
+function loadMergedEnv(agentName) {
   const shared = readEnv(sharedEnvPath());
-  const agent = readEnv(agentEnvPath(agentDir));
+  const agent = readEnv(agentEnvPath(agentName));
   return { ...shared, ...agent };
 }
 

package/dist/{chunk-NKXULRSW.js → chunk-RT6Y7AR3.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 
 // src/lib/update-check.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";