@buz-extensions/buz 1.0.0-beta.17 → 1.0.0-beta.18

package/index.ts

@@ -1,6 +1,8 @@
 import type { ChannelPlugin, OpenClawPluginApi } from "openclaw/plugin-sdk/line";
 import { emptyPluginConfigSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/line";
 import { z } from "zod";
+import { normalizeBuzTarget, looksLikeBuzId } from "./src/targets.js";
+import { resolveBuzOutboundSessionRoute } from "./src/session-route.js";
 
 const BuzAccountSchema = z
   .object({
@@ -48,7 +50,25 @@ export const buzChannelPlugin = {
     threads: true,
     media: false,
   },
-  configSchema: buildChannelConfigSchema(BuzConfigSchema),
+  configSchema: {
+    ...buildChannelConfigSchema(BuzConfigSchema),
+    uiHints: {
+      serverAddress: {
+        label: "Server Address",
+      },
+      secretKey: {
+        label: "Secret Key",
+        sensitive: false,
+      },
+      "accounts.*.serverAddress": {
+        label: "Server Address",
+      },
+      "accounts.*.secretKey": {
+        label: "Secret Key",
+        sensitive: false,
+      },
+    },
+  },
   config: {
     listAccountIds: (cfg: any) => {
       const accounts = cfg?.channels?.["buz"]?.accounts || {};
@@ -90,12 +110,17 @@ export const buzChannelPlugin = {
     }),
   },
   messaging: {
-    normalizeTarget: (target: string) => target,
+    normalizeTarget: (target: string) => normalizeBuzTarget(target) ?? undefined,
     targetResolver: {
-      looksLikeId: (_id: string) => true,
+      looksLikeId: looksLikeBuzId,
       hint: "<targetId>",
     },
-    resolveSessionTarget: ({ id }: any) => id,
+    resolveSessionTarget: ({ kind, id }: any) => {
+      if (kind === "group") return `buz:group:${id}`;
+      return `buz:user:${id}`;
+    },
+    resolveOutboundSessionRoute: (params: any) => resolveBuzOutboundSessionRoute(params),
+
   },
   setup: {
     validateInput: async (params: any) => {
@@ -112,6 +137,20 @@ export const buzChannelPlugin = {
     deliveryMode: "direct",
     chunker: null,
     textChunkLimit: 4000,
+    resolveTarget: ({ to }: { to?: string; cfg?: any; allowFrom?: string[]; accountId?: string | null; mode?: "explicit" | "implicit" }) => {
+      const trimmed = to?.trim() ?? "";
+      if (!trimmed) {
+        return { ok: true, to: "" };
+      }
+      const normalized = normalizeBuzTarget(trimmed);
+      if (!normalized) {
+        return {
+          ok: false,
+          error: new Error("Delivering to buz requires a valid target <targetId> when delivery.to is specified."),
+        };
+      }
+      return { ok: true, to: normalized };
+    },
     sendText: async ({ to, text, accountId, replyToId, threadId, cfg }: any) => {
       const { sendText } = await import("./src/outbound.js");
       return await sendText({ to, text, accountId, replyToId, threadId, cfg });

package/openclaw.plugin.json

@@ -1,6 +1,8 @@
 {
   "id": "buz",
-  "channels": ["buz"],
+  "channels": [
+    "buz"
+  ],
   "name": "buz Plugin",
   "description": "Connects OpenClaw to buz",
   "enabledByDefault": true,
@@ -36,5 +38,21 @@
         }
       }
     }
+  },
+  "uiHints": {
+    "serverAddress": {
+      "label": "Server Address"
+    },
+    "secretKey": {
+      "label": "Secret Key",
+      "sensitive": false
+    },
+    "accounts.*.serverAddress": {
+      "label": "Server Address"
+    },
+    "accounts.*.secretKey": {
+      "label": "Secret Key",
+      "sensitive": false
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buz-extensions/buz",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.18",
   "description": "OpenClaw buz channel plugin",
   "type": "module",
   "license": "MIT",

package/src/gateway.ts

@@ -10,6 +10,11 @@ const __dirname = dirname(__filename);
 
 export const activeStreams = new Map<string, grpc.ClientDuplexStream<any, any>>();
 export const activeClients = new Map<string, any>();
+const streamReadyState = new Map<string, boolean>();
+const streamWaiters = new Map<
+  string,
+  Array<{ resolve: (stream: grpc.ClientDuplexStream<any, any>) => void; reject: (err: Error) => void }>
+>();
 
 function setStatus(ctx: any, patch: Record<string, unknown>) {
   console.log(`[buz gateway] setStatus called:`, patch);
@@ -19,6 +24,66 @@ function setStatus(ctx: any, patch: Record<string, unknown>) {
   });
 }
 
+function resolvePendingWaiters(accountId: string, stream: grpc.ClientDuplexStream<any, any>) {
+  const waiters = streamWaiters.get(accountId);
+  if (!waiters?.length) {
+    return;
+  }
+  streamWaiters.delete(accountId);
+  for (const waiter of waiters) {
+    waiter.resolve(stream);
+  }
+}
+
+function rejectPendingWaiters(accountId: string, err: Error) {
+  const waiters = streamWaiters.get(accountId);
+  if (!waiters?.length) {
+    return;
+  }
+  streamWaiters.delete(accountId);
+  for (const waiter of waiters) {
+    waiter.reject(err);
+  }
+}
+
+export function isStreamReady(accountId: string): boolean {
+  return streamReadyState.get(accountId) === true && activeStreams.has(accountId);
+}
+
+export async function waitForReadyStream(
+  accountId: string,
+  timeoutMs = 3000,
+): Promise<grpc.ClientDuplexStream<any, any>> {
+  const existing = activeStreams.get(accountId);
+  if (existing && isStreamReady(accountId)) {
+    return existing;
+  }
+
+  return await new Promise<grpc.ClientDuplexStream<any, any>>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      const waiters = streamWaiters.get(accountId) ?? [];
+      streamWaiters.set(
+        accountId,
+        waiters.filter((entry) => entry.resolve !== wrappedResolve),
+      );
+      reject(new Error(`[buz] Timed out waiting for ready gRPC stream for account ${accountId}`));
+    }, timeoutMs);
+
+    const wrappedResolve = (stream: grpc.ClientDuplexStream<any, any>) => {
+      clearTimeout(timer);
+      resolve(stream);
+    };
+    const wrappedReject = (err: Error) => {
+      clearTimeout(timer);
+      reject(err);
+    };
+
+    const current = streamWaiters.get(accountId) ?? [];
+    current.push({ resolve: wrappedResolve, reject: wrappedReject });
+    streamWaiters.set(accountId, current);
+  });
+}
+
 export async function startGateway(ctx: any, serverAddress: string, secretKey: string) {
   const PROTO_PATH = resolve(__dirname, "../proto/buz.proto");
 
@@ -71,6 +136,8 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
   let reconnectAttempts = 0;
   let everConnected = false;
   let isActive = true;
+  let isConnecting = false;
+  let connectionGeneration = 0;
   let pingInterval: NodeJS.Timeout | null = null;
   let reconnectTimer: NodeJS.Timeout | null = null;
 
@@ -80,31 +147,53 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
       clearInterval(pingInterval);
       pingInterval = null;
     }
+    streamReadyState.set(accountId, false);
+    activeStreams.delete(accountId);
     if (stream) {
-      activeStreams.delete(accountId);
-      stream.removeAllListeners();
+      const current = stream;
       stream = null;
+      current.removeAllListeners();
+      try {
+        current.cancel();
+      } catch (err: any) {
+        console.warn("[buz gateway] stream cancel during cleanup failed:", err?.message || String(err));
+      }
+    }
+  };
+
+  const clearReconnectTimer = () => {
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
     }
   };
 
   const scheduleReconnect = (reason?: string) => {
     console.log(`[buz gateway] scheduleReconnect called, reason: ${reason || "none"}`);
+    isConnecting = false;
+    connectionGeneration += 1;
     cleanupStream();
-    // Keep running: true during reconnect attempts
+    rejectPendingWaiters(
+      accountId,
+      new Error(`[buz] gRPC stream unavailable for account ${accountId}${reason ? `: ${reason}` : ""}`),
+    );
     setStatus(ctx, {
       connected: false,
-      running: true, // Still trying to run
+      running: true,
       ...(reason ? { lastError: reason } : {}),
     });
 
     if (!isActive || ctx.abortSignal?.aborted) {
       console.log("[buz gateway] aborting reconnect (isActive=false or aborted)");
+      clearReconnectTimer();
       return;
     }
 
+    clearReconnectTimer();
+    const nextAttempt = reconnectAttempts + 1;
     const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
-    reconnectAttempts += 1;
-    console.log(`[buz gateway] reconnecting in ${delay}ms (attempt ${reconnectAttempts})`);
+    reconnectAttempts = nextAttempt;
+    console.log(`[buz gateway] reconnecting in ${delay}ms (attempt ${nextAttempt})`);
     ctx.log?.warn?.(
       `[${accountId}] buz gRPC disconnected${reason ? `: ${reason}` : ""}; reconnecting in ${delay}ms`,
     );
@@ -120,15 +209,21 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
       console.log("[buz gateway] aborting connect (isActive=false or aborted)");
       return;
     }
+    if (isConnecting) {
+      console.log("[buz gateway] connect skipped: already connecting");
+      return;
+    }
 
+    clearReconnectTimer();
+    isConnecting = true;
+    const generation = ++connectionGeneration;
     cleanupStream();
     setStatus(ctx, {
       connected: false,
-      running: true, // Mark as running while connecting
+      running: true,
       lastError: everConnected ? null : "connecting",
     });
 
-    // Create metadata with authorization header
     const metadata = new grpc.Metadata();
     metadata.add("authorization", `Bearer ${secretKey}`);
     metadata.add("x-openclaw-id", accountId);
@@ -138,6 +233,7 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
       stream = client.ConnectStream(metadata);
       console.log("[buz gateway] stream created:", !!stream);
     } catch (err: any) {
+      isConnecting = false;
       console.error("[buz gateway] failed to create gRPC stream:", err?.message || String(err));
       ctx.log?.error?.(
         `[${accountId}] failed to create gRPC stream: ${err?.message || String(err)}`,
@@ -147,16 +243,15 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
     }
 
     if (!stream) {
+      isConnecting = false;
       console.error("[buz gateway] stream is null after creation");
       ctx.log?.error?.(`[${accountId}] failed to create gRPC stream: stream is null`);
       scheduleReconnect("stream is null");
       return;
     }
 
-    activeStreams.set(accountId, stream);
-    console.log("[buz gateway] stream stored, total active streams:", activeStreams.size);
+    streamReadyState.set(accountId, false);
 
-    // Send auth request via message body (for backward compatibility)
     const authRequest = {
       auth_req: {
         secret_key: secretKey,
@@ -167,19 +262,25 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
     try {
       stream.write(authRequest);
     } catch (err: any) {
+      isConnecting = false;
       console.error("[buz gateway] failed to send auth request:", err?.message);
-      // Don't schedule reconnect here, let the stream error handler deal with it
+      scheduleReconnect(err?.message || "failed to send auth request");
+      return;
     }
 
     stream.on("data", async (msg: any) => {
-      console.log("[buz gateway] stream received data:", Object.keys(msg));
-
+      if (generation !== connectionGeneration) {
+        console.log("[buz gateway] ignoring data from stale generation", generation, connectionGeneration);
+        return;
+      }
       if (msg.auth_res) {
-        console.log("[buz gateway] received auth_res:", msg.auth_res);
         if (msg.auth_res.success) {
+          isConnecting = false;
           everConnected = true;
           reconnectAttempts = 0;
-          // IMPORTANT: Must include running: true
+          activeStreams.set(accountId, stream!);
+          streamReadyState.set(accountId, true);
+          resolvePendingWaiters(accountId, stream!);
           setStatus(ctx, {
             running: true,
             connected: true,
@@ -191,8 +292,7 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
 
           if (pingInterval) clearInterval(pingInterval);
           pingInterval = setInterval(() => {
-            console.log("[buz gateway] sending heartbeat");
-            if (stream) {
+            if (stream && streamReadyState.get(accountId) === true) {
               try {
                 stream.write({
                   ping: { timestamp: Date.now() },
@@ -206,6 +306,7 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
           }, 30000);
           console.log("[buz gateway] heartbeat interval set (30s)");
         } else {
+          isConnecting = false;
           const reason = `Auth failed: ${msg.auth_res.error_message || "unknown error"}`;
           console.error("[buz gateway] authentication failed:", reason);
           ctx.log?.error?.(`[${accountId}] ${reason}`);
@@ -216,7 +317,6 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
 
       if (msg.inbound_msg) {
         console.log("[buz gateway] received inbound message");
-        // Update lastInboundAt when receiving messages
         setStatus(ctx, {
           lastInboundAt: Date.now(),
           running: true,
@@ -234,11 +334,21 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
     });
 
     stream.on("end", () => {
+      if (generation !== connectionGeneration) {
+        console.log("[buz gateway] ignoring end from stale generation", generation, connectionGeneration);
+        return;
+      }
+      isConnecting = false;
       console.log("[buz gateway] stream ended");
       scheduleReconnect("stream ended");
     });
 
     stream.on("error", (err: any) => {
+      if (generation !== connectionGeneration) {
+        console.log("[buz gateway] ignoring error from stale generation", generation, connectionGeneration);
+        return;
+      }
+      isConnecting = false;
       const reason = err?.message || String(err);
       console.error("[buz gateway] stream error:", reason);
       ctx.log?.error?.(`[${accountId}] gRPC stream error: ${reason}`);
@@ -250,7 +360,7 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
 
   console.log("[buz gateway] initializing connection...");
   setStatus(ctx, {
-    running: true, // Mark as running from the start
+    running: true,
     connected: false,
     lastError: null,
     lastStartAt: Date.now(),
@@ -265,12 +375,8 @@ export async function startGateway(ctx: any, serverAddress: string, secretKey: s
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
+    rejectPendingWaiters(accountId, new Error(`[buz] gateway aborted for account ${accountId}`));
     cleanupStream();
-    const activeStream = activeStreams.get(accountId);
-    if (activeStream) {
-      activeStream.cancel();
-      activeStreams.delete(accountId);
-    }
     const activeClient = activeClients.get(accountId);
     if (activeClient) {
       activeClient.close();
@@ -296,10 +402,17 @@ export async function stopGateway(ctx: any) {
   const accountId = ctx.account?.accountId || "default";
   console.log("[buz gateway] stopping account:", accountId);
 
+  streamReadyState.set(accountId, false);
+  rejectPendingWaiters(accountId, new Error(`[buz] stop requested for account ${accountId}`));
+
   const stream = activeStreams.get(accountId);
   if (stream) {
     console.log("[buz gateway] cancelling stream");
-    stream.cancel();
+    try {
+      stream.cancel();
+    } catch (err: any) {
+      console.warn("[buz gateway] stopGateway cancel failed:", err?.message || String(err));
+    }
     activeStreams.delete(accountId);
   }
 

package/src/inbound.ts

@@ -58,7 +58,7 @@ async function emitIntermediate(params: {
   text?: string;
 }) {
   const { toTarget, accountId, messageSid, type, event, text } = params;
-  if (!text && type !== "assistant_message_start") {
+  if (!text && type !== "assistant_message_start" && !(type === "reasoning" && event === "done")) {
     return;
   }
   await sendText({
@@ -139,7 +139,29 @@ export async function handleInboundMessage(ctx: any, inboundMsg: any) {
   console.log("[buz inbound] storePath:", storePath);
   console.log("[buz inbound] dispatching via recordInboundSessionAndDispatchReply...");
 
+  let streamEventQueue = Promise.resolve();
+  let lastPartialText = "";
+  let lastReasoningText = "";
+  const enqueueStreamEvent = (task: () => Promise<void>) => {
+    const next = streamEventQueue.then(task);
+    streamEventQueue = next.catch((err) => {
+      console.error("[buz inbound] stream event failed:", err);
+    });
+    return next;
+  };
+
   try {
+    await core.channel.session.updateLastRoute({
+      storePath,
+      sessionKey: ctxPayload.SessionKey ?? sessionKey,
+      deliveryContext: {
+        channel: "buz",
+        to: isGroup ? `buz:group:${conversationId}` : `buz:user:${senderId}`,
+        accountId,
+      },
+      ctx: ctxPayload,
+    });
+
     await recordInboundSessionAndDispatchReply({
       cfg,
       channel: "buz",
@@ -151,19 +173,21 @@ export async function handleInboundMessage(ctx: any, inboundMsg: any) {
       recordInboundSession: core.channel.session.recordInboundSession,
       dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
       deliver: async (payload: any) => {
-        console.log("[buz inbound] deliver called text:", payload?.text?.substring?.(0, 50));
-        if (!payload?.text) {
-          return;
-        }
-        await sendText({
-          to: toTarget,
-          text: payload.text,
-          accountId,
-          replyToId: messageSid,
-          type: payload?.isReasoning ? "reasoning" : "final_reply",
-          event: "done",
+        await enqueueStreamEvent(async () => {
+          console.log("[buz inbound] deliver called text:", payload?.text?.substring?.(0, 50));
+          if (!payload?.text) {
+            return;
+          }
+          await sendText({
+            to: toTarget,
+            text: payload.text,
+            accountId,
+            replyToId: messageSid,
+            type: payload?.isReasoning ? "reasoning" : "final_reply",
+            event: "done",
+          });
+          console.log("[buz inbound] reply sent successfully via gRPC");
         });
-        console.log("[buz inbound] reply sent successfully via gRPC");
       },
       onRecordError: (err: any) => {
         console.error("[buz inbound] failed to record session:", err);
@@ -174,60 +198,83 @@ export async function handleInboundMessage(ctx: any, inboundMsg: any) {
       replyOptions: {
         disableBlockStreaming: false,
         onPartialReply: async (payload: any) => {
-          await emitIntermediate({
-            toTarget,
-            accountId,
-            messageSid,
-            type: "partial_reply",
-            event: "delta",
-            text: payload?.text,
+          const text = String(payload?.text || "");
+          if (!text || text === lastPartialText) {
+            return;
+          }
+          lastPartialText = text;
+          await enqueueStreamEvent(async () => {
+            await emitIntermediate({
+              toTarget,
+              accountId,
+              messageSid,
+              type: "partial_reply",
+              event: "delta",
+              text,
+            });
           });
         },
         onReasoningStream: async (payload: any) => {
-          await emitIntermediate({
-            toTarget,
-            accountId,
-            messageSid,
-            type: "reasoning",
-            event: "delta",
-            text: payload?.text,
+          const text = String(payload?.text || "");
+          if (!text || text === lastReasoningText) {
+            return;
+          }
+          lastReasoningText = text;
+          await enqueueStreamEvent(async () => {
+            await emitIntermediate({
+              toTarget,
+              accountId,
+              messageSid,
+              type: "reasoning",
+              event: "delta",
+              text,
+            });
           });
         },
         onAssistantMessageStart: async () => {
-          await emitIntermediate({
-            toTarget,
-            accountId,
-            messageSid,
-            type: "assistant_message_start",
-            event: "start",
-            text: "",
+          await enqueueStreamEvent(async () => {
+            lastPartialText = "";
+            await emitIntermediate({
+              toTarget,
+              accountId,
+              messageSid,
+              type: "assistant_message_start",
+              event: "start",
+              text: "",
+            });
           });
         },
         onReasoningEnd: async () => {
-          await emitIntermediate({
-            toTarget,
-            accountId,
-            messageSid,
-            type: "reasoning",
-            event: "done",
-            text: "",
+          await enqueueStreamEvent(async () => {
+            lastReasoningText = "";
+            await emitIntermediate({
+              toTarget,
+              accountId,
+              messageSid,
+              type: "reasoning",
+              event: "done",
+              text: "",
+            });
           });
         },
         onToolStart: async (payload: any) => {
           const toolName = String(payload?.name || "tool").trim() || "tool";
           const phase = String(payload?.phase || "start").trim() || "start";
-          await emitIntermediate({
-            toTarget,
-            accountId,
-            messageSid,
-            type: "tool_start",
-            event: "start",
-            text: `${toolName}${phase ? ` (${phase})` : ""}`,
+          await enqueueStreamEvent(async () => {
+            await emitIntermediate({
+              toTarget,
+              accountId,
+              messageSid,
+              type: "tool_start",
+              event: "start",
+              text: `${toolName}${phase ? ` (${phase})` : ""}`,
+            });
           });
         },
       },
     });
 
+    await streamEventQueue;
     console.log("[buz inbound] message dispatched successfully");
     ctx.log?.info?.(
       `[${accountId}] Successfully dispatched inbound message from ${inboundMsg.sender_id}`,

package/src/outbound.ts

@@ -1,11 +1,12 @@
-import { activeStreams } from "./gateway.js";
+import { activeStreams, isStreamReady, waitForReadyStream } from "./gateway.js";
+import { getBuzRuntime } from "../index.js";
 
 function resolveTarget(to: string) {
   let chatType = "direct";
-  let targetId = to;
+  let targetId = (to || "").trim();
 
-  if (to.startsWith("buz:")) {
-    targetId = to.substring("buz:".length);
+  if (targetId.startsWith("buz:")) {
+    targetId = targetId.substring("buz:".length);
   }
 
   if (targetId.startsWith("group:")) {
@@ -21,39 +22,56 @@ function resolveTarget(to: string) {
   return { chatType, targetId };
 }
 
-export async function sendText(params: any) {
-  const { to, text, accountId, replyToId, type = "final_reply", event } = params;
+function markLastOutboundAt(accountId: string) {
+  try {
+    const runtime = getBuzRuntime();
+    const helper = runtime?.channel?.status?.setAccountRuntimePatch;
+    if (typeof helper === "function") {
+      helper({
+        channel: "buz",
+        accountId,
+        patch: { lastOutboundAt: Date.now() },
+      });
+    }
+  } catch {
+    // best effort only
+  }
+}
 
-  console.log("[buz outbound] =========================================");
-  console.log("[buz outbound] sendText called");
-  console.log("[buz outbound] to:", to);
-  console.log("[buz outbound] type:", type);
-  console.log("[buz outbound] event:", event);
-  console.log("[buz outbound] text preview:", text?.substring?.(0, 100));
-  console.log("[buz outbound] text length:", text?.length);
-  console.log("[buz outbound] accountId:", accountId);
-  console.log("[buz outbound] replyToId:", replyToId);
+async function resolveWritableStream(accountId: string) {
+  const existing = activeStreams.get(accountId);
+  if (existing && isStreamReady(accountId)) {
+    return existing;
+  }
+  return await waitForReadyStream(accountId, 3000);
+}
 
-  const targetAccountId = accountId || "default";
-  const stream = activeStreams.get(targetAccountId);
+export async function sendText(params: any) {
+  const { to, text, accountId, replyToId, type = "final_reply", event } = params;
 
-  console.log("[buz outbound] targetAccountId:", targetAccountId);
-  console.log("[buz outbound] activeStreams size:", activeStreams.size);
-  console.log("[buz outbound] stream found:", !!stream);
+  console.log("[buz outbound] sendText called:", JSON.stringify({ to, accountId, type, textLength: text?.length }));
 
-  if (!stream) {
-    console.error("[buz outbound] ERROR: No active gRPC stream for account", targetAccountId);
-    console.log("[buz outbound] activeStreams keys:", Array.from(activeStreams.keys()));
-    throw new Error(`[buz] No active gRPC stream for account ${targetAccountId}`);
-  }
+  const targetAccountId = String(accountId || "default").trim() || "default";
+  const effectiveTo = String(to || "").trim();
+  const hasExplicitTarget = Boolean(effectiveTo);
+  const { chatType, targetId } = resolveTarget(effectiveTo);
 
-  const { chatType, targetId } = resolveTarget(to);
+  console.log(
+    "[buz outbound] resolved:",
+    JSON.stringify({
+      chatType,
+      targetId,
+      originalTo: to,
+      effectiveTo,
+      routingMode: hasExplicitTarget ? "explicit-target" : "server-default-target",
+    }),
+  );
 
   const outboundMsg = {
     outbound_msg: {
       reply_to_id: replyToId || "",
-      target_id: targetId,
-      chat_type: chatType,
+      target_id: targetId || "",
+      chat_type: hasExplicitTarget ? chatType : "",
       content_text: text || "",
       type,
       event: event || "",
@@ -62,13 +80,24 @@ export async function sendText(params: any) {
 
   console.log("[buz outbound] outboundMsg:", JSON.stringify(outboundMsg, null, 2));
 
-  try {
-    stream.write(outboundMsg);
-    console.log("[buz outbound] gRPC stream write successful");
-  } catch (err: any) {
-    console.error("[buz outbound] ERROR writing to stream:", err.message);
-    throw err;
+  let lastErr: unknown;
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    try {
+      const stream = await resolveWritableStream(targetAccountId);
+      stream.write(outboundMsg);
+      markLastOutboundAt(targetAccountId);
+      console.log(`[buz outbound] gRPC stream write successful (attempt ${attempt})`);
+      return { messageId: `msg-${Date.now()}`, chatId: effectiveTo, type, event };
+    } catch (err: any) {
+      lastErr = err;
+      console.error(`[buz outbound] ERROR writing to stream (attempt ${attempt}):`, err?.message || String(err));
+      if (attempt < 2) {
+        await new Promise((resolve) => setTimeout(resolve, 600));
+      }
+    }
   }
 
-  return { messageId: `msg-${Date.now()}`, chatId: to, type, event };
+  throw lastErr instanceof Error
+    ? lastErr
+    : new Error(`[buz] Failed to send outbound message for account ${targetAccountId}`);
 }

package/src/session-route.ts

@@ -0,0 +1,36 @@
+import { getBuzRuntime } from "../index.js";
+import { parseBuzTarget } from "./targets.js";
+
+export function resolveBuzOutboundSessionRoute(params: any) {
+  const parsed = parseBuzTarget(String(params?.target || ""));
+  if (!parsed) {
+    return null;
+  }
+
+  const runtime = getBuzRuntime();
+  const buildAgentSessionKey = runtime?.channel?.routing?.buildAgentSessionKey;
+  const chatType = parsed.kind === "group" ? "group" : "direct";
+  const accountId = String(params?.accountId || "default");
+  const baseSessionKey =
+    typeof buildAgentSessionKey === "function"
+      ? buildAgentSessionKey({
+          agentId: params.agentId,
+          channel: "buz",
+          accountId,
+          chatType,
+          conversationId: parsed.id,
+        })
+      : `agent:${params.agentId}:buz:${accountId}:${chatType}:${parsed.id}`;
+
+  return {
+    sessionKey: baseSessionKey,
+    baseSessionKey,
+    peer: {
+      kind: parsed.kind === "group" ? "group" : "direct",
+      id: parsed.id,
+    },
+    chatType,
+    from: parsed.kind === "group" ? `buz:group:${parsed.id}` : `buz:${parsed.id}`,
+    to: parsed.kind === "group" ? `buz:group:${parsed.id}` : `buz:user:${parsed.id}`,
+  };
+}

package/src/targets.ts

@@ -0,0 +1,46 @@
+export function normalizeBuzTarget(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  let value = trimmed;
+  if (/^buz:/i.test(value)) {
+    value = value.replace(/^buz:/i, "").trim();
+  }
+  if (!value) {
+    return null;
+  }
+
+  if (/^(group|user):/i.test(value)) {
+    const normalized = value.replace(/^(group|user):/i, (m) => m.toLowerCase());
+    return `buz:${normalized}`;
+  }
+
+  return `buz:user:${value}`;
+}
+
+export function looksLikeBuzId(raw: string): boolean {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return Boolean(normalizeBuzTarget(trimmed));
+}
+
+export function parseBuzTarget(raw: string): { kind: "user" | "group"; id: string } | null {
+  const normalized = normalizeBuzTarget(raw);
+  if (!normalized) {
+    return null;
+  }
+  const withoutProvider = normalized.replace(/^buz:/i, "");
+  if (withoutProvider.startsWith("group:")) {
+    const id = withoutProvider.substring("group:".length).trim();
+    return id ? { kind: "group", id } : null;
+  }
+  if (withoutProvider.startsWith("user:")) {
+    const id = withoutProvider.substring("user:".length).trim();
+    return id ? { kind: "user", id } : null;
+  }
+  return null;
+}