@chrysb/alphaclaw 0.8.3-beta.3 → 0.8.3-beta.5

package/lib/server/chat-ws.js

@@ -354,6 +354,10 @@ const createChatWsService = ({
   let gatewayConnectPromise = null;
   const pendingGatewayRequests = new Map();
   const runTargets = new Map();
+  /** While `chat.send` is in flight, agent events can arrive before we have `runId` + runTargets — match by session. */
+  const pendingSessionBySessionKey = new Map();
+  /** Agent events keyed by runId when the event references a run not yet in runTargets (race with chat.send response). */
+  const pendingAgentEventsByRunId = new Map();
   const browserRuns = new WeakMap();
 
   const sendJson = (ws, payload = {}) => {
@@ -382,6 +386,9 @@ const createChatWsService = ({
   };
 
   const clearRunTargetsForBrowser = (ws) => {
+    for (const [sk, pending] of pendingSessionBySessionKey.entries()) {
+      if (pending.ws === ws) pendingSessionBySessionKey.delete(sk);
+    }
     const runs = browserRuns.get(ws);
     if (!runs) return;
     for (const runId of runs) runTargets.delete(runId);
@@ -416,6 +423,7 @@ const createChatWsService = ({
   const markGatewayDisconnected = (reason = "Gateway disconnected") => {
     gatewaySocket = null;
     gatewayConnectPromise = null;
+    pendingAgentEventsByRunId.clear();
     rejectAllGatewayRequests(reason);
   };
 
@@ -436,6 +444,17 @@ const createChatWsService = ({
           sessionTarget = targetRow;
         }
         if (sessionTarget) return { runId: "", target: sessionTarget };
+        const pending = pendingSessionBySessionKey.get(sessionKey);
+        if (pending) {
+          return {
+            runId: resolveRunIdFromPayload(payload),
+            target: {
+              ws: pending.ws,
+              messageId: pending.messageId,
+              sessionKey,
+            },
+          };
+        }
       }
       if (runTargets.size === 1) {
         for (const [singleRunId, singleTarget] of runTargets.entries()) {
@@ -446,9 +465,60 @@ const createChatWsService = ({
     };
     if (eventName === "agent") {
       const { runId, target } = resolveTargetForPayload();
-      if (!target) return;
+      if (!target) {
+        const runIdEarly = resolveRunIdFromPayload(payload);
+        if (runIdEarly && !runTargets.get(runIdEarly)) {
+          const list = pendingAgentEventsByRunId.get(runIdEarly) || [];
+          list.push(eventPayload);
+          pendingAgentEventsByRunId.set(runIdEarly, list);
+        }
+        return;
+      }
       const stream = String(payload?.stream || "");
       const data = payload?.data || {};
+      if (stream === "tool") {
+        const toolPhase = String(data?.phase || "");
+        const toolName = String(data?.name || "unknown");
+        const toolCallId = String(data?.toolCallId || "");
+        if (toolPhase === "start") {
+          sendJson(target.ws, {
+            type: "tool",
+            phase: "call",
+            messageId: target.messageId,
+            sessionKey: target.sessionKey,
+            timestamp: Number(payload?.ts) || Date.now(),
+            toolCall: {
+              id: toolCallId,
+              name: toolName,
+              arguments: data?.args || null,
+              partialJson: "",
+            },
+            toolResult: null,
+            rawEvent: eventPayload || null,
+          });
+        } else if (toolPhase === "result") {
+          const resultText = collectTextFromUnknownShape(data?.result);
+          sendJson(target.ws, {
+            type: "tool",
+            phase: "result",
+            messageId: target.messageId,
+            sessionKey: target.sessionKey,
+            timestamp: Number(payload?.ts) || Date.now(),
+            toolCall: null,
+            toolResult: {
+              role: "toolResult",
+              toolCallId,
+              toolName,
+              content: resultText
+                ? [{ type: "text", text: resultText }]
+                : [],
+              isError: data?.isError === true,
+            },
+            rawEvent: eventPayload || null,
+          });
+        }
+        return;
+      }
       const toolCall =
         extractToolCallFromUnknownShape(payload) ||
         extractToolCallFromUnknownShape(data);
@@ -557,7 +627,7 @@ const createChatWsService = ({
             },
             role: "operator",
             scopes: kGatewayChatBridgeScopes,
-            caps: [],
+            caps: ["tool-events"],
             commands: [],
             permissions: {},
             auth: { token: getGatewayToken() },
@@ -689,13 +759,21 @@ const createChatWsService = ({
       });
       return;
     }
-    const result = await requestGateway("chat.send", {
-      sessionKey,
-      message: content,
-      idempotencyKey: crypto.randomUUID(),
-    });
+    pendingSessionBySessionKey.set(sessionKey, { ws, messageId });
+    let result;
+    try {
+      result = await requestGateway("chat.send", {
+        sessionKey,
+        message: content,
+        idempotencyKey: crypto.randomUUID(),
+      });
+    } catch (err) {
+      pendingSessionBySessionKey.delete(sessionKey);
+      throw err;
+    }
     const runId = String(result?.runId || "").trim();
     if (!runId) {
+      pendingSessionBySessionKey.delete(sessionKey);
       sendJson(ws, {
         type: "error",
         message: "Something went wrong connecting to the agent.",
@@ -706,12 +784,20 @@ const createChatWsService = ({
     }
     runTargets.set(runId, { ws, messageId, sessionKey });
     registerRunForBrowser(ws, runId);
+    pendingSessionBySessionKey.delete(sessionKey);
     sendJson(ws, {
       type: "started",
       sessionKey,
       runId,
       messageId,
     });
+    const buffered = pendingAgentEventsByRunId.get(runId);
+    if (buffered && buffered.length) {
+      pendingAgentEventsByRunId.delete(runId);
+      for (const stored of buffered) {
+        handleGatewayEvent(stored);
+      }
+    }
   };
 
   const handleStop = async ({ ws, payload }) => {

package/lib/server/routes/system.js

@@ -1,6 +1,5 @@
 const { buildManagedPaths } = require("../internal-files-migration");
 const { readOpenclawConfig } = require("../openclaw-config");
-const { hasScopedBindingFields } = require("../utils/channels");
 const https = require("https");
 
 const registerSystemRoutes = ({
@@ -117,40 +116,6 @@ const registerSystemRoutes = ({
       .filter(Boolean)
       .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
       .join(" ");
-  const resolveTelegramAccountIdForAgent = ({ config, agentId }) => {
-    const normalizedAgentId = String(agentId || "").trim();
-    if (!normalizedAgentId) return "default";
-    const bindings = Array.isArray(config?.bindings) ? config.bindings : [];
-    for (const binding of bindings) {
-      if (String(binding?.agentId || "").trim() !== normalizedAgentId) continue;
-      const match = binding?.match || {};
-      if (String(match.channel || "").trim() !== "telegram") continue;
-      if (hasScopedBindingFields(match)) continue;
-      return String(match.accountId || "").trim() || "default";
-    }
-    return normalizedAgentId === "main" ? "default" : "";
-  };
-  const resolveTelegramChannelNameForAgent = ({ config, agentId }) => {
-    const telegramConfig =
-      config?.channels?.telegram && typeof config.channels.telegram === "object"
-        ? config.channels.telegram
-        : {};
-    const accountId = resolveTelegramAccountIdForAgent({ config, agentId });
-    const hasAccounts =
-      telegramConfig.accounts && typeof telegramConfig.accounts === "object";
-    if (hasAccounts) {
-      const accountConfig =
-        accountId && telegramConfig.accounts?.[accountId]
-          ? telegramConfig.accounts[accountId]
-          : {};
-      const accountName = String(accountConfig?.name || "").trim();
-      if (accountName) return accountName;
-    } else if (accountId === "default") {
-      const legacyName = String(telegramConfig?.name || "").trim();
-      if (legacyName) return legacyName;
-    }
-    return "Telegram";
-  };
   const getDefaultAgentLabel = (config = {}) => {
     return "Main Agent";
   };
@@ -182,44 +147,31 @@ const registerSystemRoutes = ({
     if (!agentId) return "Agent";
     return getConfiguredAgentLabel(config, agentId);
   };
-  const buildSessionLabel = (sessionRow = {}, config = {}) => {
-    const key = String(sessionRow?.key || "");
-    const agentLabel = getAgentLabelFromSessionKey(key, config);
-    const agentKeyMatch = key.match(/^agent:([^:]+):/);
-    const agentId = String(agentKeyMatch?.[1] || "").trim();
-    const telegramChannelName = resolveTelegramChannelNameForAgent({
-      config,
-      agentId,
-    });
-    if (key.endsWith(":main")) return `${agentLabel} - Main Thread`;
-    const telegramMatch = key.match(/:telegram:direct:([^:]+)$/);
-    if (telegramMatch) {
-      return `${agentLabel} - Telegram DM (${telegramChannelName})`;
-    }
-    const telegramTopicMatch = key.match(
-      /:telegram:group:([^:]+):topic:([^:]+)$/,
-    );
-    if (telegramTopicMatch) {
-      const [, groupId, topicId] = telegramTopicMatch;
-      let groupEntry = null;
-      try {
-        groupEntry = topicRegistry?.getGroup?.(groupId) || null;
-      } catch {}
-      const groupName = String(groupEntry?.name || "").trim();
-      const topicName = String(
-        groupEntry?.topics?.[topicId]?.name || "",
-      ).trim();
-      if (groupName && topicName) {
-        return `${agentLabel} - ${telegramChannelName} ${groupName} · ${topicName}`;
-      }
-      if (topicName) return `${agentLabel} - ${telegramChannelName} Topic ${topicName}`;
-      return `${agentLabel} - ${telegramChannelName} Topic ${topicId}`;
-    }
-    const directMatch = key.match(/:direct:([^:]+)$/);
-    if (directMatch) {
-      return `${agentLabel} - Direct ${directMatch[1]}`;
+  const parseChannelFromSessionKey = (key = "") => {
+    const k = String(key || "");
+    if (k.includes(":telegram:")) return "telegram";
+    if (k.includes(":discord:")) return "discord";
+    if (k.includes(":slack:")) return "slack";
+    return "";
+  };
+  const getSessionTopicContext = (sessionKey = "") => {
+    const key = String(sessionKey || "");
+    const topicMatch = key.match(/:telegram:group:([^:]+):topic:([^:]+)$/);
+    if (!topicMatch) {
+      return {
+        groupName: "",
+        topicName: "",
+      };
     }
-    return key || "Session";
+    const [, groupId, topicId] = topicMatch;
+    let groupEntry = null;
+    try {
+      groupEntry = topicRegistry?.getGroup?.(groupId) || null;
+    } catch {}
+    return {
+      groupName: String(groupEntry?.name || "").trim(),
+      topicName: String(groupEntry?.topics?.[topicId]?.name || "").trim(),
+    };
   };
   const syncApiKeyAuthProfilesFromEnvVars = (nextEnvVars) => {
     if (!authProfiles) return;
@@ -280,21 +232,15 @@ const registerSystemRoutes = ({
       fallback: {},
     });
     return sessions
-      .filter((sessionRow) => {
-        const key = getRawSessionKey(sessionRow).toLowerCase();
-        if (!key) return false;
-        if (
-          key.includes(":hook:") ||
-          key.includes(":cron:") ||
-          key.includes(":doctor:")
-        ) {
-          return false;
-        }
-        return true;
-      })
       .map((sessionRow) => {
         const key = getRawSessionKey(sessionRow);
+        if (!key) return null;
         const replyTarget = getSessionReplyTarget(key);
+        const agentKeyMatch = key.match(/^agent:([^:]+):/);
+        const agentId = String(agentKeyMatch?.[1] || "").trim();
+        const channel =
+          parseChannelFromSessionKey(key) || replyTarget.replyChannel || "";
+        const topicContext = getSessionTopicContext(key);
         return {
           key,
           sessionId: String(sessionRow?.sessionId || sessionRow?.id || ""),
@@ -304,11 +250,16 @@ const registerSystemRoutes = ({
                 sessionRow?.lastActivityAt ||
                 sessionRow?.lastActiveAt,
             ) || 0,
-          label: buildSessionLabel(sessionRow, config),
+          agentId,
+          agentLabel: getAgentLabelFromSessionKey(key, config),
+          channel,
+          groupName: topicContext.groupName,
+          topicName: topicContext.topicName,
           replyChannel: replyTarget.replyChannel,
           replyTo: replyTarget.replyTo,
         };
       })
+      .filter(Boolean)
       .sort((a, b) => b.updatedAt - a.updatedAt);
   };
   const readSystemCronConfig = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.8.3-beta.3",
+  "version": "0.8.3-beta.5",
   "publishConfig": {
     "access": "public"
   },