@sumeai/sumeclaw 1.1.20 → 1.2.1

package/dist/chunk-RIUKFLMY.js

@@ -0,0 +1,746 @@
+// src/runtime.ts
+var runtimeRef = null;
+function setSumeclawRuntime(runtime) {
+  runtimeRef = runtime;
+}
+function tryGetSumeclawRuntime() {
+  return runtimeRef;
+}
+
+// src/gateway.ts
+import WebSocket from "ws";
+import { dispatchInboundDirectDmWithRuntime } from "openclaw/plugin-sdk/direct-dm";
+var DEFAULT_PLATFORM_URL = "wss://api.gixin.cc";
+var connections = /* @__PURE__ */ new Map();
+var connectingAccounts = /* @__PURE__ */ new Set();
+var pendingReplyContexts = /* @__PURE__ */ new Map();
+function replyContextKey(accountId, userId) {
+  return `${accountId}:${userId}`;
+}
+function getWebSocket(accountId) {
+  return connections.get(accountId);
+}
+function rememberPendingReplyContext(params) {
+  const key = replyContextKey(params.accountId, params.userId);
+  pendingReplyContexts.set(replyContextKey(params.accountId, params.userId), {
+    requestId: params.requestId,
+    sessionKey: params.sessionKey,
+    stream: params.stream,
+    accumulatedText: ""
+  });
+}
+function getPendingReplyContext(accountId, userId) {
+  return pendingReplyContexts.get(replyContextKey(accountId, userId));
+}
+function consumePendingReplyContext(accountId, userId) {
+  const key = replyContextKey(accountId, userId);
+  const ctx = pendingReplyContexts.get(key);
+  pendingReplyContexts.delete(key);
+  return ctx;
+}
+function appendPendingReplyText(accountId, userId, text) {
+  const ctx = getPendingReplyContext(accountId, userId);
+  if (!ctx) return "";
+  if (!ctx.accumulatedText) {
+    ctx.accumulatedText = text;
+  } else if (text.startsWith(ctx.accumulatedText)) {
+    ctx.accumulatedText = text;
+  } else if (!ctx.accumulatedText.endsWith(text)) {
+    ctx.accumulatedText += text;
+  }
+  return ctx.accumulatedText;
+}
+function connectGateway(opts) {
+  const { accountId, botToken, api } = opts;
+  const platformUrl = opts.platformUrl || DEFAULT_PLATFORM_URL;
+  const defaultAgentId = opts.defaultAgentId || "main";
+  const existing = connections.get(accountId);
+  if (existing && (existing.readyState === WebSocket.OPEN || existing.readyState === WebSocket.CONNECTING)) {
+    console.log(`[sumeclaw] \u267B\uFE0F reuse existing connection: ${accountId}`);
+    return;
+  }
+  if (connectingAccounts.has(accountId)) {
+    console.log(`[sumeclaw] \u267B\uFE0F connection already starting: ${accountId}`);
+    return;
+  }
+  let ws = null;
+  let heartbeatTimer = null;
+  let reconnectTimer = null;
+  const HEARTBEAT_INTERVAL = 3e4;
+  const RECONNECT_DELAY = 5e3;
+  function start() {
+    const url = `${platformUrl.replace(/\/$/, "")}/api/channel/${botToken}`;
+    console.log(`[sumeclaw] \u{1F310} connecting -> ${url} (${accountId})`);
+    connectingAccounts.add(accountId);
+    ws = new WebSocket(url);
+    connections.set(accountId, ws);
+    ws.on("open", () => {
+      console.log(`[sumeclaw] \u2705 connected: ${accountId}`);
+      connectingAccounts.delete(accountId);
+      connections.set(accountId, ws);
+      ws?.send(
+        JSON.stringify({
+          type: "register_info",
+          token: botToken,
+          agentId: defaultAgentId,
+          version: "1.2.0"
+        })
+      );
+      heartbeatTimer = setInterval(() => {
+        if (ws?.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "heartbeat" }));
+        }
+      }, HEARTBEAT_INTERVAL);
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        console.log("[sumeclaw] \u{1F4E9} message:", msg);
+        handleMessage(msg).catch((err) => {
+          console.error("[sumeclaw] \u274C handle message error", err);
+        });
+      } catch (err) {
+        console.error("[sumeclaw] \u274C parse message error", err);
+      }
+    });
+    ws.on("close", (code, reasonBuffer) => {
+      const reason = reasonBuffer.toString();
+      console.warn(`[sumeclaw] \u26A0\uFE0F disconnected: ${accountId}`, { code, reason });
+      cleanup();
+      if (code === 4e3 || reason.includes("replaced by a newer OpenClaw plugin connection")) {
+        console.warn(`[sumeclaw] \u{1F6D1} connection replaced, stop reconnecting: ${accountId}`);
+        return;
+      }
+      scheduleReconnect();
+    });
+    ws.on("error", (err) => {
+      console.error(`[sumeclaw] \u274C ws error: ${accountId}`, err);
+      connectingAccounts.delete(accountId);
+      ws?.close();
+    });
+  }
+  async function handleMessage(msg) {
+    switch (msg.type) {
+      case "heartbeat_ack":
+        break;
+      case "hooks_agent":
+        await handleHooksAgent(msg.payload ?? msg);
+        break;
+      case "message":
+        console.log("[sumeclaw] \u{1F4AC} \u6536\u5230\u6D88\u606F:", msg);
+        await dispatchToOpenClaw({
+          agentId: msg.agentId || "main",
+          message: msg.text || msg.message || "",
+          messageId: msg.id || msg.messageId,
+          sessionKey: msg.sessionKey || `agent:${msg.agentId || "main"}:user:${msg.from || msg.userId || "unknown"}`,
+          userId: msg.from || msg.userId || msg.senderId || "unknown",
+          raw: msg,
+          requestId: msg.requestId,
+          stream: Boolean(msg.stream)
+        });
+        break;
+      case "registered":
+        console.log(`[sumeclaw] \u{1F510} \u6CE8\u518C\u6210\u529F: ${accountId}`);
+        break;
+      default:
+        console.log("[sumeclaw] \u2753 \u672A\u5904\u7406\u6D88\u606F:", msg);
+    }
+  }
+  async function handleHooksAgent(payload) {
+    const meta = payload?.meta ?? {};
+    const userId = String(meta.user_id || payload.userId || payload.from || "unknown");
+    const agentId = String(payload.agentId || meta.agent_id || "main");
+    const text = String(payload.message || payload.text || "");
+    const sessionKey = payload.sessionKey || `agent:${agentId}:user:${userId}`;
+    console.log("[sumeclaw] \u{1F9E0} hooks_agent -> OpenClaw", {
+      accountId,
+      agentId,
+      sessionKey,
+      userId,
+      text: text.slice(0, 100)
+    });
+    rememberPendingReplyContext({
+      accountId,
+      userId,
+      requestId: payload.requestId,
+      sessionKey,
+      stream: Boolean(payload.stream)
+    });
+    await dispatchToOpenClaw({
+      agentId,
+      message: text,
+      messageId: payload.messageId || `${sessionKey}:${Date.now()}`,
+      sessionKey,
+      userId,
+      raw: payload,
+      requestId: payload.requestId,
+      stream: Boolean(payload.stream)
+    });
+  }
+  function sendAgentReply(input) {
+    const activeWs = connections.get(accountId) ?? ws;
+    if (!activeWs || activeWs.readyState !== WebSocket.OPEN) {
+      console.error("[sumeclaw] \u274C cannot send agent_reply, websocket is not open", {
+        accountId,
+        requestId: input.requestId,
+        readyState: activeWs?.readyState
+      });
+      return false;
+    }
+    activeWs.send(
+      JSON.stringify({
+        type: "agent_reply",
+        requestId: input.requestId,
+        userId: input.userId,
+        sessionKey: input.sessionKey,
+        text: input.text,
+        messageId: input.messageId ?? `sumeclaw-${Date.now()}`,
+        ok: input.ok ?? true
+      })
+    );
+    console.log("[sumeclaw] \u{1F4E4} agent_reply sent", {
+      accountId,
+      requestId: input.requestId,
+      userId: input.userId,
+      textLength: input.text.length
+    });
+    return true;
+  }
+  function sendAgentDelta(input) {
+    const activeWs = connections.get(accountId) ?? ws;
+    if (!activeWs || activeWs.readyState !== WebSocket.OPEN) {
+      console.error("[sumeclaw] \u274C cannot send agent_delta, websocket is not open", {
+        accountId,
+        requestId: input.requestId,
+        readyState: activeWs?.readyState
+      });
+      return false;
+    }
+    activeWs.send(
+      JSON.stringify({
+        type: "agent_delta",
+        requestId: input.requestId,
+        userId: input.userId,
+        sessionKey: input.sessionKey,
+        text: input.text,
+        messageId: input.messageId ?? `sumeclaw-${Date.now()}`
+      })
+    );
+    console.log("[sumeclaw] \u{1F4E4} agent_delta sent", {
+      accountId,
+      requestId: input.requestId,
+      userId: input.userId,
+      textLength: input.text.length
+    });
+    return true;
+  }
+  function sendAgentDone(input) {
+    const activeWs = connections.get(accountId) ?? ws;
+    if (!activeWs || activeWs.readyState !== WebSocket.OPEN) {
+      console.error("[sumeclaw] \u274C cannot send agent_done, websocket is not open", {
+        accountId,
+        requestId: input.requestId,
+        readyState: activeWs?.readyState
+      });
+      return false;
+    }
+    activeWs.send(
+      JSON.stringify({
+        type: "agent_done",
+        requestId: input.requestId,
+        userId: input.userId,
+        sessionKey: input.sessionKey,
+        text: input.text,
+        messageId: input.messageId ?? `sumeclaw-${Date.now()}`,
+        ok: input.ok ?? true
+      })
+    );
+    console.log("[sumeclaw] \u{1F4E4} agent_done sent", {
+      accountId,
+      requestId: input.requestId,
+      userId: input.userId,
+      textLength: input.text.length
+    });
+    return true;
+  }
+  function finishStreamReply(input) {
+    const latest = consumePendingReplyContext(accountId, input.userId);
+    if (!latest) {
+      console.warn("[sumeclaw] \u26A0\uFE0F no pending stream context to finish", {
+        accountId,
+        requestId: input.requestId,
+        userId: input.userId
+      });
+      return false;
+    }
+    return sendAgentDone({
+      requestId: latest.requestId ?? input.requestId,
+      userId: input.userId,
+      sessionKey: latest.sessionKey ?? input.sessionKey,
+      text: latest.accumulatedText,
+      ok: input.ok
+    });
+  }
+  function finishBufferedReply(input) {
+    const latest = consumePendingReplyContext(accountId, input.userId);
+    if (!latest) {
+      console.warn("[sumeclaw] \u26A0\uFE0F no pending reply context to finish", {
+        accountId,
+        requestId: input.requestId,
+        userId: input.userId
+      });
+      return false;
+    }
+    return sendAgentReply({
+      requestId: latest.requestId ?? input.requestId,
+      userId: input.userId,
+      sessionKey: latest.sessionKey ?? input.sessionKey,
+      text: latest.accumulatedText,
+      ok: input.ok
+    });
+  }
+  async function dispatchToOpenClaw(input) {
+    const runtime = tryGetSumeclawRuntime() ?? api?.runtime;
+    const turn = runtime?.channel?.turn;
+    if (!turn?.run) {
+      const directReplyDispatcher = runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher;
+      if (directReplyDispatcher) {
+        await dispatchViaDirectDmRuntime(runtime, input);
+        return;
+      }
+      console.error(
+        "[sumeclaw] \u274C \u5F53\u524D OpenClaw runtime \u4E0D\u63D0\u4F9B\u53EF\u7528\u7684 channel \u5165\u7AD9\u5206\u53D1\u80FD\u529B"
+      );
+      console.error("[sumeclaw] runtime debug:", {
+        hasStoredRuntime: Boolean(tryGetSumeclawRuntime()),
+        apiKeys: api ? Object.keys(api) : [],
+        runtimeKeys: runtime ? Object.keys(runtime) : [],
+        channelKeys: runtime?.channel ? Object.keys(runtime.channel) : []
+      });
+      sendAgentReply({
+        requestId: input.requestId,
+        userId: input.userId,
+        sessionKey: input.sessionKey,
+        text: "OpenClaw \u63D2\u4EF6\u672A\u83B7\u5F97\u8FD0\u884C\u65F6\u5206\u53D1\u80FD\u529B\uFF0C\u8BF7\u5347\u7EA7\u63D2\u4EF6\u5165\u53E3\u540E\u91CD\u542F OpenClaw Gateway\u3002",
+        ok: false
+      });
+      return;
+    }
+    const now = Date.now();
+    const messageId = String(input.messageId || `${input.sessionKey}:${now}`);
+    const senderLabel = `\u53CB\u867E\u7528\u6237 ${input.userId}`;
+    try {
+      const result = await turn.run({
+        channel: "sumeclaw",
+        accountId,
+        raw: input.raw,
+        adapter: {
+          ingest() {
+            return {
+              id: messageId,
+              timestamp: now,
+              rawText: input.message,
+              textForAgent: input.message,
+              textForCommands: input.message,
+              raw: input.raw
+            };
+          },
+          classify(turnInput) {
+            return {
+              kind: "message",
+              canStartAgentTurn: Boolean(turnInput.rawText)
+            };
+          },
+          resolveTurn(turnInput) {
+            return {
+              sender: {
+                id: input.userId,
+                name: senderLabel,
+                displayLabel: senderLabel,
+                isBot: false,
+                isSelf: false
+              },
+              conversation: {
+                kind: "direct",
+                id: input.userId,
+                label: senderLabel,
+                routePeer: input.userId
+              },
+              route: {
+                agentId: input.agentId,
+                accountId,
+                routeSessionKey: input.sessionKey,
+                dispatchSessionKey: input.sessionKey,
+                persistedSessionKey: input.sessionKey,
+                mainSessionKey: input.sessionKey,
+                createIfMissing: true
+              },
+              reply: {
+                to: input.userId,
+                originatingTo: input.userId,
+                replyTarget: input.userId,
+                sourceReplyDeliveryMode: "direct"
+              },
+              access: {
+                dm: {
+                  policy: "open",
+                  allowed: true,
+                  allowFrom: []
+                },
+                group: {
+                  isGroup: false,
+                  routeAllowed: true,
+                  senderAllowed: true,
+                  requireMention: false
+                },
+                commands: {
+                  authorized: true
+                },
+                mentions: {
+                  canDetectMention: false,
+                  wasMentioned: true
+                }
+              },
+              message: {
+                body: turnInput.rawText,
+                rawBody: turnInput.rawText,
+                bodyForAgent: turnInput.textForAgent,
+                commandBody: turnInput.textForCommands,
+                envelopeFrom: senderLabel,
+                senderLabel,
+                preview: turnInput.rawText.slice(0, 120)
+              },
+              delivery: {
+                deliver: async (payload) => {
+                  const text = String(payload?.text || payload?.body || "");
+                  if (!text) return { visibleReplySent: false };
+                  const replyId = `sumeclaw-${Date.now()}`;
+                  if (input.stream) {
+                    appendPendingReplyText(accountId, input.userId, text);
+                    sendAgentDelta({
+                      requestId: input.requestId,
+                      userId: input.userId,
+                      sessionKey: input.sessionKey,
+                      text,
+                      messageId: replyId
+                    });
+                  } else {
+                    appendPendingReplyText(accountId, input.userId, text);
+                  }
+                  return {
+                    messageIds: [replyId],
+                    visibleReplySent: true
+                  };
+                },
+                onError(err) {
+                  console.error("[sumeclaw] \u274C deliver error", err);
+                }
+              }
+            };
+          }
+        }
+      });
+      console.log("[sumeclaw] \u2705 OpenClaw turn dispatched", result?.admission ?? "");
+      if (input.stream) {
+        finishStreamReply(input);
+      } else {
+        finishBufferedReply(input);
+      }
+    } catch (err) {
+      console.error("[sumeclaw] \u274C OpenClaw turn dispatch failed", err);
+      sendAgentReply({
+        requestId: input.requestId,
+        userId: input.userId,
+        sessionKey: input.sessionKey,
+        text: "OpenClaw \u672C\u5730\u5904\u7406\u6D88\u606F\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002",
+        ok: false
+      });
+    }
+  }
+  async function dispatchViaDirectDmRuntime(runtime, input) {
+    const now = Date.now();
+    const messageId = String(input.messageId || `${input.sessionKey}:${now}`);
+    const senderLabel = `\u53CB\u867E\u7528\u6237 ${input.userId}`;
+    const baseCfg = api?.getConfig?.() ?? api?.config ?? runtime?.config ?? {};
+    const cfg = input.stream ? {
+      ...baseCfg,
+      agents: {
+        ...baseCfg.agents ?? {},
+        defaults: {
+          ...baseCfg.agents?.defaults ?? {},
+          blockStreamingDefault: "on",
+          blockStreamingBreak: "text_end",
+          blockStreamingChunk: {
+            minChars: 12,
+            maxChars: 80,
+            breakPreference: "sentence",
+            ...baseCfg.agents?.defaults?.blockStreamingChunk ?? {}
+          }
+        }
+      },
+      channels: {
+        ...baseCfg.channels ?? {},
+        sumeclaw: {
+          ...baseCfg.channels?.sumeclaw ?? {},
+          blockStreaming: true
+        }
+      }
+    } : baseCfg;
+    try {
+      await dispatchInboundDirectDmWithRuntime({
+        cfg,
+        runtime,
+        channel: "sumeclaw",
+        channelLabel: "\u53CB\u867E\u540D\u7247",
+        accountId,
+        peer: {
+          kind: "direct",
+          id: input.userId
+        },
+        senderId: input.userId,
+        senderAddress: input.userId,
+        recipientAddress: "sumeclaw",
+        conversationLabel: senderLabel,
+        rawBody: input.message,
+        messageId,
+        timestamp: now,
+        bodyForAgent: input.message,
+        commandBody: input.message,
+        commandAuthorized: true,
+        provider: "sumeclaw",
+        surface: "sumeclaw",
+        originatingChannel: "sumeclaw",
+        originatingTo: input.userId,
+        extraContext: {
+          AccountId: accountId,
+          RouteAgentId: input.agentId,
+          RequestId: input.requestId
+        },
+        deliver: async (payload) => {
+          const text = String(payload?.text || payload?.body || "");
+          if (!text) return { visibleReplySent: false };
+          const replyId = `sumeclaw-${Date.now()}`;
+          if (input.stream) {
+            appendPendingReplyText(accountId, input.userId, text);
+            sendAgentDelta({
+              requestId: input.requestId,
+              userId: input.userId,
+              sessionKey: input.sessionKey,
+              text,
+              messageId: replyId
+            });
+          } else {
+            appendPendingReplyText(accountId, input.userId, text);
+          }
+          return {
+            messageIds: [replyId],
+            visibleReplySent: true
+          };
+        },
+        onDispatchError: (err) => {
+          console.error("[sumeclaw] \u274C Direct DM dispatch error", err);
+        },
+        onRecordError: (err) => {
+          console.error("[sumeclaw] \u274C Direct DM record error", err);
+        }
+      });
+      console.log("[sumeclaw] \u2705 OpenClaw Direct DM dispatched");
+      if (input.stream) {
+        finishStreamReply(input);
+      } else {
+        finishBufferedReply(input);
+      }
+    } catch (err) {
+      console.error("[sumeclaw] \u274C Direct DM dispatch failed", err);
+      sendAgentReply({
+        requestId: input.requestId,
+        userId: input.userId,
+        sessionKey: input.sessionKey,
+        text: "OpenClaw \u672C\u5730\u5904\u7406\u6D88\u606F\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002",
+        ok: false
+      });
+    }
+  }
+  function cleanup() {
+    connectingAccounts.delete(accountId);
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    if (connections.get(accountId) === ws) {
+      connections.delete(accountId);
+    }
+  }
+  function scheduleReconnect() {
+    if (reconnectTimer) return;
+    console.log(`[sumeclaw] \u{1F501} reconnecting in ${RECONNECT_DELAY / 1e3}s`);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      start();
+    }, RECONNECT_DELAY);
+  }
+  start();
+}
+
+// src/channel.ts
+import {
+  createChatChannelPlugin,
+  createChannelPluginBase
+} from "openclaw/plugin-sdk/channel-core";
+var channelKey = "sumeclaw";
+var channelConfigAdapter = {
+  listAccountIds(cfg) {
+    const accounts = cfg.channels?.[channelKey]?.accounts ?? {};
+    return Object.keys(accounts);
+  },
+  resolveAccount(cfg, accountId) {
+    const accounts = cfg.channels?.[channelKey]?.accounts ?? {};
+    return accounts[accountId ?? "default"] ?? {};
+  }
+};
+var setupWizard = {
+  channel: channelKey,
+  /** 根据当前配置显示连接状态 */
+  status: {
+    configuredLabel: "\u5DF2\u8FDE\u63A5\u53CB\u867E\u540D\u7247",
+    unconfiguredLabel: "\u5C1A\u672A\u914D\u7F6E",
+    resolveConfigured: ({ cfg }) => {
+      const accounts = cfg.channels?.[channelKey]?.accounts ?? {};
+      return Object.values(accounts).some((acct) => acct?.botToken);
+    }
+  },
+  /** 交互式凭据收集 — 引导用户输入 botToken */
+  credentials: [
+    {
+      inputKey: "botToken",
+      credentialLabel: "\u53CB\u867E\u8FDE\u63A5\u7801",
+      preferredEnvVar: "SUMECLAW_BOT_TOKEN",
+      envPrompt: "\u662F\u5426\u4F7F\u7528\u73AF\u5883\u53D8\u91CF SUMECLAW_BOT_TOKEN\uFF1F",
+      keepPrompt: "\u4FDD\u7559\u5F53\u524D botToken\uFF1F",
+      inputPrompt: "\u8BF7\u8F93\u5165\u4ECE\u53CB\u867E\u5C0F\u7A0B\u5E8F\u83B7\u53D6\u7684 botToken\uFF1A",
+      inspect: ({ cfg, accountId }) => {
+        const token = cfg.channels?.[channelKey]?.accounts?.[accountId ?? "default"]?.botToken;
+        return {
+          accountConfigured: Boolean(token),
+          hasConfiguredValue: Boolean(token)
+        };
+      }
+    }
+  ]
+};
+var sumeclawPlugin = createChatChannelPlugin({
+  base: createChannelPluginBase({
+    id: channelKey,
+    setupWizard,
+    setup: {
+      /**
+       * 从用户配置中解析账户信息
+       */
+      resolveAccount(cfg, accountId) {
+        const accounts = cfg.channels?.[channelKey]?.accounts ?? {};
+        return accounts[accountId ?? "default"] ?? {};
+      },
+      /**
+       * 检查账户配置状态
+       */
+      inspectAccount(cfg, accountId) {
+        const account = cfg.channels?.[channelKey]?.accounts?.[accountId ?? "default"];
+        return {
+          enabled: !!account?.botToken,
+          configured: !!account?.botToken
+        };
+      }
+    }
+  }),
+  /**
+   * 渠道配置适配器 (ChannelConfigAdapter)
+   */
+  config: channelConfigAdapter,
+  /**
+   * DM 安全策略
+   *
+   * 友虾名片场景下，所有通过名片访问的用户都允许对话。
+   * 名片主可在小程序端管理黑名单（后续扩展）。
+   */
+  security: {
+    dm: {
+      channelKey: "sumeclaw",
+      resolvePolicy: () => "open",
+      defaultPolicy: "open"
+    }
+  },
+  /**
+   * 出站消息处理
+   *
+   * 当 OpenClaw Agent 生成回复后，通过 WebSocket 推回友虾名片平台。
+   */
+  outbound: {
+    attachedResults: {
+      sendText: async ({ text, to, accountId }) => {
+        const resolvedAccountId = accountId ?? "default";
+        const ws = getWebSocket(resolvedAccountId);
+        if (!ws || ws.readyState !== 1) {
+          throw new Error("WebSocket \u672A\u8FDE\u63A5\u5230\u53CB\u867E\u540D\u7247\u5E73\u53F0");
+        }
+        const pending = getPendingReplyContext(resolvedAccountId, to);
+        const messageId = `sumeclaw-${Date.now()}`;
+        if (pending?.stream) {
+          appendPendingReplyText(resolvedAccountId, to, text);
+          ws.send(
+            JSON.stringify({
+              type: "agent_delta",
+              requestId: pending.requestId,
+              userId: to,
+              sessionKey: pending.sessionKey,
+              text,
+              messageId
+            })
+          );
+          console.log("[sumeclaw] \u{1F4E4} outbound agent_delta sent", {
+            accountId: resolvedAccountId,
+            requestId: pending.requestId,
+            userId: to,
+            textLength: text.length
+          });
+          return { messageId };
+        }
+        if (pending && !pending.stream) {
+          appendPendingReplyText(resolvedAccountId, to, text);
+          console.log("[sumeclaw] \u{1F4E5} outbound reply buffered", {
+            accountId: resolvedAccountId,
+            requestId: pending.requestId,
+            userId: to,
+            textLength: text.length
+          });
+          return { messageId };
+        }
+        const finalPending = consumePendingReplyContext(resolvedAccountId, to);
+        ws.send(
+          JSON.stringify({
+            type: "agent_reply",
+            requestId: finalPending?.requestId,
+            userId: to,
+            sessionKey: finalPending?.sessionKey,
+            text,
+            messageId
+          })
+        );
+        console.log("[sumeclaw] \u{1F4E4} outbound agent_reply sent", {
+          accountId: resolvedAccountId,
+          requestId: finalPending?.requestId,
+          userId: to,
+          textLength: text.length
+        });
+        return { messageId };
+      }
+    }
+  }
+});
+sumeclawPlugin.config ??= channelConfigAdapter;
+
+export {
+  setSumeclawRuntime,
+  connectGateway,
+  sumeclawPlugin
+};
+//# sourceMappingURL=chunk-RIUKFLMY.js.map